Win32Project1/main.cpp

#include <windows.h>
#include <windowsx.h>
#include <CommCtrl.h>
#include <gdiplus.h>
#include <string>
#include <vector>
#include "enums.h"

using namespace std;
using namespace Gdiplus;

namespace Win32Project1
{
    HWND hMainWindow;
    HWND hMainWindowStatusBar;
    LPCWSTR openImageFilename;
    Image* pOpenImage;
    vector<HMENU> ddMenuHandles(255);
    int clientAreaWidth = 800;
    int clientAreaHeight = 600;
    UINT windowStyle = WS_OVERLAPPED | WS_MINIMIZEBOX | WS_SYSMENU;
    HANDLE hConsoleOutput;
    Point prevMousePos;
    Point curMousePos;
    Color color = Color::Black;
    Tool tool = Tool::Brush;
    DrawingMode drawingMode = DrawingMode::DrawOnImage;
    BOOL isImageLoaded = FALSE;
    BOOL debug = TRUE;
    BOOL isDrawing = FALSE;

    OPENFILENAME CreateOFN(HWND hOwnerWindow = hMainWindow)
    {
        OPENFILENAME ofn;
        WCHAR filename[MAX_PATH];
        ZeroMemory(&ofn, sizeof(ofn));

        ofn.lStructSize = sizeof(ofn);
        ofn.hwndOwner = hOwnerWindow;
        ofn.lpstrFile = filename;
        ofn.lpstrFile[0] = '\0';
        ofn.nMaxFile = sizeof(filename);
        ofn.lpstrFilter = L"All\0*.*\0Text\0*.TXT\0";
        ofn.nFilterIndex = 1;
        ofn.lpstrFileTitle = NULL;
        ofn.nMaxFileTitle = 0;
        ofn.lpstrInitialDir = NULL;
        ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;

        return ofn;
    }

    CHOOSECOLOR CreateCC(HWND hOwnerWindow = hMainWindow)
    {
        CHOOSECOLOR cc;
        COLORREF cr[16];
        ZeroMemory(&cc, sizeof(CHOOSECOLOR));

        cc.lStructSize = sizeof(CHOOSECOLOR);
        cc.hwndOwner = hOwnerWindow;
        cc.rgbResult = RGB(255, 255, 255);
        cc.lpCustColors = cr;
        cc.Flags = CC_RGBINIT | CC_FULLOPEN;

        return cc;
    }

    int MessageBox(LPCWSTR text, LPCWSTR caption = L"Alert", long type = MB_OK, HWND hWnd = hMainWindow)
    {
        return MessageBox(hWnd, text, caption, type);
    }

    void SetAppState(LPCWSTR state = L"Ready")
    {
        SetWindowText(hMainWindow, (wstring(L"[D3DTest1] ") + state).c_str());
        SendMessage(hMainWindowStatusBar, SB_SETTEXT, 0, (LPARAM)state);
    }

    void OnKeyDown(WPARAM virtualKeyCode)
    {
        wstring yptfk = L"You pressed the following key: \n";
        int charCode = MapVirtualKey(virtualKeyCode, MAPVK_VK_TO_CHAR);
        WCHAR key = (WCHAR)charCode;
        wstring text = yptfk + L"Character: \"" + key + L"\"\nCharcode: " + to_wstring(charCode);
        MessageBox(text.c_str());
    }

    Point GetWindowPos(HWND hWnd = hMainWindow)
    {
        RECT wr;
        GetWindowRect(hWnd, &wr);
        return Point(wr.left, wr.top);
    }

    Size AdjustWindowSize(int clientAreaWidth, int clientAreaHeight)
    {
        RECT wr = { 0, 0, clientAreaWidth, clientAreaHeight };
        AdjustWindowRect(&wr, windowStyle, FALSE);
        return Size(wr.right - wr.left, wr.bottom - wr.top);
    }

    void SetClientAreaSize(int width, int height, HWND hWnd = hMainWindow)
    {
        clientAreaWidth = width;
        clientAreaHeight = height;
        Size wndSize = AdjustWindowSize(width, height);
        Point wndPos = GetWindowPos();
        MoveWindow(hWnd, wndPos.X, wndPos.Y, wndSize.Width, wndSize.Height, TRUE);
    }

