Freigeben über

Verwenden von Cursorn

In diesem Abschnitt werden die folgenden Themen erläutert.

Erstellen eines Cursors

Im folgenden Beispiel werden zwei Cursorhandles erstellt: eine für den Standard-Sanduhrcursor und einen für einen benutzerdefinierten Cursor, der als Ressource in der Ressourcendefinitionsdatei der Anwendung enthalten ist.

HINSTANCE hinst;            // handle to current instance 
HCURSOR hCurs1, hCurs2;     // cursor handles 
 
// Create a standard hourglass cursor. 
 
hCurs1 = LoadCursor(NULL, IDC_WAIT); 
 
// Create a custom cursor based on a resource. 
 
hCurs2 = LoadCursor(hinst, MAKEINTRESOURCE(240));

Anwendungen sollten benutzerdefinierte Cursor als Ressourcen implementieren und LoadCursor, LoadCursorFromFile oder LoadImage verwenden, anstatt den Cursor zur Laufzeit zu erstellen. Die Verwendung von Cursorressourcen vermeidet Geräteabhängigkeit, vereinfacht die Lokalisierung und ermöglicht Es Anwendungen, Cursordesigns gemeinsam zu nutzen.

Im folgenden Beispiel wird die CreateCursor-Funktion verwendet, um zur Laufzeit einen benutzerdefinierten Monochromcursor zu erstellen. Das Beispiel wird hier bereitgestellt, um zu veranschaulichen, wie das System Cursormasken interpretiert.

HINSTANCE hinst;            // handle to current instance  
HCURSOR hCurs1, hCurs2;     // cursor handles 
 
HCURSOR hCurs3;             // cursor handle 
 
// Yin-shaped cursor AND mask (32x32x1bpp)
 BYTE ANDmaskCursor[] =
{
    0xFF, 0xFC, 0x3F, 0xFF,   // ##############----##############
    0xFF, 0xC0, 0x1F, 0xFF,   // ##########---------#############
    0xFF, 0x00, 0x3F, 0xFF,   // ########----------##############
    0xFE, 0x00, 0xFF, 0xFF,   // #######---------################
    0xF8, 0x01, 0xFF, 0xFF,   // #####----------#################
    0xF0, 0x03, 0xFF, 0xFF,   // ####----------##################
    0xF0, 0x03, 0xFF, 0xFF,   // ####----------##################
    0xE0, 0x07, 0xFF, 0xFF,   // ###----------###################
    0xC0, 0x07, 0xFF, 0xFF,   // ##-----------###################
    0xC0, 0x0F, 0xFF, 0xFF,   // ##----------####################
    0x80, 0x0F, 0xFF, 0xFF,   // #-----------####################
    0x80, 0x0F, 0xFF, 0xFF,   // #-----------####################
    0x80, 0x07, 0xFF, 0xFF,   // #------------###################
    0x00, 0x07, 0xFF, 0xFF,   // -------------###################
    0x00, 0x03, 0xFF, 0xFF,   // --------------##################
    0x00, 0x00, 0xFF, 0xFF,   // ----------------################
    0x00, 0x00, 0x7F, 0xFF,   // -----------------###############
    0x00, 0x00, 0x1F, 0xFF,   // -------------------#############
    0x00, 0x00, 0x0F, 0xFF,   // --------------------############
    0x80, 0x00, 0x0F, 0xFF,   // #-------------------############
    0x80, 0x00, 0x07, 0xFF,   // #--------------------###########
    0x80, 0x00, 0x07, 0xFF,   // #--------------------###########
    0xC0, 0x00, 0x07, 0xFF,   // ##-------------------###########
    0xC0, 0x00, 0x0F, 0xFF,   // ##------------------############
    0xE0, 0x00, 0x0F, 0xFF,   // ###-----------------############
    0xF0, 0x00, 0x1F, 0xFF,   // ####---------------#############
    0xF0, 0x00, 0x1F, 0xFF,   // ####---------------#############
    0xF8, 0x00, 0x3F, 0xFF,   // #####-------------##############
    0xFE, 0x00, 0x7F, 0xFF,   // #######----------###############
    0xFF, 0x00, 0xFF, 0xFF,   // ########--------################
    0xFF, 0xC3, 0xFF, 0xFF,   // ##########----##################
    0xFF, 0xFF, 0xFF, 0xFF    // ################################
};
 
