Paint ++ на WinAPI

// 777.cpp : Defines the entry point for the application.
//
 
#include "stdafx.h"
#include "777.h"
#include <windows.h>
#include <tchar.h>
#include <commdlg.h>
#include <commctrl.h>
#include <fstream>
#include <vector>
#include <xstring>
 
#define MAX_LOADSTRING 100
#define ID_FIRSTCHILD 101
#define ID_SECONDCHILD 102
#define ID_THIRDCHILD 103
 
 
 
// Global Variables:
HINSTANCE hInst;                                // current instance
TCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
TCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name
 
struct REC
    {
    int x1;
    int y1;
    int x2;
    int y2;
    }rec[50];
int count=0;
 
// Forward declarations of functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
 
int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);
 
    // TODO: Place code here.
    MSG msg;
    HACCEL hAccelTable;
 
    // Initialize global strings
    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_MY777, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);
 
    // Perform application initialization:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }
 
    hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_MY777));
 
    // Main message loop:
    while (GetMessage(&msg, NULL, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
 
    return (int) msg.wParam;
}
 
 
 
//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
//  COMMENTS:
//
//    This function and its usage are only necessary if you want this code
//    to be compatible with Win32 systems prior to the 'RegisterClassEx'
//    function that was added to Windows 95. It is important to call this function
//    so that the application will get 'well formed' small icons associated
//    with it.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEX wcex;
 
    wcex.cbSize = sizeof(WNDCLASSEX);
 
    wcex.style          = CS_HREDRAW | CS_VREDRAW | CS_SAVEBITS | CS_CLASSDC;//////////////////////
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_MY777));
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCE(IDC_MY777);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
 
    return RegisterClassEx(&wcex);
}
 
//
//   FUNCTION: InitInstance(HINSTANCE, int)
//
//   PURPOSE: Saves instance handle and creates main window
//
//   COMMENTS:
//
//        In this function, we save the instance handle in a global variable and
//        create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;
 
   hInst = hInstance; // Store instance handle in our global variable
 
   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
 
   if (!hWnd)
   {
      return FALSE;
   }
 
   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);
 
   return TRUE;
}
 
//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND  - process the application menu
//  WM_PAINT    - Paint the main window
//  WM_DESTROY  - post a quit message and return
//
//
TBBUTTON tbb[] =
{   {STD_FILENEW,  ID_FILE_NEW, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0, 0, 0},
    {STD_FILEOPEN, ID_FILE_OPEN, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0, 0, 0},
    {STD_FILESAVE, ID_FILE_SAVE, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0, 0, 0}
    
};
    
