Windows Practice_闹钟（二）_简易记事本

Windows 编程学习方法

对于常用的几千个Windows API，我们是记不住的，所以我们需要常用常查，用多了自然而然的就熟悉了，有的API记得不是很清楚我们查文档，上网查资料就可以解决了。

简易记事本的完善

这个记事本支持在窗口上任意位置输入字符串，还有行与行以及字符与字符之间的对齐。

// Notepad.cpp : 定义应用程序的入口点。
//

#include "stdafx.h"
#include <string>
#include <vector>
#include "Notepad.h"

#define MAX_LOADSTRING 100

// 1 有一个窗口类，并且是在系统中注册的，也就说有两个窗口只需要注册一次就可以了。窗口类中有很多信息，这会决定Windows式样（窗口类加Style）
// 2 创建一个窗口，有各种各样的资源
// 3 显示窗口（showWindow）
// 4 响应窗口消息

std::wstring g_wstrBuf;
unsigned g_xPos = 0;
unsigned g_yPos = 0;

// 全局变量: 
HINSTANCE hInst;                                // 当前实例
WCHAR szTitle[MAX_LOADSTRING];                  // 标题栏文本
WCHAR szWindowClass[MAX_LOADSTRING];            // 主窗口类名
                                                // 此代码模块中包含的函数的前向声明: 
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 wWinMain(_In_ HINSTANCE hInstance,
    _In_opt_ HINSTANCE hPrevInstance,
    _In_ LPWSTR    lpCmdLine,
    _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    // TODO: 在此放置代码。

    // 初始化全局字符串
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_NOTEPAD, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);

    // 执行应用程序初始化: 
    if (!InitInstance(hInstance, nCmdShow))
    {
        return FALSE;
    }

    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_NOTEPAD));

    MSG msg;

    // 主消息循环: 
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    return (int)msg.wParam;
}

struct PaintData
{
    int x;
    int y;
    std::wstring wstrBuf;
};

std::vector<PaintData> g_vecPaintDatas;

//
//  函数: MyRegisterClass()
//
//  目的: 注册窗口类。
//
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.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_NOTEPAD));
    wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wcex.lpszMenuName = MAKEINTRESOURCEW(IDC_NOTEPAD);
    wcex.lpszClassName = szWindowClass;
    wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassExW(&wcex);
}

//
//   函数: InitInstance(HINSTANCE, int)
//
//   目的: 保存实例句柄并创建主窗口
//
//   注释: 
//
//        在此函数中，我们在全局变量中保存实例句柄并
//        创建和显示主程序窗口。
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
    hInst = hInstance; // 将实例句柄存储在全局变量中

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

    if (!hWnd)
    {
        return FALSE;
    }

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

    return TRUE;
}

//
//  函数: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  目的:    处理主窗口的消息。
//
//  WM_COMMAND  - 处理应用程序菜单
//  WM_PAINT    - 绘制主窗口
//  WM_DESTROY  - 发送退出消息并返回
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_COMMAND:
    {
        int wmId = LOWORD(wParam);
        // 分析菜单选择: 
        switch (wmId)
        {
        case IDM_ABOUT:
            DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
            break;
        case IDM_EXIT:
            DestroyWindow(hWnd);
            break;
        case IDM_REPEAL:
            if (g_vecPaintDatas.size() > 0)
            {
                g_wstrBuf.clear();
                g_vecPaintDatas.pop_back();
                InvalidateRect(hWnd, nullptr, TRUE);
            }
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
        }
    }
    break;
    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hWnd, &ps);

        if (g_wstrBuf.length() > 0)
        {
            if (g_vecPaintDatas.size() > 0)
            {
                PaintData data = { 0 };
                data.x = g_xPos;
                data.y = g_yPos;
                data.wstrBuf = g_wstrBuf;

                if (g_vecPaintDatas.back().x == g_xPos && g_vecPaintDatas.back().y == g_yPos)
                {
                    g_vecPaintDatas.pop_back();
                }

                g_vecPaintDatas.push_back(data);
            }
            else
            {
                PaintData data = { 0 };
                data.x = g_xPos;
                data.y = g_yPos;
                data.wstrBuf = g_wstrBuf;
                g_vecPaintDatas.push_back(data);
            }
        }

        for (auto value : g_vecPaintDatas)
        {
            TextOut(hdc, value.x, value.y, value.wstrBuf.c_str(), value.wstrBuf.length());
        }

        EndPaint(hWnd, &ps);
    }
    break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    case WM_CHAR:
        if (wParam == VK_RETURN)
        {
            g_yPos += 15;
            g_xPos = 0;
            g_wstrBuf.clear();
        }
        else
        {
            g_wstrBuf += wchar_t(wParam);
            InvalidateRect(hWnd, nullptr, TRUE);
        }
        break;
    case WM_LBUTTONDOWN:
    {
        g_wstrBuf.clear();
        POINT pt;
        GetCursorPos(&pt);
        ScreenToClient(hWnd, &pt);
        g_yPos = pt.y;
        g_xPos = pt.x;
        g_xPos += 5;
        g_yPos += 7;

        g_xPos = (g_xPos -= g_xPos % 10);
        g_yPos = (g_yPos -= g_yPos % 15);
    }
    break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