// Yin-shaped cursor XOR mask (32x32x1bpp)
BYTE XORmaskCursor[] =
{
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x03, 0xC0, 0x00,   // --------------####--------------
    0x00, 0x3F, 0x00, 0x00,   // ----------######----------------
    0x00, 0xFE, 0x00, 0x00,   // --------#######-----------------
    0x03, 0xFC, 0x00, 0x00,   // ------########------------------
    0x07, 0xF8, 0x00, 0x00,   // -----########-------------------
    0x07, 0xF8, 0x00, 0x00,   // -----########-------------------
    0x0F, 0xF0, 0x00, 0x00,   // ----########--------------------
    0x1F, 0xF0, 0x00, 0x00,   // ---#########--------------------
    0x1F, 0xE0, 0x00, 0x00,   // ---########---------------------
    0x3F, 0xE0, 0x00, 0x00,   // --#########---------------------
    0x3F, 0xE0, 0x00, 0x00,   // --#########---------------------
    0x3F, 0xF0, 0x00, 0x00,   // --##########--------------------
    0x7F, 0xF0, 0x00, 0x00,   // -###########--------------------
    0x7F, 0xF8, 0x00, 0x00,   // -############-------------------
    0x7F, 0xFC, 0x00, 0x00,   // -#############------------------
    0x7F, 0xFF, 0x00, 0x00,   // -###############----------------
    0x7F, 0xFF, 0x80, 0x00,   // -################---------------
    0x7F, 0xFF, 0xE0, 0x00,   // -##################-------------
    0x3F, 0xFF, 0xE0, 0x00,   // --#################-------------
    0x3F, 0xC7, 0xF0, 0x00,   // --########----######------------
    0x3F, 0x83, 0xF0, 0x00,   // --#######------#####------------
    0x1F, 0x83, 0xF0, 0x00,   // ---######------#####------------
    0x1F, 0x83, 0xE0, 0x00,   // ---######------####-------------
    0x0F, 0xC7, 0xE0, 0x00,   // ----######----#####-------------
    0x07, 0xFF, 0xC0, 0x00,   // -----#############--------------
    0x07, 0xFF, 0xC0, 0x00,   // -----#############--------------
    0x01, 0xFF, 0x80, 0x00,   // -------##########---------------
    0x00, 0xFF, 0x00, 0x00,   // --------########----------------
    0x00, 0x3C, 0x00, 0x00,   // ----------####------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00    // --------------------------------
};
 
// Create a custom cursor at run time. 
 
hCurs3 = CreateCursor( hinst,   // app. instance 
             19,                // horizontal position of hot spot 
             2,                 // vertical position of hot spot 
             32,                // cursor width 
             32,                // cursor height 
             ANDmaskCursor,     // AND mask 
             XORmaskCursor );   // XOR mask

Um den Cursor zu erstellen, wendet CreateCursor die folgende Wahrheitstabelle auf die Masken AND und XOR an.

UND Maske XOR-Maske Bildschirm
0 0 Schwarz
0 1 Weiß
1 0 Bildschirm
1 1 Umgekehrter Bildschirm

Weitere Informationen finden Sie unter Bitmaps.

Erstellen eines alpha-gemischten Cursors

Führen Sie die folgenden Schritte aus, um zur Laufzeit einen alpha-gemischten Cursor oder ein Symbol zu erstellen:

  • Vervollständigen Sie eine BITMAPV5HEADER Struktur, wie im folgenden Codebeispiel gezeigt, um ein alpha-gemischtes DIB (32 Bit pro Pixel) zu definieren.
  • Rufen Sie die CreateDIBSection-Funktion auf, um einen DIB-Abschnitt basierend auf der BITMAPV5HEADER Struktur zu erstellen, die Sie abgeschlossen haben.
  • Verwenden Sie die gewünschten Bitmap- und Alphainformationen für Ihren alpha-gemischten Cursor oder Ihr Symbol, um den DIB-Abschnitt abzuschließen.
  • Füllen Sie eine ICONINFO-Struktur aus.
  • Platzieren Sie eine leere monochrome Bitmap im hbmMask-Feld, und platzieren Sie den alpha-geblendeten DIB-Abschnitt im hbmColor-Feld.
  • Rufen Sie die CreateIconIndirect-Funktion auf, um den alpha-gemischten Cursor oder das Symbol zu erstellen.

Der folgende Code veranschaulicht, wie sie einen alpha-gemischten Cursor erstellen. Sie können denselben Code verwenden, um ein alpha-gemischtes Symbol zu erstellen, indem Sie das fIcon-Element der ICONINFO-Struktur in WAHR ändern:

