Udostępnij przez

Korzystanie z kursorów

W tej sekcji omówiono następujące tematy.

Tworzenie kursora

Poniższy przykład tworzy dwa uchwyty kursora: jeden dla standardowego kursora klepsydry i jeden dla kursora niestandardowego dołączonego jako zasób w pliku definicji zasobów aplikacji.

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));

Aplikacje powinny implementować niestandardowe kursory jako zasoby i używać LoadCursor, LoadCursorFromFilelub LoadImage zamiast tworzyć kursor w czasie wykonywania. Korzystanie z zasobów kursora pozwala uniknąć zależności urządzenia, upraszcza lokalizację i umożliwia aplikacjom udostępnianie projektów kursorów.

W poniższym przykładzie użyto funkcji CreateCursor, aby utworzyć niestandardowy kursor monochromatyczny w czasie wykonywania. W tym przykładzie pokazano, jak system interpretuje maski kursorów.

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

Aby utworzyć kursor, CreateCursor stosuje następującą tabelę prawdy do maski AND i maski XOR.

MASKA I Maska XOR Wyświetlacz
0 0 Czarny
0 1 Biały
1 0 Ekran
1 1 Odwrócony ekran

Aby uzyskać więcej informacji, zobacz Mapy bitowe.

Tworzenie kursora z kanałem alfa

Wykonaj następujące kroki, aby utworzyć kursor lub ikonę z blendowaniem alfa w czasie wykonywania:

  • Wykonaj strukturę BITMAPV5HEADER, tak jak w przykładzie kodu, wykonując poniższe kroki, aby zdefiniować 32 bity na piksel (BPP) w połączeniu DIB.
  • Wywołaj funkcję CreateDIBSection, aby utworzyć sekcję DIB na podstawie ukończonej struktury BITMAPV5HEADER.
  • Użyj mapy bitowej i informacji alfa, które mają być używane dla kursora lub ikony mieszanej alfa, aby ukończyć sekcję DIB.
  • Ukończ strukturę ICONINFO.
  • Umieść pustą monochromatyczną mapę bitową w polu hbmMask, a następnie umieść sekcję DIB z zastosowanym alpha blendingiem w polu hbmColor.
  • Wywołaj funkcję CreateIconIndirect, aby utworzyć kursor lub ikonę z efektem blendingu alfa.

Poniższy kod pokazuje, jak utworzyć kursor mieszany alfa. Możesz użyć tego samego kodu, aby utworzyć ikonę alfa zblendowaną, zmieniając element fIcon struktury ICONINFO na TRUE.

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;
}

Przed zamknięciem należy użyć funkcji DestroyCursor, aby zniszczyć wszystkie kursory utworzone za pomocą CreateCursor lub CreateIconIndirect. Nie jest konieczne zniszczenie kursorów utworzonych przez inne funkcje.

Pobieranie rozmiaru kursora

Zobacz Sprawdzenie rozmiaru ikony.

Wyświetlanie kursora

System automatycznie wyświetla kursor klasy (kursor skojarzony z oknem, do którego wskazuje kursor). Kursor klasy można przypisać podczas rejestrowania klasy okna. Poniższy przykład ilustruje to przez przypisanie uchwytu kursora do hCursor członka WNDCLASS struktury zidentyfikowanej przez parametr wc.

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);

Po zarejestrowaniu klasy okna kursor zidentyfikowany przez 230 w pliku definicji zasobów aplikacji jest domyślnym kursorem dla wszystkich okien opartych na klasie.

Aplikacja może zmienić projekt kursora przy użyciu funkcji SetCursor i określania innego uchwytu kursora. Jednak po przesunięciu kursora system ponownie rysuje kursor klasy w nowym miejscu. Aby zapobiec ponownemu rysowaniu kursora klasy, należy przetworzyć komunikat WM_SETCURSOR. Za każdym razem, gdy kursor porusza się, a dane wejściowe myszy nie są przechwytywane, system wysyła ten komunikat do okna, w którym przesuwa się kursor.

Podczas przetwarzania WM_SETCURSORmożna określić różne kursory dla różnych warunków. Na przykład w poniższym przykładzie pokazano, jak wyświetlić kursor za każdym razem, gdy kursor przesuwa się na ikonę zminimalizowanej aplikacji.

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; 
    }

Gdy okno nie zostanie zminimalizowane, system wyświetli kursor klasy.

Kursor klasy można zastąpić za pomocą funkcji SetClassLong. Ta funkcja zmienia domyślne ustawienia okna dla wszystkich okien określonej klasy. Poniższy przykład zastępuje istniejący kursor klasy kursorem hCurs2.

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

Aby uzyskać więcej informacji, zobacz Klasy okien oraz Dane wejściowe myszy.

Ograniczenie kursora

Poniższy przykład ogranicza kursor do okna aplikacji, a następnie przywraca kursor do poprzedniego okna. W przykładzie użyto funkcji GetClipCursor, aby zarejestrować obszar, w którym kursor może się poruszać, a funkcja ClipCursor, aby ograniczyć i przywrócić kursor.

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);

Ponieważ w systemie jest dostępny tylko jeden kursor, aplikacja, która ogranicza kursor, musi przywrócić kursor przed ponownym zrezygnowaniem z kontrolki do innego okna.

Tworzenie pułapki na myszy za pomocą funkcji kursora

W poniższym przykładzie użyto SetCursorPos, GetCursorPos, CreateCursor, LoadCursori funkcji SetCursor, aby utworzyć prostą pułapkę myszy. Używa również funkcji kursora i czasomierza do monitorowania położenia kursora co 10 sekund. Jeśli pozycja kursora nie zmieniła się w ciągu ostatnich 10 sekund, a główne okno aplikacji zostanie zminimalizowane, aplikacja zmieni kursor i przeniesie go do ikony myszy.

Przykład podobnej pułapki myszy znajduje się w Icon. Używa ona funkcji LoadCursor i LoadIcon zamiast bardziej zależnych od urządzenia funkcji CreateCursor i CreateIcon.

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; 
    } 
}

Przenoszenie kursora za pomocą klawiatury

Ponieważ system nie wymaga myszy, aplikacja powinna być w stanie symulować akcje myszy za pomocą klawiatury. W poniższym przykładzie pokazano, jak to osiągnąć przy użyciu GetCursorPos i funkcji SetCursorPos oraz przetwarzania danych wejściowych z strzałek.

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