    // Not tested yet.

    void SetWindowBackgroundImage(LPCWSTR filename, HWND hWnd = hMainWindow)
    {
        HBITMAP hImage = (HBITMAP)LoadImage(NULL, filename, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
        SendMessage(hWnd, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)hImage);
    }

    void DrawImageToWindow(HWND hWnd = hMainWindow)
    {
        if (isImageLoaded)
        {
            Graphics gc(GetDC(hWnd));
            Rect clientArea(0, 0, clientAreaWidth, clientAreaHeight);
            gc.DrawImage(pOpenImage, clientArea);
        }
        SendMessage(hMainWindowStatusBar, WM_PAINT, NULL, NULL);
    }

    ImageCodecInfo* GetICIs()
    {
        UINT numOfEncoders = 0;
        UINT iciBufferSize = 0;
        GetImageEncodersSize(&numOfEncoders, &iciBufferSize);
        ImageCodecInfo* iciBuffer = new ImageCodecInfo[iciBufferSize];
        GetImageEncoders(numOfEncoders, iciBufferSize, iciBuffer);
        return iciBuffer;
    }

    LPWSTR ClassIdToString(CLSID classId)
    {
        LPOLESTR string = new OLECHAR[500];
        StringFromCLSID(classId, &string);
        return string;
    }

    CLSID GetEncoderClassIDByMimeType(LPCWSTR mimeType)
    {
        ImageCodecInfo* icis = GetICIs();
        for (int i = 0; i != sizeof(icis); i++)
        {
            auto ici = icis[i];

            if (wcscmp(mimeType, ici.MimeType) == 0)
            {
                return ici.Clsid;
            }
        }
    }

    void SaveFile(LPCWSTR filename)
    {
        if (filename != NULL)
        {
            Graphics gc(pOpenImage);
            HDC hMainWindowDc = GetDC(hMainWindow);
            HDC hImageDc = gc.GetHDC();
            BitBlt(hImageDc, 0, 0, clientAreaWidth, clientAreaHeight, hMainWindowDc, 0, 0, SRCCOPY);
            const CLSID jpegEncoder = GetEncoderClassIDByMimeType(L"image/bmp");
            pOpenImage->Save(filename, &jpegEncoder, NULL);
        }
    }

    LPWSTR GetFilenameToSave()
    {
        OPENFILENAME ofn = CreateOFN();
        if (GetSaveFileName(&ofn))
        {
            LPWSTR filename = new WCHAR[MAX_PATH];
            wcscpy(filename, ofn.lpstrFile);
            return filename;
        }
        else
        {
            return NULL;
        }
    }

    void LoadFile(LPCWSTR filename)
    {
        if (filename != NULL)
        {
            if (!isImageLoaded)
            {
                EnableMenuItem(ddMenuHandles[Tbi::FileMenu], Tbi::File_Save, MF_ENABLED);
                openImageFilename = filename;
                pOpenImage = Image::FromFile(filename);
                int width = pOpenImage->GetWidth();
                int height = pOpenImage->GetHeight();
                if (width != NULL & height != NULL)
                {
                    isImageLoaded = TRUE;
                    SetClientAreaSize(width, height);
                    DrawImageToWindow();
                    SetAppState((wstring(L"Loaded image: ") + wstring(filename)).c_str());
                }
                else
                {
                    MessageBox(L"Could not load image!", L"Error!", MB_ICONERROR | MB_OK);
                }
            }
            else
            {
                int mbResult = MessageBox(L"Save file before opening another?", L"Save", MB_YESNOCANCEL);
                if (mbResult == IDYES)
                {
                    if (LPCWSTR fn = GetFilenameToSave())
                    {
                        SaveFile(fn);
                        isImageLoaded = FALSE;
                        LoadFile(filename);
                    }
                }
                else if (mbResult == IDNO)
                {
                    isImageLoaded = FALSE;
                    LoadFile(filename);
                }
            }
        }
    }

    void WriteFileA(HANDLE hFile, LPCSTR data)
    {
        WriteFile(hFile, data, strlen(data), 0, NULL);
    }

    LPCSTR ToString(int number)
    {
        LPSTR string = "";
        strcpy(string, to_string(number).c_str());
        return string;
    }

