velopack/samples/CPlusPlusWin32/CppWin32Sample.cpp

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <shellapi.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <iostream>

#include "constants.h"
#include "Velopack.hpp"

#pragma comment(linker, \
  "\"/manifestdependency:type='Win32' "\
  "name='Microsoft.Windows.Common-Controls' "\
  "version='6.0.0.0' "\
  "processorArchitecture='*' "\
  "publicKeyToken='6595b64144ccf1df' "\
  "language='*'\"")
#pragma comment(lib, "ComCtl32.lib")

using namespace Velopack;

HINSTANCE hInst;
const WCHAR szTitle[] = L"Velopack C++ Sample App";
const WCHAR szWindowClass[] = L"VeloCppWinSample";

std::unique_ptr<UpdateManager> manager;
std::optional<UpdateInfo> updInfo = std::nullopt;
bool downloaded = false;

// Forward declarations of functions included in this code module:
int					MessageBoxCentered(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType);
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
std::wstring        Utf8ToWString(std::string const& str);
std::string         WStringToUtf8(std::wstring const& wstr);

void handle_vpkc_log(void* pUserData, const char* pszLevel, const char* pszMessage)
{
    std::cout << pszLevel << ": " << pszMessage << std::endl;
}

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
    _In_opt_ HINSTANCE hPrevInstance,
    _In_ LPWSTR    lpCmdLine,
    _In_ int       nCmdShow)
{
    // Redirect StdOut to console window
    AllocConsole();
    FILE* fp;
    _wfreopen_s(&fp, L"CONOUT$", L"w", stdout);
    _wfreopen_s(&fp, L"CONOUT$", L"w", stderr);
    _wfreopen_s(&fp, L"CONIN$", L"r", stdin);

    // Initialize Velopack log capture
    std::cout << "Velopack C++ Sample App" << std::endl;
    vpkc_set_logger(handle_vpkc_log, 0);

    // This should run as early as possible in the main method.
    // Velopack may exit / restart the app at this point. 
    // See VelopackApp class for more options/configuration.
    VelopackApp::Build()
        .Run();

    try {
        // If the app is not installed, creating an UpdateManager will throw an exception.
        manager = std::make_unique<UpdateManager>(UPDATE_URL);
    }
    catch (std::exception& e) {
        std::wstring what = Utf8ToWString(e.what());
        MessageBoxCentered(nullptr, what.c_str(), szTitle, MB_OK | MB_ICONERROR);
        return 1;
    }

    MyRegisterClass(hInstance);
    if (!InitInstance(hInstance, nCmdShow)) {
        return FALSE;
    }

    // Main message loop:
    MSG msg;
    while (GetMessage(&msg, nullptr, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return (int)msg.wParam;
}

ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;
    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc = WndProc;
    wcex.cbClsExtra = 0;
    wcex.cbWndExtra = 0;
    wcex.hInstance = hInstance;
    wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wcex.lpszClassName = szWindowClass;
    wcex.hIcon = 0;
    wcex.hIconSm = 0;
    wcex.lpszMenuName = 0;
    return RegisterClassExW(&wcex);
}

HWND hCheckButton;
HWND hDownloadButton;
HWND hRestartButton;

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
    hInst = hInstance; // Store instance handle in our global variable

    HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, 0, 300, 260, nullptr, nullptr, hInstance, nullptr);

    hCheckButton = CreateWindowW(L"BUTTON", L"Check for updates",
        WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON,
        40, 50, 200, 40,
        hWnd, NULL, (HINSTANCE)GetWindowLongPtr(hWnd, GWLP_HINSTANCE), NULL);

    hDownloadButton = CreateWindowW(L"BUTTON", L"Download update",
        WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON,
        40, 100, 200, 40,
        hWnd, NULL, (HINSTANCE)GetWindowLongPtr(hWnd, GWLP_HINSTANCE), NULL);

    hRestartButton = CreateWindowW(L"BUTTON", L"Apply / Restart",
        WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON,
        40, 150, 200, 40,
        hWnd, NULL, (HINSTANCE)GetWindowLongPtr(hWnd, GWLP_HINSTANCE), NULL);

    if (!hWnd) {
        return FALSE;
    }

    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);

    return TRUE;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message) {
    case WM_COMMAND:
    {
        if (LOWORD(wParam) == BN_CLICKED) {
            if ((HWND)lParam == hCheckButton) {
                try {
                    updInfo = manager->CheckForUpdates();
                    if (updInfo.has_value()) {
                        std::string version = updInfo.value().TargetFullRelease.Version;
                        std::wstring message = L"Update available: " + Utf8ToWString(version);
                        MessageBoxCentered(hWnd, message.c_str(), szTitle, MB_OK);
                    }
                    else {
                        MessageBoxCentered(hWnd, L"No updates available.", szTitle, MB_OK);
                    }
                }
                catch (std::exception& e) {
                    std::wstring what = Utf8ToWString(e.what());
                    MessageBoxCentered(hWnd, what.c_str(), szTitle, MB_OK | MB_ICONERROR);
                }
            }
            else if ((HWND)lParam == hDownloadButton) {
                if (updInfo.has_value()) {
                    try {
                        manager->DownloadUpdates(updInfo.value());
                        downloaded = true;
                        MessageBoxCentered(hWnd, L"Download completed successfully.", szTitle, MB_OK);
                    }
                    catch (std::exception& e) {
                        std::wstring what = Utf8ToWString(e.what());
                        MessageBoxCentered(hWnd, what.c_str(), szTitle, MB_OK | MB_ICONERROR);
                    }
                }
                else {
                    MessageBoxCentered(hWnd, L"Check for updates first.", szTitle, MB_OK);
                }
            }
            else if ((HWND)lParam == hRestartButton) {
                if (!downloaded) {
                    MessageBoxCentered(hWnd, L"Download an update first.", szTitle, MB_OK);
                }
                else {
                    manager->WaitExitThenApplyUpdates(updInfo.value());
                    exit(0);
                }
            }
        }
        break;
    }
    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hWnd, &ps);
        RECT r{ 0, 5, ps.rcPaint.right, ps.rcPaint.bottom };

        std::string currentVersion = manager->GetCurrentVersion();
        auto ver = Utf8ToWString(currentVersion);
        std::wstring text = L"Welcome to v" + ver + L" of the\nVelopack C++ Sample App.";
        DrawText(hdc, text.c_str(), -1, &r, DT_BOTTOM | DT_CENTER);
        EndPaint(hWnd, &ps);
        break;
    }
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