HCURSOR CreateAlphaCursor(void)
{
    HDC hMemDC;
    DWORD dwWidth, dwHeight;
    BITMAPV5HEADER bi;
    HBITMAP hBitmap, hOldBitmap;
    void *lpBits;
    DWORD x,y;
    HCURSOR hAlphaCursor = NULL;

    dwWidth  = 32;  // width of cursor
    dwHeight = 32;  // height of cursor

    ZeroMemory(&bi,sizeof(BITMAPV5HEADER));
    bi.bV5Size           = sizeof(BITMAPV5HEADER);
    bi.bV5Width           = dwWidth;
    bi.bV5Height          = dwHeight;
    bi.bV5Planes = 1;
    bi.bV5BitCount = 32;
    bi.bV5Compression = BI_BITFIELDS;
    // The following mask specification specifies a supported 32 BPP
    // alpha format for Windows XP.
    bi.bV5RedMask   =  0x00FF0000;
    bi.bV5GreenMask =  0x0000FF00;
    bi.bV5BlueMask  =  0x000000FF;
    bi.bV5AlphaMask =  0xFF000000; 

    HDC hdc;
    hdc = GetDC(NULL);

    // Create the DIB section with an alpha channel.
    hBitmap = CreateDIBSection(hdc, (BITMAPINFO *)&bi, DIB_RGB_COLORS, 
        (void **)&lpBits, NULL, (DWORD)0);

    hMemDC = CreateCompatibleDC(hdc);
    ReleaseDC(NULL,hdc);

    // Draw something on the DIB section.
    hOldBitmap = (HBITMAP)SelectObject(hMemDC, hBitmap);
    PatBlt(hMemDC,0,0,dwWidth,dwHeight,WHITENESS);
    SetTextColor(hMemDC,RGB(0,0,0));
    SetBkMode(hMemDC,TRANSPARENT);
    TextOut(hMemDC,0,9,"rgba",4);
    SelectObject(hMemDC, hOldBitmap);
    DeleteDC(hMemDC);

    // Create an empty mask bitmap.
    HBITMAP hMonoBitmap = CreateBitmap(dwWidth,dwHeight,1,1,NULL);

    // Set the alpha values for each pixel in the cursor so that
    // the complete cursor is semi-transparent.
    DWORD *lpdwPixel;
    lpdwPixel = (DWORD *)lpBits;
    for (x=0;x<dwWidth;x++)
       for (y=0;y<dwHeight;y++)
       {
           // Clear the alpha bits
           *lpdwPixel &= 0x00FFFFFF;
           // Set the alpha bits to 0x9F (semi-transparent)
           *lpdwPixel |= 0x9F000000;
           lpdwPixel++;
       }

    ICONINFO ii;
    ii.fIcon = FALSE;  // Change fIcon to TRUE to create an alpha icon
    ii.xHotspot = 0;
    ii.yHotspot = 0;
    ii.hbmMask = hMonoBitmap;
    ii.hbmColor = hBitmap;

    // Create the alpha cursor with the alpha DIB section.
    hAlphaCursor = CreateIconIndirect(&ii);

    DeleteObject(hBitmap);          
    DeleteObject(hMonoBitmap); 

    return hAlphaCursor;
}

Vor dem Schließen müssen Sie die DestroyCursor-Funktion verwenden, um alle Cursor zu zerstören, die Sie mit CreateCursor oder CreateIconIndirect erstellt haben. Es ist nicht erforderlich, Cursor zu zerstören, die von anderen Funktionen erstellt wurden.

Ermitteln der Cursorgröße

Siehe Ermitteln der Symbolgröße.

Anzeigen eines Cursors

Das System zeigt den Klassencursor automatisch an, also den Cursor, der dem Fenster zugeordnet ist, auf das er zeigt. Sie können beim Registrieren einer Fensterklasse einen Klassencursor zuweisen. Das folgende Beispiel veranschaulicht dies durch Zuweisen eines Cursorhandles zum hCursor-Element der WNDCLASS-Struktur , die durch den WC-Parameter identifiziert wird.

WNDCLASS  wc; 
 
// Fill the window class structure with parameters that 
// describe the main window. 
 
wc.style = NULL;                        // class style(s) 
wc.lpfnWndProc = (WNDPROC) MainWndProc; // window procedure 
wc.cbClsExtra = 0;           // no per-class extra data 
wc.cbWndExtra = 0;           // no per-window extra data 
wc.hInstance = hinst;        // application that owns the class 
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);     // class icon 
wc.hCursor = LoadCursor(hinst, MAKEINTRESOURCE(230)); // class cursor 
wc.hbrBackground = GetStockObject(WHITE_BRUSH); // class background 
wc.lpszMenuName =  "GenericMenu";               // class menu 
wc.lpszClassName = "GenericWClass"              // class name 
 