VOID StatusOut(HWND hStatus, int count, TCHAR * str)
{   
    TCHAR text[256];
    _stprintf(text,_T("Строк: %d"), count);
    SendMessage(hStatus, SB_SETTEXT, (WPARAM)0, (LPARAM)text);
    SendMessage(hStatus, SB_SETTEXT, (WPARAM)1, (LPARAM)str);
}
 
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    PAINTSTRUCT ps;
    HDC hdc;
    static OPENFILENAME file;
    static HWND hWndToolBar, hWndStatusBar, hb1, hb2, hb3;
    int m, k, aWidths[2];
    static TCHAR name[256] = _T("");
    TCHAR str[256];
    std::ifstream in;
    std::ofstream out;
    static std::vector<std::string> v;
    std::vector<std::string>::iterator it;
    std::string st;
    int y, t;
    static int n,lenght,sx,sy,cx,iVscrollPos,iHscrollPos,COUNT,MAX_WIDTH;
    static SIZE size = {8, 16};
    static int size_Toolbar;
    RECT rt;
    static int x1, x2, y1, y2, temp=2;
    int i=0;
    static bool box=false;
    HINSTANCE hInstance;
    /*int WINAPI CombineRgn(
    HRGN hrgnDest, // новая область
    HRGN hrgnSrc1, // первая исходная область
    HRGN hrgnSrc2, // вторая исходная область
    int fnCombineMode); // режим комбинирования*/
 
 
    switch (message)
    {
        case WM_CREATE:
            hWndToolBar = CreateToolbarEx(  hWnd, WS_CHILD|WS_VISIBLE|CCS_TOP,
                                            2, 0, HINST_COMMCTRL, IDB_STD_SMALL_COLOR, tbb, 3, 0, 0, 0, 0,
                                            sizeof(TBBUTTON));
            
               hb1 = CreateWindow(L"button",                ///////////////////Line
                       L"Линия",
                       WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
                       30,
                       40,  
                       70,    
                       30,    
                       hWnd,    
                       (HMENU) (int) (ID_FIRSTCHILD),    
                       hInstance,  
                       NULL);
            hb2 = CreateWindow(L"button",                   //////////////////////////////Rectangle
                       L"Прямоуг.",
                       WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
                       30,
                       73, 
                       70,
                       30,
                       hWnd,
                       (HMENU) (int) (ID_SECONDCHILD),
                       hInstance,
                       NULL);
 
            hb3 = CreateWindow(L"button",                       /////////////////Ellipse
                        L"Эллипс",
                        WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
                        30,
                        106,
                        70,
                        30,
                        hWnd,
                        (HMENU) (int) (ID_THIRDCHILD),
                        hInstance,
                        NULL);
 
                        break;
            ////////////////////////////////////////////////////////////////////////
        case WM_SIZE:
            sx = LOWORD(lParam);
            sy = HIWORD(lParam);
            t = n - (sy - size_Toolbar)/size.cy;
            if (t > 0) COUNT = t; else COUNT = iVscrollPos = 0;
            SetScrollRange(hWnd, SB_VERT, 0, COUNT, FALSE);
            SetScrollPos(hWnd, SB_VERT, iVscrollPos, TRUE);
            t = lenght - sx/size.cx;
            if (t > 0) MAX_WIDTH = t; else MAX_WIDTH = iHscrollPos = 0;
            SetScrollRange(hWnd, SB_HORZ, 0, MAX_WIDTH, FALSE);
            SetScrollPos(hWnd, SB_HORZ, iHscrollPos, TRUE);
            aWidths[0] = 100;
            aWidths[1] = sx;
            GetWindowRect(hWndToolBar, &rt);
            m = rt.bottom - rt.top;
            SendMessage(hWndToolBar, TB_AUTOSIZE, 0, 0);
            GetWindowRect(hWndStatusBar, &rt);
            k = rt.bottom - rt.top;
            MoveWindow(hWndStatusBar, 0, sy - k, sx, sy, TRUE);
            SendMessage(hWndStatusBar, SB_SETPARTS, (WPARAM)2, (LPARAM)aWidths);
            StatusOut(hWndStatusBar, n, name);
            return 0;
            ////////////////////////////////////////////////////////////////////////
        case WM_MOUSEWHEEL:   
            iVscrollPos -= (short)HIWORD(wParam)/WHEEL_DELTA;
            iVscrollPos = max(0, min(iVscrollPos, COUNT));
            SetScrollPos(hWnd, SB_VERT, iVscrollPos, TRUE);
            InvalidateRect(hWnd, NULL, TRUE);
            break;
            ////////////////////////////////////////////////////////////////////////
        case WM_VSCROLL:
            switch(LOWORD(wParam))
            {
            case SB_LINEUP : iVscrollPos--; break;
            case SB_LINEDOWN : iVscrollPos++; break;
            case SB_PAGEUP : iVscrollPos -= sy/size.cy; break;
            case SB_PAGEDOWN : iVscrollPos += sy/size.cy; break;
            case SB_THUMBPOSITION : iVscrollPos = HIWORD(wParam); break;
            }
            iVscrollPos = max(0, min(iVscrollPos, COUNT));
            if (iVscrollPos != GetScrollPos(hWnd, SB_VERT))
            {
                SetScrollPos(hWnd, SB_VERT, iVscrollPos, TRUE);
                InvalidateRect(hWnd, NULL, TRUE);
            }
            break;
            //////////////////////////////////////////////////////////////////////
        case WM_HSCROLL:
            switch(LOWORD(wParam))
            {
            case SB_LINEUP : iHscrollPos--; break;
            case SB_LINEDOWN : iHscrollPos++; break;
            case SB_PAGEUP : iHscrollPos -= 8; break;
            case SB_PAGEDOWN : iHscrollPos += 8; break;
            case SB_THUMBPOSITION : iHscrollPos = HIWORD(wParam); break;
            }
            iHscrollPos = max(0, min(iHscrollPos, MAX_WIDTH));
            if (iHscrollPos != GetScrollPos(hWnd, SB_HORZ))
            {
                SetScrollPos(hWnd, SB_HORZ, iHscrollPos, TRUE);
                InvalidateRect(hWnd, NULL, TRUE);
            }
            break;
            ////////////////////////////////////////////////////////////////////////
        
        case WM_LBUTTONDOWN:
            x1 = LOWORD(lParam);
            y1 = HIWORD(lParam);
            rec[count].x1=x1;
            rec[count].y1=y1;
            
            break;
 
        case WM_MOUSEMOVE:
            if(wParam & MK_LBUTTON)
            {
                x2 = LOWORD(lParam);
                y2 = HIWORD(lParam);
                InvalidateRect (hWnd, NULL, TRUE) ;
            }
            break;
        
        case WM_LBUTTONUP:
            rec[count].x2=LOWORD(lParam);
            rec[count].y2=HIWORD(lParam);
            count++;
            box=true;
            break;
 
        
        
        
        case WM_COMMAND:
            if(LOWORD(wParam) == ID_FIRSTCHILD)////Line
            {
                for(i=0;i<count;i++)
                {
                    rec[i].x1=0;
                    rec[i].x2=0;
                    rec[i].y1=0;
                    rec[i].y2=0;
                }
                count =0;
                temp = 2;
            }
 
            if(LOWORD(wParam) == ID_SECONDCHILD)///Rectangle
            {
                for(i=0;i<count;i++)
                {
                    rec[i].x1=0;
                    rec[i].x2=0;
                    rec[i].y1=0;
                    rec[i].y2=0;
                }
                count =0;
                temp = 0;
            }
 
            if(LOWORD(wParam) == ID_THIRDCHILD)////Ellipse
            {
                for(i=0;i<count;i++)
                {
                    rec[i].x1=0;
                    rec[i].x2=0;
                    rec[i].y1=0;
                    rec[i].y2=0;
                }
                temp = 1;
                count =0;
            }
 
            switch (LOWORD(wParam)) 
            {
                /*case ID_FILE_NEW:
                    szText[0] = '\0';
                    SetWindowTextA(hEdit, szText);
                    StatusOut (hWndStatusBar, 0, _T(" "));
                    if (!v.empty()) std::vector<std::string>().swap(v);
                    n = lenght = 0;
                    SendMessage(hWnd, WM_SIZE, 0, sy << 16 | sx);
                    InvalidateRect(hWnd,NULL,TRUE);
                    break; 
                case ID_FILE_OPEN:
                    file.lpstrTitle = _T("Открыть файл для чтения");
                    file.Flags = OFN_HIDEREADONLY;
                    if (!GetOpenFileName(&file)) return 1;
                    in.open(name, std::ios::binary);
                    in.read(szText, 0x7fff);
                    if ((m = in.gcount()) == 0x7fff)
                    {
                        MessageBox (hWnd, _T("Слишком большой файл"),
                                        _T("Edit"), MB_OK | MB_ICONSTOP);
                        in.close();
                        n = v.size();
                        SendMessage(hWnd, WM_SIZE, 0, sy << 16 | sx);
                        InvalidateRect(hWnd,NULL,1);
                        return 0;
                    }
                    szText [m] = '\0';
                    in.close();
                    SetWindowTextA(hEdit, szText);
                    n = SendMessage (hEdit, EM_GETLINECOUNT, 0, 0);
                    StatusOut(hWndStatusBar, n, name);
                    break;
                case ID_FILE_SAVE:
                    file.lpstrTitle = _T("Открыть файл для записи");
                    file.Flags = OFN_NOTESTFILECREATE | OFN_HIDEREADONLY;
                    if (!GetSaveFileName(&file)) return 1;
                    out.open(name, std::ios::binary);
                    m = GetWindowTextA(hEdit, szText, 0x7fff);
                    out.write(szText, m);
                    out.close();
                    n = SendMessage (hEdit, EM_GETLINECOUNT, 0, 0);
                    StatusOut(hWndStatusBar, n, name);
                    break;*/
 
                
                case IDM_ABOUT:
                    DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                    break;
                            
                case IDM_EXIT: 
                    DestroyWindow(hWnd); 
                    break;
                    default: 
                    return DefWindowProc(hWnd, message, wParam, lParam);
            }
            break;
        case WM_PAINT:                                              
            hdc = BeginPaint(hWnd, &ps);
            if(temp == 0)
            {
                if(box == true)
                {
                    for(i=0;i<count;i++)
                    {
                        Rectangle(hdc,rec[i].x1,rec[i].y1,rec[i].x2,rec[i].y2);
                    }
                }
                Rectangle(hdc, x1, y1, x2, y2);
                
            }
            if(temp == 1)
            {
                if(box == true)
                {
                    for(i=0;i<count;i++)
                    {
                        Ellipse(hdc,rec[i].x1,rec[i].y1,rec[i].x2,rec[i].y2);
                    }
                }
                Ellipse(hdc, x1, y1, x2, y2);
            }
            if(temp == 2)
            {
                if(box == true)
                {
                    for(i=0;i<count;i++)
                    {
                        MoveToEx(hdc, rec[i].x1, rec[i].y1, NULL);
                        LineTo(hdc, rec[i].x2, rec[i].y2);
                    }
                }
                MoveToEx(hdc, x1, y1, NULL);
                LineTo(hdc, x2, y2);
            }
            EndPaint(hWnd, &ps);
            break;
            
        case WM_DESTROY:
            PostQuitMessage(0);
            break;
        default:
            return DefWindowProc (hWnd, message, wParam, lParam);
    }
    
    return 0;
}
/////////////////////////////////////////////////////////////////////////////
// Message handler for about box.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;
 
    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}

...
CTypedPtrArray<CObArray, CPointX*> arpoint; // Массив точек (CPointX ваш класс для точек, в нем есть объект CPoint)
...
void CPointX::Serialize(CArchive& ar)
{
if(ar.IsStoring())
{ // storing code
ar << point.x << point.y; // Занесение данных в архив
} // для записи в файл
else
{ // loading code
ar >> point.x >> point.y; // Получение данных из архива
} // после чтения из файла
}
......
this->arpoint.Serialize(ar); //для записи в архив
...
//Вывод в контекст устройства
int sz = arpoint.GetSize();
 
for(int i = 0; i < sz; i++)
{
// Рисование текущего символа 'X'
pDC->TextOutA(arpoint.GetAt(i)->point.x,
arpoint.GetAt(i)->point.y, "X");
}