// “关于”框的消息处理程序。
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;
}

这个记事本程序需要注意的一些点

**鼠标坐标的获取**msdn中强调的源文如下：Important Do not use the LOWORD or HIWORD macros to extract the x- and y- coordinates of the cursor position because these macros return incorrect results on systems with multiple monitors. Systems with multiple monitors can have negative x- and y- coordinates, and LOWORD and HIWORD treat the coordinates as unsigned quantities.
大概意思是说使用LOWORD 和HIWORD在多屏幕情况下会出错。应该使用：
xPos = GET_X_LPARAM(lParam);
yPos = GET_Y_LPARAM(lParam);
来获取x坐标和y坐标。但是这两个函数只有在Windows 2000之后的系统中才被支持。并且它的头文件在Windowsx.h头文件中定义的。
历史字符串的保存由于WM_PAINT会刷新窗口，将之前的数据都清空，所以我们需要把所有的字符串都保存起来（当然了，正儿八经的记事本是以字符为单位来存储的，我们这里是以字符串来存储的），每一次发生WM_PAINT消息的时候把所有的字符串来输出。

设备上下文DC

我们之所以能够在窗口上显示字符串，是因为我们有了DC设备上下文。HDC是DC的句柄，是一个内核对象。
DC是针对于某一个窗口来说的，桌面是一个顶级窗口。也就是说，如果能拿到桌面DC，就可以在桌面绘图了。
DC是和窗口（HWND）绑定的，也是说，我们不需要通过名称获取DC的内核对象，使用窗口句柄就可以获取HDC了。

在桌面上绘制10等分的棋盘

#include <string>
#include <conio.h>
#include <Windows.h>

int main()
{
    //DC
    // 获取桌面大小
    // 10等分
    // 绘制棋盘

    HWND hWnd = GetDesktopWindow();

    int xScreen = GetSystemMetrics(SM_CXSCREEN);
    int yScreen = GetSystemMetrics(SM_CYSCREEN);

    HDC hDc = GetDC(hWnd);
    HDC memDc = CreateCompatibleDC(hDc);
    HBITMAP hbitmap = CreateCompatibleBitmap(hDc, xScreen, yScreen);
    SelectObject(memDc, hbitmap);


    xScreen -= 4;
    yScreen -= 4;
    HPEN hpen = CreatePen(PS_SOLID, 4, RGB(255, 0, 0));
    SelectObject(memDc, hpen);

    BYTE keyState[256] = { 0 };
    bool bQuit = false;
    POINT ptStart;
    POINT ptEnd;

    printf("请按任意键退出！\r\n");
    while (true)
    {
        ptStart.x = 0;
        ptStart.y = 2;
        ptEnd.x = xScreen;
        ptEnd.y = 2;
        POINT ptOut;
        for (int i = 0; i <= 10; ++i)
        {
            MoveToEx(memDc, ptStart.x, ptStart.y, &ptOut);
            LineTo(memDc, ptEnd.x, ptEnd.y);

            ptStart.y += yScreen / 10;
            ptEnd.y += yScreen / 10;

            if (_kbhit())
            {
                bQuit = true;
                break;
            }
        }

        ptStart.x = 2;
        ptStart.y = 0;
        ptEnd.x = 2;
        ptEnd.y = yScreen;

        for (int i = 0; i <= 10; ++i)
        {
            MoveToEx(memDc, ptStart.x, ptStart.y, &ptOut);
            LineTo(memDc, ptEnd.x, ptEnd.y);

            ptStart.x += xScreen / 10;
            ptEnd.x += xScreen / 10;

            if (_kbhit())
            {
                bQuit = true;
                break;
            }
        }

        BitBlt(hDc, 0, 0, xScreen + 4, yScreen + 4, memDc, 0, 0, SRCCOPY);

        if (bQuit)
        {
            ::InvalidateRect(nullptr, nullptr, TRUE);
            break;
        }
    }

    system("pause");
    return 0;
}

上述代码问题，虽然用到了双缓冲，但是它使得整个桌面变得不透明了，整个桌面都被这个棋盘遮挡住了，这是双缓存使用不当，应该让黄缓冲创建一个透明的位图既可以解决这个问题。
以后有时间再解决吧！！！