¦p¦óÂмgº¡©ì¦²

   /***********************************************************************
    *
    ¡P Fulldrag.c
     *
    ¡P Copyright (c) 1997 Microsoft Corporation.
     *
    ¡P Abstract:
     *
    ¡P Sample program that demonstrates how a program can override
    ¡P Full Drag.
     *

   ***********************************************************************/ 

    #define STRICT
    #include <windows.h>


   /***********************************************************************
     *
    ¡P Globals
     *
    ¡P g_fMoveSize
     *
    ¡P Set while you are in a move/size loop. The WM_ENTERSIZEMOVE
    ¡P and WM_EXITSIZEMOVE messages tell you when these things happen.
     *
    ¡P g_fPaintDeferred
     *
    ¡P Set if you deferred a paint that occurred while you were
    ¡P busy doing a Move/Size. When the Move/Size completes
    ¡P and you discover that a paint was deferred, you force
    ¡P a full repaint to complete the deferred paint.
     *
     *
    ¡P Note:
     *
    ¡P In a real (that is, non-sample) program, these would not be global
    ¡P variables. They would be per-window variables.
     *

   ***********************************************************************/ 

    BOOL g_fDragging;
    BOOL g_fPaintDeferred;


   /***********************************************************************
     *
    ¡P Hilbert
     *
    ¡P Draws a segment of the hilbert curve.
     *
    ¡P The math is not important. What is important is that drawing
    ¡P a hilbert curve takes a long time.
     *

   ***********************************************************************/ 

    #define MAXDEPTH 8      /* Bigger depth takes longer to draw. */ 
    void
    Hilbert(HDC hdc, int x, int y, int vx, int vy, int wx, int wy, int n)
    {
    if (n >= MAXDEPTH) {
    LineTo(hdc, x + (vx+wx)/2, y + (vy+wy)/2);
    } else {
    n++;
    Hilbert(hdc, x, y, wx/2, wy/2, vx/2, vy/2, n);
    Hilbert(hdc, x+vx/2, y+vy/2, vx/2, vy/2, wx/2, wy/2, n);
    Hilbert(hdc, x+vx/2+wx/2, y+vy/2+wy/2, vx/2, vy/2, wx/2, wy/2, n);
    Hilbert(hdc, x+vx/2+wx, y+vy/2+wy, -wx/2, -wy/2, -vx/2, -vy/2, n);
        }
    }


   /***********************************************************************
     *
    ¡P Hilbert_OnPaint
     *
    ¡P Handle the WM_PAINT message.
     *
    ¡P If the user is dragging the window, then don't do painting,
    ¡P because that would make the dragging very jerky. Instead, just
    ¡P remember that there was a paint message that you ignored. After
    ¡P the size/move is complete, you will perform one big paint to do
    ¡P the things that you ignored.
     *

   ***********************************************************************/ 

    void
    Hilbert_OnPaint(HWND hwnd)
    {
    PAINTSTRUCT ps;
    RECT rc;
    HDC hdc;

    hdc = BeginPaint(hwnd, &ps);
    if (hdc) {
    if (g_fDragging) {
    g_fPaintDeferred = TRUE;
    } else {
    HBRUSH hbrOld;
    HPEN hpenOld;
    HCURSOR hcurOld;

    hcurOld = SetCursor(LoadCursor(0, IDC_WAIT));
    hbrOld = SelectObject(hdc, GetStockObject(BLACK_BRUSH)); hpenOld =
    SelectObject(hdc, GetStockObject(BLACK_PEN));
    MoveToEx(hdc, 0, 0, 0);
    Hilbert(hdc, 0, 0, GetSystemMetrics(SM_CXFULLSCREEN), 0,
    0, GetSystemMetrics(SM_CYFULLSCREEN), 0);
    SelectObject(hdc, hpenOld);
    SelectObject(hdc, hbrOld);
    SetCursor(hcurOld);
            }
    EndPaint(hwnd, &ps);
        }
    }


   /***********************************************************************
     *
    ¡P Hilbert_WndProc
     *
    ¡P Window procedure.
     *

   ***********************************************************************/ 

    LRESULT CALLBACK
    Hilbert_WndProc(HWND hwnd, UINT wm, WPARAM wp, LPARAM lp)
    {
    switch (wm) {
    case WM_PAINT:
    Hilbert_OnPaint(hwnd);
    break;

    case WM_DESTROY:
    PostQuitMessage(0); break;

        /*
    ¡P When you begin a Size/Move operation, remember that you are
    ¡P performing a Size/Move operation so you don't paint during the
    . Size/Move.
         */ 
    case WM_ENTERSIZEMOVE:
    g_fDragging = TRUE; break;

        /*
    ¡P When you finish a Size/Move operation, remember that you are
    ¡P performing a Size/Move operation so you will resume painting,
    . and if there were any deferred paint messages, re-invalidate
    . yourself they will be regenerated.
         */ 
    case WM_EXITSIZEMOVE:
    g_fDragging = FALSE;
    if (g_fPaintDeferred) {
    g_fPaintDeferred = FALSE;
    InvalidateRect(hwnd, 0, TRUE);
            }
    break;

        }

    return DefWindowProc(hwnd, wm, wp, lp);
    }


   /***********************************************************************
     *
    ¡P WinMain
     *
    ¡P Program entry point.
     *
    ¡P Register the class, create the window, and go into a message loop.
     *

   ***********************************************************************/ 

    int WINAPI
    WinMain(HINSTANCE hinst, HINSTANCE hinstPrev, LPSTR pszCmdLine, int
    nCmdShow)
    {
    HWND hwnd;
    MSG msg;
    WNDCLASS wc = {
    0,
    Hilbert_WndProc,
    0,
    0,
    hinst,
    LoadIcon(0, IDI_APPLICATION),
    LoadCursor(0, IDC_ARROW),
    (HBRUSH)(COLOR_WINDOW+1),
    0,
    "Hilbert"
        };

    RegisterClass(&wc);
    hwnd = CreateWindow("Hilbert", "Hilbert", WS_OVERLAPPEDWINDOW,
    CW_USEDEFAULT, CW_USEDEFAULT,
    CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, hinst, 0);
    ShowWindow(hwnd, nCmdShow);
    while (GetMessage(&msg, 0, 0, 0)) {
    TranslateMessage(&msg);
    DispatchMessage(&msg);
        }

    return 0;
    }