View difference between Paste ID: DgYt2KG7 and 2yBhd6H8

 #include <windows.h>
 #include <algorithm>
 #include <vector>
 #include <map>
 #include <string>
 #include <array>
 
 LRESULT CALLBACK WinProc(HWND, UINT, WPARAM, LPARAM);
 bool createWinClass(HINSTANCE&, TCHAR*);
 
 using namespace std;
 
 struct CRectColor
 {
 	unsigned int x, y;
 	COLORREF pcolor;
 };
 
 struct CRectShape
 {
 	unsigned int x, y, shape;
 };
 
 class CPaint
 {
 	public:
 		CPaint();
 
 		void drawPallet(const HWND);
 		void startDraw(const WORD, const WORD);
 		void endDraw(const HWND, const WORD, const WORD);
 		void updatePosition(const RECT);
 		bool palletArea(const WORD) const;
 		void userClick(const HWND, const WORD, const WORD, const bool);
 		unsigned int getXcoord() const;
 
 		static const unsigned int colors_count = 16;
 		static const unsigned int rectangle_size = 40;
 		static const unsigned int pallet_size = 200;
 
 	private:
 		void fillPallet();
 
 		RECT position;
 		RECT draw_coords;
 		vector<CRectColor> pallet;
 		map<string, CRectShape> shapes;
 		enum shapes { RECTANGLE, CIRCLE, TRIANGLE, TRIANGLE_FILL };
 
 		unsigned short int current_shape;
 		COLORREF current_brush_color;
 		COLORREF current_pen_color;
 };
 
 CPaint::CPaint() : current_shape(RECTANGLE), current_brush_color(RGB(0, 0,0)), current_pen_color(RGB(0, 0,0))
 {
 	fillPallet();
 }
 
 void CPaint::fillPallet()
 {
 	array<COLORREF, colors_count> tab = {
 		RGB(0, 0, 0), RGB(255, 0, 0),
 		RGB(0, 255, 0), RGB(0, 0, 255),
 		RGB(255, 255, 0), RGB(255, 0, 255),
 		RGB(0, 255, 255), RGB(255, 255, 255),
 		RGB(80, 80, 80), RGB(180, 20, 20),
 		RGB(20, 180, 20), RGB(20, 20, 180),
 		RGB(180, 180, 20), RGB(180, 20, 180),
 		RGB(20, 180, 180), RGB(150, 150, 150)
 	};
 	for(array<COLORREF, colors_count>::iterator it = tab.begin(); it != tab.end(); it++)
 	{
 		CRectColor CRectColor;
 		CRectColor.x = CRectColor.y = 0;
 		CRectColor.pcolor = *it;
 		this->pallet.push_back(CRectColor);
 	}
 
 	// shapes
 	CRectShape defaultrect;
 	defaultrect.x = defaultrect.y = 0;
 	defaultrect.shape = RECTANGLE;
 
 	shapes["rectangle"] = defaultrect;
 	shapes["circle"] = defaultrect;
 	shapes["triangle"] = defaultrect;
 	shapes["trianglefill"] = defaultrect;
 
 	shapes["circle"].shape = CIRCLE;
 	shapes["triangle"].shape = TRIANGLE;
 	shapes["trianglefill"].shape = TRIANGLE_FILL;
 
 	draw_coords.bottom = draw_coords.left = draw_coords.top = draw_coords.right = 0;
 }
 
 void CPaint::updatePosition(const RECT position)
 {
 	this->position = position;
 }
 
 void CPaint::drawPallet(const HWND hwnd)
 {
 	PAINTSTRUCT paintdata;
 	HDC hdc = BeginPaint(hwnd, &paintdata);
 
 	HPEN emptyPen = (HPEN) SelectObject(hdc, GetStockObject(NULL_PEN));
 	HBRUSH emptyBrush = (HBRUSH) SelectObject(hdc, GetStockObject(NULL_BRUSH));
 
 	HPEN standardPen = CreatePen(PS_SOLID, 0, RGB(0, 0, 0));
 	HPEN bluePen = CreatePen(PS_SOLID, 0, RGB(0, 0, 255));
 	HPEN greyPen = CreatePen(PS_SOLID, 0, RGB(180, 180, 180));
 
 	HBRUSH standardBrush = CreateSolidBrush(RGB(0, 0, 0));
 	HBRUSH whiteBrush = CreateSolidBrush(RGB(255, 255, 255));
 	HBRUSH greyBrush = CreateSolidBrush(RGB(180, 180, 180));
 
 	SelectObject(hdc, greyBrush);
 	SelectObject(hdc, bluePen);
 
 	//draw grey palet
 	Rectangle(hdc, position.right - CPaint::pallet_size,
 		0, position.right, position.bottom);
 
 	//draw colors palet
 	unsigned int i = 0, inc = 0;
 	unsigned int margin_left = 45;
 	unsigned int margin_top = 40;
 
 	SelectObject(hdc, greyPen);
 	for(vector<CRectColor>::iterator it = pallet.begin(); it != pallet.end(); it++, i++, inc++)
 	{
 		if(inc == 8) {
 			margin_left += CPaint::rectangle_size + 25;
 			i = 0;
 		}
 
 		unsigned int margin = i * (CPaint::rectangle_size + 5);
 		(*it).x = position.right - CPaint::pallet_size + margin_left;
 		(*it).y = position.top + margin_top + margin;
 
 		HBRUSH rectBrush = CreateSolidBrush((*it).pcolor);
 		SelectObject(hdc, rectBrush);
 		Rectangle(hdc, (*it).x, (*it).y,
 			(*it).x + CPaint::rectangle_size, (*it).y + CPaint::rectangle_size);
 		DeleteObject(rectBrush);
 	}
 
 	//draw shapes pallet
 	SelectObject(hdc, standardPen);
 	SelectObject(hdc, whiteBrush);
 
 	unsigned int margin_bottom = 80;
 	margin_left = 45;
 
 	//rectangle
 	shapes["rectangle"].x = position.right - CPaint::pallet_size + margin_left;
 	shapes["rectangle"].y = position.bottom - margin_bottom - CPaint::rectangle_size;
 
 	Rectangle(hdc, shapes["rectangle"].x, shapes["rectangle"].y,
 			shapes["rectangle"].x + CPaint::rectangle_size, shapes["rectangle"].y + CPaint::rectangle_size);
 
 	SelectObject(hdc, standardBrush);
 	Rectangle(hdc, shapes["rectangle"].x + 5, shapes["rectangle"].y + 5,
 			shapes["rectangle"].x + CPaint::rectangle_size - 5, shapes["rectangle"].y + CPaint::rectangle_size - 5);
 
 	//circle
 	SelectObject(hdc, whiteBrush);
 	shapes["circle"].x = shapes["rectangle"].x;
 	shapes["circle"].y = position.bottom - margin_bottom + 5;
 
 	Rectangle(hdc, shapes["circle"].x, shapes["circle"].y,
 			shapes["circle"].x + CPaint::rectangle_size, shapes["circle"].y + CPaint::rectangle_size);
 
 	SelectObject(hdc, standardBrush);
 	Ellipse(hdc, shapes["circle"].x + 5, shapes["circle"].y + 5,
 			shapes["circle"].x + CPaint::rectangle_size - 5, shapes["circle"].y + CPaint::rectangle_size - 5);
 
 	//triangle
 	SelectObject(hdc, whiteBrush);
 	shapes["triangle"].x = shapes["rectangle"].x + CPaint::rectangle_size + 25;
 	shapes["triangle"].y = shapes["rectangle"].y;
 
 	Rectangle(hdc, shapes["triangle"].x, shapes["triangle"].y,
 			shapes["triangle"].x + CPaint::rectangle_size, shapes["triangle"].y + CPaint::rectangle_size);
 
 	POINT trianglePos[3];
 	trianglePos[0].x = shapes["triangle"].x + 5;
 	trianglePos[1].x = shapes["triangle"].x + CPaint::rectangle_size - 5;
 	trianglePos[0].y = trianglePos[1].y = shapes["triangle"].y + 5;
 	trianglePos[2].y = shapes["triangle"].y + CPaint::rectangle_size - 5;
 	trianglePos[2].x = (trianglePos[0].x + trianglePos[1].x) / 2;
 
 	Polygon(hdc, trianglePos, 3);
 
 	//triangle fill
 	SelectObject(hdc, whiteBrush);
 	shapes["trianglefill"].x = shapes["triangle"].x;
 	shapes["trianglefill"].y = shapes["circle"].y;
 
 	Rectangle(hdc, shapes["trianglefill"].x, shapes["trianglefill"].y,
 			shapes["trianglefill"].x + CPaint::rectangle_size, shapes["trianglefill"].y + CPaint::rectangle_size);
 
 	SelectObject(hdc, standardBrush);
 	trianglePos[0].x = shapes["trianglefill"].x + 5;
 	trianglePos[1].x = shapes["trianglefill"].x + CPaint::rectangle_size - 5;
 	trianglePos[0].y = trianglePos[1].y = shapes["trianglefill"].y + 5;
 	trianglePos[2].y = shapes["trianglefill"].y + CPaint::rectangle_size - 5;
 	trianglePos[2].x = (trianglePos[0].x + trianglePos[1].x) / 2;
 
 	Polygon(hdc, trianglePos, 3);
 
 	SelectObject(hdc, emptyPen);
 	SelectObject(hdc, emptyBrush);
 	EndPaint(hwnd, &paintdata);
 
 	DeleteObject(standardPen);
 	DeleteObject(bluePen);
 	DeleteObject(greyPen);
 	DeleteObject(standardBrush);
 	DeleteObject(whiteBrush);
 	DeleteObject(greyBrush);
 }
 
 unsigned int CPaint::getXcoord() const
 {
 	return position.right;
 }
 
 void CPaint::startDraw(const WORD x, const WORD y)
 {
 	// start draw on client area, remember points
 	draw_coords.left = x;
 	draw_coords.top = y;
 }
 
 void CPaint::endDraw(const HWND hwnd, const WORD x, const WORD y)
 {
 	// end draw on client area
 	draw_coords.right = x;
 	draw_coords.bottom = y;
 
 	HDC hdc = GetDC(hwnd);
 	HPEN emptyPen = (HPEN) SelectObject(hdc, GetStockObject(NULL_PEN));
 	HBRUSH emptyBrush = (HBRUSH) SelectObject(hdc, GetStockObject(NULL_BRUSH));
 
 	HPEN userPen = CreatePen(PS_SOLID, 0, current_pen_color);
 	HBRUSH userBrush = CreateSolidBrush(current_brush_color);
 
 	SelectObject(hdc, userPen);
 	SelectObject(hdc, userBrush);
 	switch(current_shape)
 	{
 		case RECTANGLE:
 			Rectangle(hdc, draw_coords.left, draw_coords.top,
 				draw_coords.right, draw_coords.bottom);
 			break;
 		case CIRCLE:
 			Ellipse(hdc, draw_coords.left, draw_coords.top,
 				draw_coords.right, draw_coords.bottom);
 			break;
 		case TRIANGLE:
 		{
 			POINT trianglePos[4];
 			trianglePos[0].x = draw_coords.left;
 			trianglePos[1].x = draw_coords.right;
 			trianglePos[0].y = trianglePos[1].y = draw_coords.top;
 			trianglePos[2].y = draw_coords.bottom;
 			trianglePos[2].x = (trianglePos[0].x + trianglePos[1].x) / 2;
 			trianglePos[3] = trianglePos[0];
 			Polyline(hdc, trianglePos, 4);
 			break;
 		}
 		case TRIANGLE_FILL:
 		{
 			POINT trianglePos[3];
 			trianglePos[0].x = draw_coords.left;
 			trianglePos[1].x = draw_coords.right;
 			trianglePos[0].y = trianglePos[1].y = draw_coords.top;
 			trianglePos[2].y = draw_coords.bottom;
 			trianglePos[2].x = (trianglePos[0].x + trianglePos[1].x) / 2;
 			Polygon(hdc, trianglePos, 3);
 			break;
 		}
 	}
 	SelectObject(hdc, emptyPen);
 	SelectObject(hdc, emptyBrush);
 	DeleteObject(userPen);
 	DeleteObject(userBrush);
 	ReleaseDC(hwnd, hdc);
 }
 
 bool CPaint::palletArea(const WORD x) const
 {
 	if(x < position.right - pallet_size) // no on grey pallet
 		return false;
 
 	return true;
 }
 
 void CPaint::userClick(const HWND hwnd, const WORD x, const WORD y, const bool left)
 {
 	if(left) // LPM click
 	{
 		// color change?
 		for(vector<CRectColor>::iterator it = pallet.begin(); it != pallet.end(); it++)
 		{
 			if(x >= (*it).x && x <= (*it).x + CPaint::rectangle_size)
 			{
 				if(y >= (*it).y && y <= (*it).y + CPaint::rectangle_size)
 				{
 					HDC con = GetDC(hwnd);
 					current_brush_color = GetPixel(con, x, y);
 					ReleaseDC(hwnd, con);
 					break;
 				}
 			}
 		}
 
 		// shape change?
 		unsigned int i = 0;
 		for(map<string, CRectShape>::iterator it = shapes.begin(); it != shapes.end(); it++, i++)
 		{
 			if(x >= (*it).second.x && x <= (*it).second.x + CPaint::rectangle_size)
 			{
 				if(y >= (*it).second.y && y <= (*it).second.y + CPaint::rectangle_size)
 				{
 					current_shape = (*it).second.shape;
 					break;
 				}
 			}
 		}
 	}
 	else // RPM click
 	{
 		// color change?
 		for(vector<CRectColor>::iterator it = pallet.begin(); it != pallet.end(); it++)
 		{
 			if(x >= (*it).x && x <= (*it).x + CPaint::rectangle_size)
 			{
 				if(y >= (*it).y && y <= (*it).y + CPaint::rectangle_size)
 				{
 					HDC con = GetDC(hwnd);
 					current_pen_color = GetPixel(con, x, y);
 					ReleaseDC(hwnd, con);
 					break;
 				}
 			}
 		}
 	}
 }
 // END CLASS
 
 TCHAR APPName[] = TEXT("Paint application");
 TCHAR ClassName[] = TEXT("Class name");
 
 CPaint Paint;
 
 int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPevInstance, LPSTR lpCmdLine, int nShowCmd)
 {
 	if(!createWinClass(hInstance, ClassName))
 		return 1;
 
 	HWND window = CreateWindowEx(0, ClassName, APPName, WS_OVERLAPPEDWINDOW, 200, 50, 800, 650, 0, 0, 0, 0);
 	if(window)
 	{
 		MSG msg;
 		ShowWindow(window, nShowCmd);
 
 		while(GetMessage(&msg, 0, 0, 0) > 0)
 		{
 			TranslateMessage(&msg);
 			DispatchMessage(&msg);
 		}
 	}
 	else MessageBox(0, TEXT("Inicjalizacja okna nie powiodła się."), APPName, MB_OK | MB_ICONERROR);
 	UnregisterClass(ClassName, hInstance);
 	return 0;
 }
 
 static LRESULT CALLBACK WinProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
 	static bool draw = false;
 	switch(msg)
 	{
 		case WM_CLOSE:
 		{
 			if(MessageBox(hwnd, TEXT("Czy na pewno zamknąć aplikację?"), APPName, MB_YESNO) == IDYES)
 			{
 				DestroyWindow(hwnd);
 				break;
 			}
 		}
 		case WM_MOVE:
 		case WM_SIZE:
 		{
 			RECT rectangle;
 			InvalidateRect(hwnd, 0, true);
 			GetClientRect(hwnd, &rectangle);
 			Paint.updatePosition(rectangle);
 			break;
 		}
 		case WM_GETMINMAXINFO:
 		{
 			MINMAXINFO* mmi = (MINMAXINFO*)lParam;
 			mmi->ptMinTrackSize.x = CPaint::pallet_size;
 			mmi->ptMinTrackSize.y = 580;
 			return 0;
 		}
 		case WM_PAINT:
 		{
 			Paint.drawPallet(hwnd);
 			break;
 		}
 		case WM_LBUTTONDOWN:
 		{
 			if(Paint.palletArea(LOWORD(lParam)))
 				Paint.userClick(hwnd, LOWORD(lParam), HIWORD(lParam), true); // brush / shape choice
 			else
 			{
 				draw = true;
 				Paint.startDraw(LOWORD(lParam), HIWORD(lParam));
 			}
 			break;
 		}
 		case WM_LBUTTONUP:
 		{
 			if(!Paint.palletArea(LOWORD(lParam)) && draw) // end draw
 				Paint.endDraw(hwnd, LOWORD(lParam), HIWORD(lParam));
 
 			draw = false;
 			break;
 		}
 		case WM_RBUTTONDOWN:
 		{
 			if(Paint.palletArea(LOWORD(lParam))) // pen color choice
 				Paint.userClick(hwnd, LOWORD(lParam), HIWORD(lParam), false);
 			break;
 		}
 		case WM_DESTROY:
 			PostQuitMessage(0);
 			break;
 		default:
 			return DefWindowProc(hwnd, msg, wParam, lParam);
 	}
 	return 0;
 }
 
 static bool createWinClass(HINSTANCE& hInstance, TCHAR* ClassName)
 {
 	WNDCLASSEX wc;
 	wc.cbClsExtra = wc.cbWndExtra = 0;
 	wc.cbSize = sizeof(WNDCLASSEX);
 	wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
 	wc.hCursor = LoadCursor(0, IDC_ARROW);
 	wc.hIconSm = wc.hIcon = LoadIcon(0, IDI_APPLICATION);
 	wc.hInstance = hInstance;
 	wc.lpfnWndProc = WinProc;
 	wc.lpszClassName = ClassName;
 	wc.lpszMenuName = 0;
 	wc.style = 0;
 	return (RegisterClassEx(&wc) != 0);
 }