// Register the window class. 
 
return RegisterClass(&wc);

Wenn die Fensterklasse registriert ist, ist der Cursor, der in der Ressourcendefinitionsdatei der Anwendung durch 230 identifiziert wird, der Standardcursor für alle Fenster, die auf der Klasse basieren.

Ihre Anwendung kann den Entwurf des Cursors mithilfe der SetCursor-Funktion ändern und einen anderen Cursorziehpunkt angeben. Wenn sich der Cursor jedoch bewegt, wird der Klassencursor an der neuen Position neu gezeichnet. Um zu verhindern, dass der Klassencursor neu gezeichnet wird, müssen Sie die WM_SETCURSOR Nachricht verarbeiten. Jedes Mal, wenn der Cursor bewegt wird und die Mauseingabe nicht erfasst wird, sendet das System diese Meldung an das Fenster, in dem sich der Cursor bewegt.

Sie können unterschiedliche Cursor für unterschiedliche Bedingungen angeben, während WM_SETCURSOR verarbeitet wird. Das folgende Beispiel zeigt beispielsweise, wie der Cursor immer dann angezeigt wird, wenn der Cursor über das Symbol einer minimierten Anwendung bewegt wird.

case WM_SETCURSOR: 
 
    // If the window is minimized, draw the hCurs3 cursor. 
    // If the window is not minimized, draw the default 
    // cursor (class cursor). 
 
    if (IsIconic(hwnd)) 
    { 
        SetCursor(hCurs3); 
        break; 
    }

Wenn das Fenster nicht minimiert wird, zeigt das System den Klassencursor an.

Sie können einen Klassencursor mithilfe der SetClassLong-Funktion ersetzen. Diese Funktion ändert die Standardfenstereinstellungen für alle Fenster einer angegebenen Klasse. Im folgenden Beispiel wird der vorhandene Klassencursor durch den hCurs2 Cursor ersetzt.

// Change the cursor for window class represented by hwnd. 
 
SetClassLongPtr(hwnd,    // window handle 
    GCLP_HCURSOR,        // change cursor 
    (LONG_PTR) hCurs2);  // new cursor

Weitere Informationen finden Sie unter "Window Classes " und "Mouse Input".

Einschränken eines Cursors

Im folgenden Beispiel wird der Cursor auf das Fenster der Anwendung beschränkt und daraufhin auf das vorherige Fenster zurückgesetzt. Im Beispiel wird die GetClipCursor-Funktion verwendet, um den Bereich aufzuzeichnen, in dem der Cursor verschoben werden kann, und die ClipCursor-Funktion , um den Cursor einzugrenzen und wiederherzustellen.

RECT rcClip;           // new area for ClipCursor
RECT rcOldClip;        // previous area for ClipCursor
 
// Record the area in which the cursor can move. 
 
GetClipCursor(&rcOldClip); 
 
// Get the dimensions of the application's window. 
 
GetWindowRect(hwnd, &rcClip); 
 
// Confine the cursor to the application's window. 
 
ClipCursor(&rcClip); 
 
   // 
   // Process input from the confined cursor. 
   // 
 
// Restore the cursor to its previous area. 
 
ClipCursor(&rcOldClip);

Da im System jeweils nur ein Cursor verfügbar ist, muss eine Anwendung, die den Cursor beschränkt, den Cursor wiederherstellen, bevor das Steuerelement an ein anderes Fenster übergeben wird.

Verwenden von Cursorfunktionen zum Erstellen eines Maustrap

Im folgenden Beispiel werden die Funktionen SetCursorPos, GetCursorPos, CreateCursor, LoadCursor und SetCursor verwendet, um einen einfachen Maustrap zu erstellen. Außerdem werden Cursor- und Zeitgeberfunktionen verwendet, um die Position des Cursors alle 10 Sekunden zu überwachen. Wenn sich die Cursorposition in den letzten 10 Sekunden nicht geändert hat und das Hauptfenster der Anwendung minimiert wird, ändert die Anwendung den Cursor und verschiebt ihn zum Maustrapsymbol.

Ein Beispiel für einen ähnlichen Maustrap ist in Symbolen enthalten. Es verwendet die Funktionen LoadCursor und LoadIcon anstelle der geräteabhängigen CreateCursor - und CreateIcon-Funktionen .

