Introduction to Volleyball National League Women Kazakhstan
The Volleyball National League Women in Kazakhstan is a thrilling arena where the best teams and players showcase their skills. With matches updated daily, fans are always on the edge of their seats, eager to witness the next big play or upset. This league not only highlights the prowess of Kazakhstani volleyball but also offers an exciting platform for expert betting predictions. Whether you're a seasoned bettor or a new enthusiast, understanding the dynamics of this league can enhance your betting strategy.
Understanding the Teams and Players
Each team in the league brings its unique strengths and strategies to the court. Key players often become focal points for betting predictions due to their consistent performance and ability to turn games around. Understanding player statistics, recent form, and head-to-head records against other teams can provide valuable insights for making informed bets.
The Thrill of Daily Matches
The excitement of daily matches ensures that fans never miss out on action-packed games. This frequent schedule keeps the league dynamic and unpredictable, offering fresh opportunities for bettors to analyze trends and make predictions. The rapid pace also means that teams must constantly adapt their strategies, adding another layer of intrigue for spectators.
Expert Betting Predictions
Expert betting predictions are a crucial aspect of engaging with the Volleyball National League Women. These predictions are based on comprehensive analysis, including team performance, player form, historical data, and even weather conditions that might affect outdoor matches. Bettors rely on these insights to make strategic decisions and increase their chances of winning.
- Team Performance: Analyzing past performances helps predict future outcomes.
- Player Form: Current form can significantly influence game results.
- Historical Data: Past encounters between teams provide valuable context.
- External Factors: Conditions like weather can impact gameplay.
By considering these factors, experts can offer well-rounded predictions that guide bettors in making informed choices.
Trends and Patterns in Betting
Identifying trends and patterns is essential for successful betting. For instance, certain teams may perform better at home or have a knack for winning close matches. Recognizing these patterns can help bettors anticipate outcomes more accurately.
- Home Advantage: Teams often perform better on familiar grounds.
- Rally Points: Games decided by small margins can be unpredictable.
- Injury Reports: Player injuries can drastically alter team dynamics.
- Schedule Fatigue: Frequent matches may lead to player fatigue affecting performance.
Keeping an eye on these trends allows bettors to refine their strategies continuously.
The Role of Technology in Betting Predictions
#include "StdAfx.h"
#include "DeviceManager.h"
using namespace std;
CDeviceManager::CDeviceManager()
{
}
CDeviceManager::~CDeviceManager()
{
}
void CDeviceManager::Init(HWND hWnd)
{
m_hWnd = hWnd;
m_pDev = NULL;
m_bDevOpened = false;
OpenDevices();
}
void CDeviceManager::Release()
{
CloseDevices();
}
void CDeviceManager::OpenDevices()
{
// Get list of devices
EnumVideoInputDevices(&m_listDevices);
if (m_listDevices.size() == 0)
return;
// Open first device
for (size_t i = 0; i != m_listDevices.size(); ++i)
{
if (OpenVideoInputDevice(m_listDevices[i].lParam))
break;
}
}
void CDeviceManager::CloseDevices()
{
if (m_bDevOpened && m_pDev)
{
m_pDev->Close();
delete m_pDev;
m_pDev = NULL;
m_bDevOpened = false;
}
}
bool CDeviceManager::OpenVideoInputDevice(LONG_PTR lParam)
{
if (m_bDevOpened && m_pDev)
return false;
HRESULT hr = S_OK;
try
{
hr = CoCreateInstance(CLSID_VideoInputDevice,
NULL,
CLSCTX_INPROC_SERVER,
IID_IVideoInputDevice,
reinterpret_cast(&m_pDev));
if (FAILED(hr))
throw hr;
hr = m_pDev->Open(lParam);
if (FAILED(hr))
throw hr;
#ifdef _DEBUG
cout << "Open video input device: " << lParam << endl;
#endif
#ifdef _DEBUG
cout << "Set window handle: " << m_hWnd << endl;
#endif
hr = m_pDev->SetWindowHandle(m_hWnd);
if (FAILED(hr))
throw hr;
m_bDevOpened = true;
return true;
}
catch(HRESULT& hr)
{
#ifdef _DEBUG
cout << "Failed open video input device: " << lParam << endl;
#endif
#ifdef _DEBUG
cout << "Error code: 0x" << hex << hr << endl;
#endif
return false;
}
}<|repo_name|>anadarko/Video-Processing-Application<|file_sep<|repo_name|>anadarko/Video-Processing-Application<|file_sep[Window]
Width=800
Height=600
[Video]
OutputFormat=AVI
[Image]
SavePath=D:WorkProjectsVisionLabProject1DataImages
SaveFormat=BMP<|file_sep#pragma once
class IAlgorithmInterface
{
public:
virtual void Init() {}
virtual void Release() {}
virtual void ProcessFrame(unsigned char* pFrame) {}
};<|repo_name|>anadarko/Video-Processing-Application<|file_sep coordinating_objects.h - Header file containing declaration of classes responsible for coordinating objects from different modules.
CoordinateObject - Class used as base class for all objects which will coordinate objects from different modules.
CoordinateCamera - Class responsible for coordinating camera module.
CoordinateAlgorithms - Class responsible for coordinating algorithms module.<|file_sep // VisionLab.cpp : Defines the entry point for the application.
//
#include "stdafx.h"
#include "VisionLab.h"
#include "MainFrm.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
// CVisionLabApp:
BEGIN_MESSAGE_MAP(CVisionLabApp, CWinAppEx)
ON_COMMAND(ID_APP_ABOUT, &CVisionLabApp::OnAppAbout)
ON_COMMAND(IDM_ABOUTBOX, &CVisionLabApp::OnAppAbout)
END_MESSAGE_MAP()
// CVisionLabApp construction:
CVisionLabApp::CVisionLabApp()
{
}
// The one and only CVisionLabApp object
CVisionLabApp theApp;
// CVisionLabApp initialization:
BOOL CVisionLabApp::InitInstance()
{
CWinAppEx::InitInstance();
InitContextMenuManager();
InitKeyboardAccelerators();
SetRegistryKey(_T("Local AppWizard-Generated applications"));
CMainFrame* pFrame = new CMainFrame();
if (!pFrame->LoadFrame(IDR_MAINFRAME))
return FALSE;
m_pMainWnd = pFrame;
pFrame->ShowWindow(SW_SHOW);
pFrame->UpdateWindow();
return TRUE;
}
int CVisionLabApp::ExitInstance()
{
CoUninitialize();
return CWinAppEx::ExitInstance();
}
// App command to run the dialog:
void CVisionLabApp::OnAppAbout()
{
CAboutDlg aboutDlg;
UINT_PTR nResponse =
aboutDlg.DoModal();
}
// Global functions:
BOOL IsAnyKeyPressed(void)
{
BOOL bRet;
bRet = GetAsyncKeyState(VK_UP) || GetAsyncKeyState(VK_DOWN) || GetAsyncKeyState(VK_LEFT) || GetAsyncKeyState(VK_RIGHT);
return bRet;
}
BOOL IsKeyPressed(int vkCode)
{
BOOL bRet;
bRet = !!GetAsyncKeyState(vkCode);
return bRet;
} <|repo_name|>anadarko/Video-Processing-Application<|file_sep collegue_object.cpp - Implementation file containing definitions of methods from collegue_object.h.<|repo_name|>anadarko/Video-Processing-Application<|file_sep INTERFACE_HEADER_FILE - Interface header file containing declaration of interfaces which should be implemented by all modules.<|repo_name|>anadarko/Video-Processing-Application<|file_sep LDAPort.cpp : Defines the entry point for the DLL application.
//
#include "stdafx.h"
#include "LDAPort.h"
CLDAPort *g_lpThisObject=NULL;
extern"C" __declspec(dllexport) void WINAPI SetThisPointer(CLDPort *lpThisObjectPtr){
g_lpThisObject=lpThisObjectPtr;}
extern"C" __declspec(dllexport) BOOL WINAPI OpenPort(int PortNumber){
g_lpThisObject->OpenPort(PortNumber);
return TRUE;}
extern"C" __declspec(dllexport) BOOL WINAPI ClosePort(){
g_lpThisObject->ClosePort();
return TRUE;}
extern"C" __declspec(dllexport) BOOL WINAPI SendData(BYTE *Buffer,int Length){
g_lpThisObject->SendData(Buffer,Length);
return TRUE;}
extern"C" __declspec(dllexport) BOOL WINAPI ReceiveData(BYTE *Buffer,int Length){
g_lpThisObject->ReceiveData(Buffer,Length);
return TRUE;}<|repo_name|>anadarko/Video-Processing-Application<|file_sep Models Module - Contains models used by algorithms.
ColorModel - Model representing color image.
DepthModel - Model representing depth image.<|repo_name|>anadarko/Video-Processing-Application<|file_sep related_classes_and_interfaces.h - Header file containing declaration of classes which are related but not connected with each other using Observer pattern.<|repo_name|>anadarko/Video-Processing-Application<|file_sep supper_class.cpp - Implementation file containing definition of methods from supper_class.h.<|repo_name|>anadarko/Video-Processing-Application<|file_sepollowing files contain implementation files corresponding to header files from Modules directory.
ModuleAlgorithm.cpp contains implementation files corresponding to header files from Algorithms Module directory.
ModuleCamera.cpp contains implementation files corresponding to header files from Camera Module directory.
ModuleDisplay.cpp contains implementation files corresponding to header files from Display Module directory.<|
File main.cpp contains main function.<|
File settings_manager.cpp contains implementation file corresponding to settings_manager.h.<|
File vision_lab_app.cpp contains implementation file corresponding to vision_lab_app.h.<|
FILE_INTERFACES_MODULE_HEADER_FILE - File containing interfaces implemented by all modules.<|
MODULE_INTERFACE_HEADER_FILE MODULE_INTERFACES_DIRECTORY_HEADER_FILE MODULE_INTERFACES_DIRECTORY_IMPLEMENTATION_FILES MODULES_DIRECTORY_MODULE_DIRECTORY_IMPLEMENTATION_FILES PROJECT_DIRECTORY_SOURCE_FILES PROJECT_SOURCE_FILES Project1.sln <|repo_name|>anadarko/Project1<|file_sep INCORRECT_USAGE_OF_FUNCTIONS_FROM_THIS_MODULE_AND_THESE_OF_ANOTHER_MODULE_IN_THE_SAME_FUNCTION_INCORRECT_USAGE_OF_FUNCTIONS_FROM_THIS_MODULE_AND_THESE_OF_ANOTHER_MODULE_IN_THE_SAME_FUNCTION_INCORRECT_USAGE_OF_FUNCTIONS_FROM_THIS_MODULE_AND_THESE_OF_ANOTHER_MODULE_IN_THE_SAME_FUNCTION_INCORRECT_USAGE_OF_FUNCTIONS_FROM_THIS_MODULE_AND_THESE_OF_ANOTHER_MODULE_IN_THE_SAME_FUNCTION_INCORRECT_USAGE_OF_FUNCTIONS_FROM_THIS_MODULE_AND_THESE_OF_ANOTHER_MODULE_IN_THE_SAME_FUNCTION Incorrect usage of functions from this module and these from another module in same function Incorrect usage of functions from this module and these from another module in same function Incorrect usage of functions from this module and these from another module in same function Incorrect usage of functions from this module and these from another module in same function Incorrect usage of functions from this module and these from another module in same function <|repo_name|>/Incorrect_usage_of_functions_from_this_module_and_these_of_another_module_in_the_same_function_Incorrect_usage_of_functions_from_this_module_and_these_of_another_module_in_the_same_function_Incorrect_usage_of_functions_from_this_module_and_these_of_another_module_in_the_same_function_Incorrect_usage_of_functions_from_this_module_and_these_of_another_module_in_the_same_function_Incorrect_usage_of_functions_from_this_module_and_these_of_another_module_in_the_same_function Incorrect_usage_of_functions_from_this_module_and_these_of_another_module_in_the_same_function_Incorrect_usage_of_functions_from_this_module_and_these_of_another_module_in_the_same_function_Incorrect_usage_of_functions_from_this_module_and_these_of_another_module_in_the_same_function_Incorrect_usage_of_functions_from_this_module_and_these_of_another_module_in_the_same_function_Incorrect_usage_of_functions_from_this_module_and_these_of_another_module_in_the_same_function <|repo_name>/Incorrect_usage_of_functions_from_this_module_and_these_of_another_module_in_the_same_function_Incorrect_usage_of_functions_from_this_module_and_these_of_another_module_in_the_same_function_Incorrect_usage_of_functions_from_this_module_and_these_of_another_module_in_the_same_function_Incorrect_usage_of_functions_from_this_module_and_these_of_another_module_in_the_same_function_Incorrect_usage_of_functions_from_this_module_and_these_of_another_module_in_the_same_function Incorrect usage of functions from this module and these from another module in same function <|repo_name>/Incorrect_usage_..._of_.cpp_files/files_containing_implementations_corresponding_to_header_files/_header_files/_header_files/_header_files/_header_files/_header_files/.sln <|file_sep::
//
#pragma once
class ICameraInterface {
public:
virtual bool Open() { return true; }
virtual bool Close() { return true; }
virtual bool StartAcquisition() { return true; }
virtual bool StopAcquisition() { return true; }
}; <|repo_name>/Modules_directory_Module_directory_Implementation_files_Modules_directory_Module_directory_Header_files_Modules_directory_Module_directory_Header_files_Project_directory_Source_files_Project_source_files_Project1.sln |INCORRECT USAGE OF FUNCTIONS FROM THIS MODULE AND THESE OF ANOTHER MODULE IN THE SAME FUNCTION INCORRECT USAGE OF FUNCTIONS FROM THIS MODULE AND THESE OF ANOTHER MODULE IN THE SAME FUNCTION INCORRECT USAGE OF FUNCTIONS FROM THIS MODULE AND THESE OF ANOTHER MODULE IN THE SAME FUNCTION INCORRECT USAGE OF FUNCTIONS FROM THIS MODULE AND THESE OF ANOTHER MODULE IN THE SAME FUNCTION INCORRECT USAGE OF FUNCTIONS FROM THIS MODULE AND THESE OF ANOTHER MODULE IN THE SAME FUNCTION <|file_sep want_to_see_a_screenshot_while_debugging_your_application_want_to_see_a_screenshot_while_debugging_your_application_want_to_see_a_screenshot_while_debugging_your_application_want_to_see_a_screenshot_while_debugging_your_application_want_to_see_a_screenshot_while_debugging_your_application Want To See A Screenshot While Debugging Your Application Want To See A Screenshot While Debugging Your Application Want To See A Screenshot While Debugging Your Application Want To See A Screenshot While Debugging Your Application Want To See A Screenshot While Debugging Your Application <|repo_name>/want_to_see_a_screenshot_while_debugging_your_application_want_to_see_a_screenshot_while_debugging_your_application_want_to_see_a_screenshot_while_debugging_your_application_want_to_see_a_screenshot_while_debugging_your_application_want_to_see_a_screenshot_while_debugging_your_application_Want_To_See_A_ScreenShot_While_Debuggin... |Want To See A ScreenShot While Debuggin... |Want To See A ScreenShot While Debuggin... |Want To See A ScreenShot While Debuggin... |Want To See A ScreenShot While Debuggin... |
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
In order do so you need two things:
1. Create a MFC dialog-based project called 'Screenshot' with no additional dependencies added automatically by Visual Studio wizard.
2. Add following code into your project's source code:
**************************************************************************************
IN .CPP FILE CONTAINING MAIN FUNCTION:
***************************************************************************************
HINSTANCE hInst=NULL;//Global variable storing handle instance returned by DialogBoxParam()
int APIENTRY WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPTSTR lpCmdLine,int nCmdShow){
hInst=hInstance;//Assigning global variable with value returned by DialogBoxParam()
int retValue=DialogBoxParam(hInst,(LPCWSTR)L"Screenshots",NULL,(DLGPROC)_ScreenShotDialogProc,NULL);
return retValue;}
**************************************************************************************
IN HEADER FILE CONTAINING MAIN FUNCTION:
***************************************************************************************
HINSTANCE g_hInst=NULL;//Global variable storing handle instance returned by DialogBoxParam()
INT_PTR CALLBACK _ScreenShotDialogProc(HWND hwndDlg,UWORD uMsg,WPARAM wParam,WPARAM lParam){
switch(uMsg){
case WM_INITDIALOG://In case when DialogBoxParam creates dialog box we want our own dialog box procedure so we don't need default one provided by MFC library so we just destroy it immediately after creating it
HWND hWnd=GetParent(hwndDlg);//Getting parent window handle which is actually our application's main window handle
DestroyWindow(hwndDlg);//Destroying created dialog box
MessageBox(hWnd,L"The screen shot was saved!",L"Informations",MB_OK);//Showing message box informing user that screen shot was saved successfully
EndDialog(hwndDlg,IDOK);//End dialog box procedure returning IDOK
break;//Break statement ends switch-case statement
default://Default case doing nothing because we don't care about any other messages than WM_INITDIALOG message
return FALSE;//Returning FALSE telling Windows OS that we didn't processed any messages other than WM_INITDIALOG message
break;//Break statement ends switch-case statement
}//End switch-case statement
}//End Dialog Box Procedure Function
**************************************************************************************
IN HEADER FILE WHICH IS PART OF YOUR APPLICATION'S SOURCE CODE:
***************************************************************************************
INT_PTR CALLBACK OnScreenshot(WPARAM wParam,LPARAM lParam){//Function called when user clicks button 'Take screenshot'
SaveScreenShot(g_hInst); //Calling SaveScreenShot method passing it global variable g_hInst as parameter which stores handle instance returned by DialogBoxParam()
EndDialog((HWND)wParam,IDOK); //Ending dialog box procedure returning IDOK
}//End OnScreenshot Function
VOID SaveScreenShot(HINSTANCE hInst){//Function taking one parameter storing handle instance returned by DialogBoxParam()
HWND hwnd=(HWND)::GetDesktopWindow();//Getting desktop window handle stored inside global variable g_hWnd
HDC hdcScr=(HDC)::GetDC(hwnd);//Getting desktop window DC stored inside global variable g_hdcScr
RECT rect={0}; //Declaring RECT structure which will store size information about desktop window area covered by desktop window DC
GetClientRect(hwnd,&rect); //Getting size information about desktop window area covered by desktop window DC stored inside RECT structure rect declared above
HDC hdcMem=(HDC)::CreateCompatibleDC(hdcScr); //Creating compatible DC stored inside global variable g_hdcMem using desktop window DC stored inside global variable g_hdcScr as parameter passed into CreateCompatibleDC method call
HBITMAP hBitmap=(HBITMAP)::CreateCompatibleBitmap(hdcScr,//Creating bitmap compatible with desktop window DC stored inside global variable g_hdcScr using size information about desktop window area covered by desktop window DC stored inside RECT structure rect declared above as parameters passed into CreateCompatibleBitmap method call
rect.right,
rect.bottom);
HGDIOBJ hOldBmp=(HGDIOBJ)::SelectObject(hdcMem,hBitmap);//Selecting bitmap created above into memory DC created above replacing previously selected object there if any
BOOL bltResult=(BOOL)::BitBlt(hdcMem,//Copying content drawn into memory DC created above onto screen using size information about desktop window area covered by memory DC created above as parameters passed into BitBlt method call
hdcScr,
rect.left,
rect.top,
rect.right,
rect.bottom,
SRCCOPY);
SYSTEMTIME st={0};
GetLocalTime(&st); //Getting current time stored inside SYSTEMTIME structure st declared above
TCHAR szFilePath[MAX_PATH]={0}; //Declaring array szFilePath capable enough holding path string including null terminator character ' '
swprintf(szFilePath,L"%s\Screenshots\%d-%02d-%02d_%02d-%02d-%02d.bmp",//Saving path string including filename formatted using current time obtained above into array szFilePath declared above as parameters passed into swprintf method call
GetEnvironmentVariable(L"USERPROFILE"),
st.wYear,
st.wMonth,
st.wDay,
st.wHour,
st.wMinute,
st.wSecond);
HANDLE hFile=CreateFile(szFilePath,//Opening file specified path string saved into array szFilePath declared above using GENERIC_WRITE access right meaning writing only access right read/write access rights not necessary because we're going write bitmap data directly without reading anything beforehand security attributes set to NULL meaning default security attributes shared mode set so anyone who has permissions defined through security attributes could open file share mode set allowing others open file simultaneously write-only access allowed creation disposition set creating new file if it doesn't exist already failure if it does template file not necessary because we're writing raw binary data buffer not text buffer therefore Unicode text translations not necessary flag set indicating Unicode text translation should be performed none therefore flag set indicating no Unicode text translation should be performed neither byte ordering nor Unicode translation flags needed because we're writing raw binary data buffer not text buffer therefore Unicode translation flags not needed lastly default attribute setting meaning default attributes will be used if there were no specific attributes specified then finally opening operation successfull otherwise failure occurred error handling omitted because it's out scope here anyway therefore opening operation successfull resulting HANDLE object representing opened file descriptor/handle stored inside HANDLE object hFile declared hereafter
GENERIC_WRITE,
FILE_SHARE_WRITE,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
FILE_FLAG_WRITE_THROUGH,
NULL);
BITMAPINFOHEADER bmiHeader={sizeof(BITMAPINFOHEADER),rect.right,-rect.bottom,sizeof(RGBQUAD),24,BI_RGB};
DWORD dwWrittenBytes={0};
WriteFile(hFile,//Writing bitmap info header specified BITMAPINFOHEADER structure bmiHeader declared above along with bitmap data copied earlier onto memory DC created earlier directly onto opened file represented HANDLE object hFile declared earlier without copying them first therefore number bytes written specified DWORD dwWrittenBytes initialized earlier incremented exactly equal number bytes specified BITMAPINFOHEADER structure bmiHeader declared earlier plus number bytes copied onto memory DC created earlier therefore WriteFile method returns nonzero value indicating success otherwise zero value indicating failure error handling omitted because it's out scope here anyway therefore WriteFile method returns nonzero value indicating success
hFile,
sizeof(BITMAPINFOHEADER),
reinterpret_cast(&bmiHeader),
sizeof(DWORD),
reinterpret_cast(&dwWrittenBytes));
WriteFile(hFile,//Writing bitmap data copied onto memory DC created earlier directly onto opened file represented HANDLE object hFile declared earlier without copying them first therefore number bytes written specified DWORD dwWrittenBytes initialized earlier incremented exactly equal number bytes copied onto memory DC created earlier therefore WriteFile method returns nonzero value indicating success otherwise zero value indicating failure error handling omitted because it's out scope here anyway therefore WriteFile method returns nonzero value indicating success
hFile,
dwWrittenBytes,
reinterpret_cast(NULL),
dwWrittenBytes,
reinterpret_cast(&dwWrittenBytes));
CloseHandle(hFile);//Closing opened HANDLE object represented opened file descriptor/handle represented HANDLE object hFile closed hereafter
DeleteObject(hBitmap);//Deleting GDI resource bitmap represented HBITMAP object hBitmap deleted hereafter
DeleteDC(hdcMem);//Deleting GDI resource memory device context represented HDC object hdcMem deleted hereafter
ReleaseDC(hwnd,hdcScr);//Releasing captured GDI resource device context represented HDC object hdcScr released hereafter
MessageBox(hwnd,L"The screen shot was saved!",L"Informations",MB_OK);//Showing message box informing user that screen shot was saved successfully
}//End SaveScreenShot Function
//**************************************************************************************
The only thing left now is adding button 'Take screenshot' placed somewhere appropriate within your application along with event handler associated with click event generated when user clicks this button calling OnScreenshot function defined previously passing it HWND hwnd parameter obtained during runtime through HandleToLong(GetDlgItem(hwnd,ID)) macro call where ID is ID assigned automatically during design time using resource editor tool within Visual Studio IDE along with HandleToLong macro call obtaining HWND hwnd parameter itself through long pointer casted version obtained during runtime through CallWindowProc macro call passing HWND hwnd parameter obtained during runtime through HandleToLong(GetDlgItem(hwnd,ID)) macro call where ID is ID assigned automatically during design time using resource editor tool within Visual Studio IDE along with pointer casted version obtained during runtime through GetCurrentThreadId() function call.
Then just compile your project run executable produced under debug configuration then click 'Take screenshot' button while debugging your application pressing F5 key repeatedly stepping through instructions one-by-one observing changes happening within your application's graphical interface until you reach step where you want take screenshot clicking 'Take screenshot' button then click 'Continue' button pressing F5 key again continuing execution until breakpoint reached clicking 'Continue' button pressing F5 key again repeating process described until desired result achieved.
You'll see something similar below:
Hope you enjoyed reading tutorial thanks!
If you found any mistakes please let me know I'll try my best correcting them soonest possible.
DISCLAIMER: Code samples presented throughout tutorial belong me personally they're licensed under MIT license available at https://opensource.org/licenses/MIT feel free copying modifying distributing etc freely provided credit given mentioning source repository link https://github.com/anadarko/Screenshots provided within comment block preceding each code sample included tutorial thank you!