    void Log(LPCSTR data)
    {
        if (debug)
        {
            WriteFileA(hConsoleOutput, data);
            WriteFileA(hConsoleOutput, "\n");
        }
    }

    void Log(int data)
    {
        Log(ToString(data));
    }

    LPWSTR GetFilenameToOpen()
    {
        OPENFILENAME ofn = CreateOFN();
        if (GetOpenFileName(&ofn))
        {
            LPWSTR filename = new WCHAR[MAX_PATH];
            wcscpy(filename, ofn.lpstrFile);
            return filename;
        }
        else
        {
            return NULL;
        }
    }

    void DrawLine(Point pt1 = prevMousePos, Point pt2 = curMousePos)
    {
        Pen pen(color, 10);
        if (drawingMode == DrawingMode::DrawOnWindow)
        {
            Graphics gc(GetDC(hMainWindow));
            gc.DrawLine(&pen, pt1, pt2);
        }
        else if (drawingMode == DrawingMode::DrawOnImage)
        {
            Graphics gc(pOpenImage);
            gc.DrawLine(&pen, pt1, pt2);
            DrawImageToWindow();
        }
    }

    Point GetMousePos(LPARAM lParam)
    {
        Point mousePos;
        mousePos.X = GET_X_LPARAM(lParam);
        mousePos.Y = GET_Y_LPARAM(lParam);
        return mousePos;
    }

    void FlipMousePositions(LPARAM lParam)
    {
        prevMousePos = curMousePos;
        curMousePos = GetMousePos(lParam);
    }

    void LogMousePos(Point pos)
    {
        Log("X:");
        Log(pos.X);
        Log("Y:");
        Log(pos.Y);
    }

    void PickAColor()
    {
        CHOOSECOLOR cc = CreateCC();
        ChooseColor(&cc);
        COLORREF cr = cc.rgbResult;
        BYTE R = GetRValue(cr);
        BYTE G = GetGValue(cr);
        BYTE B = GetBValue(cr);
        color = Color(R, G, B);
    }

    void UncheckAllTbis(Tbi container)
    {
        for (int i = 0; i != 50; i++)
        {
            CheckMenuItem(ddMenuHandles[container], i, MF_BYPOSITION | MF_UNCHECKED);
        }
    }

    void CheckTbi(Tbi container, Tbi target)
    {
        UncheckAllTbis(container);
        CheckMenuItem(ddMenuHandles[container], target, MF_BYCOMMAND | MF_CHECKED);
    }