HICON hIcon1;               // icon handles 
POINT ptOld;                // previous cursor location 
HCURSOR hCurs1;             // cursor handle 
 
 
// The following cursor masks are defined in a code 
// example that appears earlier in this section. 
 
// Yin-shaped cursor AND and XOR masks 
 
BYTE ANDmaskCursor[] = ... 
BYTE XORmaskCursor[] = ... 
 
// Yang-shaped icon AND mask (32x32x1bpp)
BYTE ANDmaskIcon[] =
{
    0xFF, 0xFF, 0xFF, 0xFF,   // ################################
    0xFF, 0xFF, 0xC3, 0xFF,   // ##################----##########
    0xFF, 0xFF, 0x00, 0xFF,   // ################--------########
    0xFF, 0xFE, 0x00, 0x7F,   // ###############----------#######
    0xFF, 0xFC, 0x00, 0x1F,   // ##############-------------#####
    0xFF, 0xF8, 0x00, 0x0F,   // #############---------------####
    0xFF, 0xF8, 0x00, 0x0F,   // #############---------------####
    0xFF, 0xF0, 0x00, 0x07,   // ############-----------------###
    0xFF, 0xF0, 0x00, 0x03,   // ############------------------##
    0xFF, 0xE0, 0x00, 0x03,   // ###########-------------------##
    0xFF, 0xE0, 0x00, 0x01,   // ###########--------------------#
    0xFF, 0xE0, 0x00, 0x01,   // ###########--------------------#
    0xFF, 0xF0, 0x00, 0x01,   // ############-------------------#
    0xFF, 0xF0, 0x00, 0x00,   // ############--------------------
    0xFF, 0xF8, 0x00, 0x00,   // #############-------------------
    0xFF, 0xFC, 0x00, 0x00,   // ##############------------------
    0xFF, 0xFF, 0x00, 0x00,   // ################----------------
    0xFF, 0xFF, 0x80, 0x00,   // #################---------------
    0xFF, 0xFF, 0xE0, 0x00,   // ###################-------------
    0xFF, 0xFF, 0xE0, 0x01,   // ###################------------#
    0xFF, 0xFF, 0xF0, 0x01,   // ####################-----------#
    0xFF, 0xFF, 0xF0, 0x01,   // ####################-----------#
    0xFF, 0xFF, 0xF0, 0x03,   // ####################----------##
    0xFF, 0xFF, 0xE0, 0x03,   // ###################-----------##
    0xFF, 0xFF, 0xE0, 0x07,   // ###################----------###
    0xFF, 0xFF, 0xC0, 0x0F,   // ##################----------####
    0xFF, 0xFF, 0xC0, 0x0F,   // ##################----------####
    0xFF, 0xFF, 0x80, 0x1F,   // #################----------#####
    0xFF, 0xFF, 0x00, 0x7F,   // ################---------#######
    0xFF, 0xFC, 0x00, 0xFF,   // ##############----------########
    0xFF, 0xF8, 0x03, 0xFF,   // #############---------##########
    0xFF, 0xFC, 0x3F, 0xFF    // ##############----##############
};
 
// Yang-shaped icon XOR mask (32x32x1bpp)
BYTE XORmaskIcon[] =
{
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x38, 0x00,   // ------------------###-----------
    0x00, 0x00, 0x7C, 0x00,   // -----------------#####----------
    0x00, 0x00, 0x7C, 0x00,   // -----------------#####----------
    0x00, 0x00, 0x7C, 0x00,   // -----------------#####----------
    0x00, 0x00, 0x38, 0x00,   // ------------------###-----------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00,   // --------------------------------
    0x00, 0x00, 0x00, 0x00    // --------------------------------
};

hIcon1 = CreateIcon(hinst, // handle to app. instance 
             32,           // icon width 
             32,           // icon height 
             1,            // number of XOR planes 
             1,            // number of bits per pixel 
             ANDmaskIcon,  // AND mask 
             XORmaskIcon); // XOR mask 
 
hCurs1 = CreateCursor(hinst, // handle to app. instance
             19,             // horizontal position of hot spot 
             2,              // vertical position of hot spot 
             32,             // cursor width 
             32,             // cursor height 
             ANDmaskCursor,  // AND mask 
             XORmaskCursor); // XOR mask 
 
// Fill in the window class structure. 
 
WNDCLASS  wc; 
 
wc.hIcon = hIcon1;                        // class icon 
wc.hCursor = LoadCursor(NULL, IDC_ARROW); // class cursor 
 
