Detekce a sledování několika dotykových bodů

Následující kroky vysvětlují, jak sledovat více dotykových bodů pomocí windows Touch.

1. Vytvořte aplikaci a povolte windows Touch.
2. Přidání obslužné rutiny pro WM_TOUCH a sledování bodů
3. Nakreslete body.

Po spuštění aplikace se vykreslí kruhy pod každým dotykem. Následující snímek obrazovky ukazuje, jak může vaše aplikace vypadat při spuštění.

Vytvoření aplikace a povolení dotykového ovládání Windows

Začněte s aplikací Microsoft Win32 pomocí průvodce Microsoft Visual Studio. Po dokončení průvodce přidejte podporu pro zprávy Windows Touch nastavením verze Windows v targetver.h a včetně windows.h a windowsx.h ve vaší aplikaci. Následující kód ukazuje, jak nastavit verzi Systému Windows v targetver.h.

#ifndef WINVER                  // Specifies that the minimum required platform is Windows 7.
#define WINVER 0x0601           // Change this to the appropriate value to target other versions of Windows.
#endif

#ifndef _WIN32_WINNT            // Specifies that the minimum required platform is Windows 7.
#define _WIN32_WINNT 0x0601     // Change this to the appropriate value to target other versions of Windows.
#endif     

#ifndef _WIN32_WINDOWS          // Specifies that the minimum required platform is Windows 98.
#define _WIN32_WINDOWS 0x0410 // Change this to the appropriate value to target Windows Me or later.
#endif

#ifndef _WIN32_IE                       // Specifies that the minimum required platform is Internet Explorer 7.0.
#define _WIN32_IE 0x0700        // Change this to the appropriate value to target other versions of IE.
#endif

Následující kód ukazuje, jak se mají přidat direktivy include. Můžete také vytvořit některé globální proměnné, které budou použity později.

#include <windows.h>    // included for Windows Touch
#include <windowsx.h>   // included for point conversion

#define MAXPOINTS 10

// You will use this array to track touch points
int points[MAXPOINTS][2];

// You will use this array to switch the color / track ids
int idLookup[MAXPOINTS];


// You can make the touch points larger
// by changing this radius value
static int radius      = 50;

// There should be at least as many colors
// as there can be touch points so that you
// can have different colors for each point
COLORREF colors[] = { RGB(153,255,51), 
                      RGB(153,0,0), 
                      RGB(0,153,0), 
                      RGB(255,255,0), 
                      RGB(255,51,204), 
                      RGB(0,0,0),
                      RGB(0,153,0), 
                      RGB(153, 255, 255), 
                      RGB(153,153,255), 
                      RGB(0,51,153)
                    };

Přidejte obslužnou rutinu pro WM_TOUCH a sledování bodů.

Nejprve deklarujte některé proměnné používané obslužnou rutinou WM_TOUCH v WndProc.

int wmId, wmEvent, i, x, y;

UINT cInputs;
PTOUCHINPUT pInputs;
POINT ptInput;   

Nyní inicializujte proměnné použité pro ukládání dotykových bodů a zaregistrujte okno pro dotykové vstupy z metody InitInstance.

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;

   hInst = hInstance; // Store instance handle in our global variable

   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);

   if (!hWnd) {
      return FALSE;
   }

   // register the window for touch instead of gestures
   RegisterTouchWindow(hWnd, 0);  

   // the following code initializes the points
   for (int i=0; i< MAXPOINTS; i++){
     points[i][0] = -1;
     points[i][1] = -1;
     idLookup[i]  = -1;
   }  

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

   return TRUE;
}

Dále zpracujte zprávu WM_TOUCH z metody WndProc. Následující kód ukazuje implementaci obslužné rutiny pro WM_TOUCH.

case WM_TOUCH:        
  cInputs = LOWORD(wParam);
  pInputs = new TOUCHINPUT[cInputs];
  if (pInputs){
    if (GetTouchInputInfo((HTOUCHINPUT)lParam, cInputs, pInputs, sizeof(TOUCHINPUT))){
      for (int i=0; i < static_cast<INT>(cInputs); i++){
        TOUCHINPUT ti = pInputs[i];
        index = GetContactIndex(ti.dwID);
        if (ti.dwID != 0 && index < MAXPOINTS){                            
          // Do something with your touch input handle
          ptInput.x = TOUCH_COORD_TO_PIXEL(ti.x);
          ptInput.y = TOUCH_COORD_TO_PIXEL(ti.y);
          ScreenToClient(hWnd, &ptInput);
          
          if (ti.dwFlags & TOUCHEVENTF_UP){                      
            points[index][0] = -1;
            points[index][1] = -1;

            // Remove the old contact index to make it available for the new incremented dwID.
            // On some touch devices, the dwID value is continuously incremented.
            RemoveContactIndex(index);                
          }else{
            points[index][0] = ptInput.x;
            points[index][1] = ptInput.y;                
          }
        }
      }

      InvalidateRect(hWnd, NULL, FALSE);
    }
    // If you handled the message and don't want anything else done with it, you can close it
    CloseTouchInputHandle((HTOUCHINPUT)lParam);
    delete [] pInputs;
  }else{
    // Handle the error here 
  }  