    LRESULT CALLBACK OnWindowMessage(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
    {
        int mbResult;
        switch (message)
        {
            case WM_CLOSE:
                if (isImageLoaded)
                {
                    mbResult = MessageBox(L"Save changes before exiting?", L"Exit", MB_YESNOCANCEL | MB_ICONWARNING);
                    if (mbResult == IDYES)
                    {
                        SaveFile(GetFilenameToSave());
                    }
                    else if(mbResult == IDNO)
                    {
                        DestroyWindow(hWnd);
                    }
                }
                else
                {
                    DestroyWindow(hWnd);
                }
                return 0;
            break;

            case WM_DESTROY:
                PostQuitMessage(0);
                return 0;
            break;

            case WM_KEYDOWN:
                OnKeyDown(wParam);
            break;

            case WM_PAINT:
                DrawImageToWindow();
            break;

            case WM_COMMAND:
                switch (Tbi tbi = (Tbi)LOWORD(wParam))
                {
                    case Tbi::File_Open:
                        LoadFile(GetFilenameToOpen());
                    break;

                    case Tbi::File_Save:
                        SaveFile(GetFilenameToSave());
                    break;

                    case Tbi::Tool_Brush:
                        tool = Tool::Brush;
                        CheckTbi(Tbi::ToolMenu, tbi);
                    break;

                    case Tbi::Tool_Line:
                        tool = Tool::Line;
                        CheckTbi(Tbi::ToolMenu, tbi);
                    break;

                    case Tbi::Tool_ColorPicker:
                        PickAColor();
                    break;
                }
            break;

            case WM_MOUSEMOVE:
                if (isDrawing)
                {
                    switch (tool)
                    {
                        case Tool::Brush:
                            FlipMousePositions(lParam);
                            DrawLine();
                        break;
                    }
                }
            break;

            case WM_LBUTTONDOWN:
                switch (tool)
                {
                    case Tool::Brush:
                        isDrawing = TRUE;
                        curMousePos = GetMousePos(lParam);
                    break;

                    case Tool::Line:
                        isDrawing = TRUE;
                        curMousePos = GetMousePos(lParam);
                    break;
                }
            break;

            case WM_LBUTTONUP:
                switch (tool)
                {
                    case Tool::Brush:
                        isDrawing = FALSE;
                    break;

                    case Tool::Line:
                        isDrawing = FALSE;
                        FlipMousePositions(lParam);
                        DrawLine();
                    break;
                }
            break;
        }
        return DefWindowProc(hWnd, message, wParam, lParam);
    }

    HWND CreateStatusBar(HWND hParentWindow, int id, LPCWSTR text = L"Ready")
    {
        return CreateStatusWindow(WS_CHILD | WS_VISIBLE, text, hParentWindow, id);
    }

    HMENU CreateMainWindowToolbar()
    {
        HMENU hToolbar = CreateMenu();

        HMENU hFileMenu = CreatePopupMenu();
        AppendMenu(hFileMenu, MF_STRING, Tbi::File_Open, L"Open");
        AppendMenu(hFileMenu, MF_STRING | MF_DISABLED, Tbi::File_Save, L"Save");
        // AppendMenu(hFileMenu, MF_STRING, Tbi::File_Close, L"Close");

        HMENU hToolMenu = CreatePopupMenu();
        AppendMenu(hToolMenu, MF_STRING, Tbi::Tool_Line, L"Line");
        AppendMenu(hToolMenu, MF_STRING | MF_CHECKED, Tbi::Tool_Brush, L"Brush");
        AppendMenu(hToolMenu, MF_STRING, Tbi::Tool_ColorPicker, L"Color Picker");

        AppendMenu(hToolbar, MF_POPUP, (UINT_PTR)hFileMenu, L"File");
        AppendMenu(hToolbar, MF_POPUP, (UINT_PTR)hToolMenu, L"Tool");

        ddMenuHandles.at(Tbi::FileMenu) = hFileMenu;
        ddMenuHandles.at(Tbi::ToolMenu) = hToolMenu;

        return hToolbar;
    }

    void LoadConsole()
    {
        AllocConsole();
        hConsoleOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    }

    int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
    {
        if (debug)
        {
            LoadConsole();
        }

        WNDCLASSEX wc;
        ZeroMemory(&wc, sizeof(wc));

        wc.cbSize = sizeof(WNDCLASSEX);
        wc.style = CS_HREDRAW | CS_VREDRAW;
        wc.lpfnWndProc = OnWindowMessage;
        wc.hInstance = hInstance;
        wc.hCursor = LoadCursor(NULL, IDC_ARROW);
        wc.hbrBackground = CreateSolidBrush(RGB(255, 255, 255));
        wc.lpszClassName = L"WC_Default";

        RegisterClassEx(&wc);

        Size sz = AdjustWindowSize(clientAreaWidth, clientAreaHeight);
        HMENU hMainWindowMenu = CreateMainWindowToolbar();

        GdiplusStartupInput gdipsi;
        ULONG_PTR gdipToken;
        GdiplusStartup(&gdipToken, &gdipsi, NULL);

        hMainWindow = CreateWindowEx
        (
            NULL,
            L"WC_Default",
            L"[D3DTest1] Loading",
            windowStyle,
            300,
            300,
            sz.Width,
            sz.Height,
            NULL,
            hMainWindowMenu,
            hInstance,
            NULL
        );

        hMainWindowStatusBar = CreateStatusBar(hMainWindow, 0);
        SetAppState(L"Ready");
        ShowWindow(hMainWindow, SW_RESTORE);

        MSG message;
        while (GetMessage(&message, NULL, 0, 0))
        {
            TranslateMessage(&message);
            DispatchMessage(&message);
        }

        GdiplusShutdown(gdipToken);

        return 0;
    }
}

int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
    Win32Project1::WinMain(hInstance, hPrevInstance, lpCmdLine, nShowCmd);
};