Nasýl yapýlýr: tam Sürükle geçersiz kýl

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

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

    #define STRICT
    #include <windows.h>


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

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

    BOOL g_fDragging;
    BOOL g_fPaintDeferred;


   /***********************************************************************
     *
    · Hilbert
     *
    · Draws a segment of the hilbert curve.
     *
    · The math is not important. What is important is that drawing
    · 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);
        }
    }


   /***********************************************************************
     *
    · Hilbert_OnPaint
     *
    · Handle the WM_PAINT message.
     *
    · If the user is dragging the window, then don't do painting,
    · because that would make the dragging very jerky. Instead, just
    · remember that there was a paint message that you ignored. After
    · the size/move is complete, you will perform one big paint to do
    · 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);
        }
    }


   /***********************************************************************
     *
    · Hilbert_WndProc
     *
    · 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;

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

        /*
    · When you finish a Size/Move operation, remember that you are
    · 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);
    }


   /***********************************************************************
     *
    · WinMain
     *
    · Program entry point.
     *
    · 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;
    }