int MessageBoxCentered(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType)
{
    if (hWnd == nullptr) {
        return MessageBox(hWnd, lpText, lpCaption, uType);
    }
    else {
        // Center message box at its parent window
        static HHOOK hHookCBT{};
        hHookCBT = SetWindowsHookEx(WH_CBT,
            [](int nCode, WPARAM wParam, LPARAM lParam) -> LRESULT
            {
                if (nCode == HCBT_CREATEWND) {
                    if (((LPCBT_CREATEWND)lParam)->lpcs->lpszClass == (LPWSTR)(ATOM)32770)  // #32770 = dialog box class
                    {
                        RECT rcParent{};
                        GetWindowRect(((LPCBT_CREATEWND)lParam)->lpcs->hwndParent, &rcParent);
                        ((LPCBT_CREATEWND)lParam)->lpcs->x = rcParent.left + ((rcParent.right - rcParent.left) - ((LPCBT_CREATEWND)lParam)->lpcs->cx) / 2;
                        ((LPCBT_CREATEWND)lParam)->lpcs->y = rcParent.top + ((rcParent.bottom - rcParent.top) - ((LPCBT_CREATEWND)lParam)->lpcs->cy) / 2;
                    }
                }

                return CallNextHookEx(hHookCBT, nCode, wParam, lParam);
            },
            0, GetCurrentThreadId());

        int iRet{ MessageBox(hWnd, lpText, lpCaption, uType) };

        UnhookWindowsHookEx(hHookCBT);

        return iRet;
    }
}

std::string WStringToUtf8(std::wstring const& wstr)
{
    if (wstr.empty()) return std::string();
    int size_needed = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), NULL, 0, NULL, NULL);
    std::string strTo(size_needed, 0);
    WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), &strTo[0], size_needed, NULL, NULL);
    return strTo;
}

std::wstring Utf8ToWString(std::string const& str)
{
    if (str.empty()) return std::wstring();
    int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), NULL, 0);
    std::wstring strTo(size_needed, 0);
    MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), &strTo[0], size_needed);
    return strTo;
}