Poznámka

Pokud chcete použít funkci ScreenToClient, musíte mít ve své aplikaci podporu vysokého DPI. Další informace o podpoře vysokého DPI naleznete v tématu Vysoký DPI.

Když se uživatel dotkne obrazovky, pozice, na které se dotkne, budou uloženy v poli bodů. dwID člen struktury TOUCHINPUT ukládá identifikátor, který bude závislý na hardwaru.

K řešení problému, že člen dwID závisí na hardwaru, používá obslužná rutina případu WM_TOUCH funkci GetContactIndex, která mapuje člena dwID struktury TOUCHINPUT na bod, který je vykreslen na obrazovce. Následující kód ukazuje implementaci této funkce.

// This function is used to return an index given an ID
int GetContactIndex(int dwID){
  for (int i = 0; i < MAXPOINTS; i++) {
      if (idLookup[i] == dwID) {
          return i;
      }
  }

  for (int i = 0; i < MAXPOINTS; i++) {
      if (idLookup[i] == -1) {
          idLookup[i] = dwID;
          return i;
      }
  }
  // Out of contacts
  return -1;
}

// Mark the specified index as initialized for new use
BOOL RemoveContactIndex(int index) {
    if (index >= 0 && index < MAXPOINTS) {
        idLookup[index] = -1;
        return true;
    }

    return false;
}

Důležitý

Windows 11 a novější

Některé interakce se třemi a čtyřmi prsty přestanou ve výchozím nastavení fungovat v aplikacích pro Windows.

Ve výchozím nastavení systém využívá interakce se třemi a čtyřmi prsty pro operace, jako je přepínání nebo minimalizace oken a změna virtuálních ploch. Vzhledem k tomu, že tyto interakce se teď zpracovávají na úrovni systému, může tato změna ovlivnit funkčnost vaší aplikace.

Pro podporu interakcí se třemi nebo čtyřmi prsty v rámci aplikace se zavedlo nové uživatelské nastavení, které určuje, jestli systém tyto interakce zpracovává nebo ne:

zařízení bluetooth & > touch > "tří a čtyř prstových dotykových gest"

Když je nastavená možnost Zapnuto (výchozí), systém bude zpracovávat všechny interakce se třemi a čtyřmi prsty (aplikace je nebudou moct podporovat).

Když je tato možnost nastavená na Vypnuto, můžou aplikace podporovat interakce se třemi a čtyřmi prsty (systém je nezpracuje).

Pokud vaše aplikace musí tyto interakce podporovat, doporučujeme informovat uživatele o tomto nastavení a poskytnout odkaz, který spustí aplikaci Nastavení na příslušnou stránku (ms-settings:devices-touch). Další podrobnosti najdete v tématu Launcher.LaunchUriAsync metoda.

Nakreslení bodů

Deklarujte následující proměnné pro rutinu výkresu.

    // For double buffering
    static HDC memDC       = 0;
    static HBITMAP hMemBmp = 0;
    HBITMAP hOldBmp        = 0;
   
    // For drawing / fills
    PAINTSTRUCT ps;
    HDC hdc;
    HBRUSH hBrush;
    
    // For tracking dwId to points
    int index;

Kontext zobrazení paměti memDC slouží k ukládání dočasného grafického kontextu, který se vymění s vykreslovaným kontextem zobrazení, hdc, aby se odstranilo blikání. Implementujte kreslicí rutinu, která zpracuje body, které jste uložili, a nakreslí kruh v těchto bodech. Následující kód ukazuje, jak byste mohli implementovat obslužnou rutinu WM_PAINT.

  case WM_PAINT:
    hdc = BeginPaint(hWnd, &ps);    
    RECT client;
    GetClientRect(hWnd, &client);        
  
    // start double buffering
    if (!memDC){
      memDC = CreateCompatibleDC(hdc);
    }
    hMemBmp = CreateCompatibleBitmap(hdc, client.right, client.bottom);
    hOldBmp = (HBITMAP)SelectObject(memDC, hMemBmp);          

    hBrush = CreateSolidBrush(RGB(255, 255, 255));
    FillRect(memDC, &client, hBrush);
    DeleteObject(hBrush);

    //Draw Touched Points                
    for (i=0; i < MAXPOINTS; i++){
      hBrush = CreateSolidBrush(colors[i]);        
      SelectObject( memDC, hBrush);           

      x = points[i][0];
      y = points[i][1];
      if  (x >0 && y>0){              
        Ellipse(memDC, x - radius, y - radius, x+ radius, y + radius);
      }

      DeleteObject(hBrush);
    }
  
    BitBlt(hdc, 0,0, client.right, client.bottom, memDC, 0,0, SRCCOPY);      
    EndPaint(hWnd, &ps);

    SelectObject(memDC, hOldBmp);
    DeleteObject(hMemBmp);

    break;

Když spustíte aplikaci, měla by teď vypadat podobně jako na obrázku na začátku této části.

Pro zábavu můžete kolem dotykových bodů kreslit další čáry. Následující snímek obrazovky ukazuje, jak by aplikace mohla vypadat s několika nadbytečnými čárami nakreslenými kolem kruhů.

Související témata

Windows dotykové vstupy