//
// Register the window class and perform 
// other application initialization. 
//
 
// Set a timer for the mousetrap. 
 
GetCursorPos(&ptOld); 
 
SetTimer(hwnd, IDT_CURSOR, 10000, (TIMERPROC) NULL); 
 
LONG APIENTRY MainWndProc( 
    HWND hwnd,          // window handle 
    UINT message,       // type of message 
    UINT wParam,        // additional information 
    LONG lParam)        // additional information 
{ 
 
    HDC hdc;            // handle to device context 
    POINT pt;           // current cursor location 
    RECT rc;            // minimized window location 
 
    switch (message) 
    { 
        //
        // Process other messages. 
        // 
        case WM_TIMER: 
        // If the window is minimized, compare the 
        // current cursor position with the one 10 
        // seconds before. If the cursor position has 
        // not changed, move the cursor to the icon. 
 
            if (IsIconic(hwnd)) 
            { 
                GetCursorPos(&pt); 
 
                if ((pt.x == ptOld.x) && (pt.y == ptOld.y)) 
                { 
                    GetWindowRect(hwnd, &rc); 
                    SetCursorPos(rc.left + 20, rc.top + 4); 
 
                    // Note that the additional constants 
                    // (20 and 4) are application-specific 
                    // values to align the yin-shaped cursor 
                    // and the yang-shaped icon. 
 
                } 
                else 
                { 
                    ptOld.x = pt.x; 
                    ptOld.y = pt.y; 
                } 
            } 
 
            return 0; 
 
        case WM_SETCURSOR: 
        // If the window is minimized, draw hCurs1. 
        // If the window is not minimized, draw the 
        // default cursor (class cursor). 
 
            if (IsIconic(hwnd)) 
            { 
                SetCursor(hCurs1); 
                break; 
            } 
 
        case WM_DESTROY: 
        // Destroy timer. 
 
            KillTimer(hwnd, IDT_CURSOR); 
 
            PostQuitMessage(0); 
            break; 
    } 
}

Verwenden der Tastatur zum Verschieben des Cursors

Da das System keine Maus erfordert, sollte eine Anwendung Mausaktionen mit der Tastatur simulieren können. Das folgende Beispiel zeigt, wie Sie dies mithilfe der Funktionen "GetCursorPos " und "SetCursorPos " erreichen und Eingaben aus den Pfeiltasten verarbeiten.

HCURSOR hCurs1, hCurs2;    // cursor handles 
 
POINT pt;                  // cursor location  
RECT rc;                   // client area coordinates 
static int repeat = 1;     // repeat key counter 
 
// 
// Other declarations and initialization. 
// 
 
switch (message) 
{ 
// 
// Process other messages. 
// 
 
    case WM_KEYDOWN: 
 
        if (wParam != VK_LEFT && wParam != VK_RIGHT && 
        wParam != VK_UP && wParam != VK_DOWN) 
        { 
            break; 
        } 
 
        GetCursorPos(&pt); 
 
        // Convert screen coordinates to client coordinates. 
 
        ScreenToClient(hwnd, &pt); 
 
        switch (wParam) 
        { 
        // Move the cursor to reflect which 
        // arrow keys are pressed. 
 
            case VK_LEFT:               // left arrow 
                pt.x -= repeat; 
                break; 
 
            case VK_RIGHT:              // right arrow 
                pt.x += repeat; 
                break; 
 
            case VK_UP:                 // up arrow 
                pt.y -= repeat; 
                break; 
 
            case VK_DOWN:               // down arrow 
                pt.y += repeat; 
                break; 
 
            default: 
                return 0; 
        } 
 
        repeat++;           // Increment repeat count. 
 
        // Keep the cursor in the client area. 
 
        GetClientRect(hwnd, &rc); 
 
        if (pt.x >= rc.right) 
        { 
            pt.x = rc.right - 1; 
        } 
        else 
        { 
            if (pt.x < rc.left) 
            { 
                pt.x = rc.left; 
            } 
        } 
 
        if (pt.y >= rc.bottom) 
            pt.y = rc.bottom - 1; 
        else 
            if (pt.y < rc.top) 
                pt.y = rc.top; 
 
        // Convert client coordinates to screen coordinates. 
 
        ClientToScreen(hwnd, &pt); 
        SetCursorPos(pt.x, pt.y); 
        return 0; 

 
    case WM_KEYUP: 
 
        repeat = 1;            // Clear repeat count. 
        return 0; 
 
}

 

 

  • Last updated on