Esempio di manipolazione tocco di Windows (MTManipulation)
Questa sezione descrive l'esempio di manipolazione tocco di Windows.
L'esempio windows Touch Manipulation illustra come tradurre, ruotare e ridimensionare un oggetto usando l'interfaccia IManipulationProcessor e implementando un sink di eventi _IManipulationEvents . La schermata seguente mostra l'aspetto dell'esempio durante l'esecuzione.
Per questo esempio viene creata una classe CDrawingObject che può essere convertita, ruotata o ridimensionata a livello di codice. Viene creata un'istanza di un'interfaccia IManipulationProcessor . Viene creato un sink di eventi di manipolazione che accetta un puntatore alla classe CDrawingObject e all'interfaccia IManipulationProcessor nel relativo costruttore. Un punto di connessione a IManipulationProcessor viene creato nell'implementazione del sink dell'evento di manipolazione in modo che gli eventi generati dal IManipulationProcessor vengano ricevuti dal sink dell'evento. I dati di tocco vengono inseriti nell'interfaccia IManipulationProcessor e l'interfaccia genererà quindi _IManipulationEvent eventi. I gestori eventi nella classe CManipulationEventSink aggiorneranno l'orientamento di CDrawingObject chiamando le funzioni di accesso sul puntatore a CDrawingObject.
Il codice seguente mostra come viene configurata la finestra per il tocco e come viene creata un'istanza di CDrawingObject e IManipulationProcessor e passata al costruttore CManipulationEventSink .
CDrawingObject g_cRect; // CDrawingObject class holds information about the rectangle
// and it is responsible for painting the rectangle.
(...)
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
(...)
// Register application window for receiving multi-touch input. Use default settings.
if (!RegisterTouchWindow(hWnd, 0))
{
MessageBox(hWnd, L"Cannot register application window for multi-touch input", L"Error", MB_OK);
return FALSE;
}
ASSERT(IsTouchWindow(hWnd, NULL));
// Instantiate the ManipulationProcessor object
HRESULT hr = CoCreateInstance(__uuidof(ManipulationProcessor), NULL, CLSCTX_ALL, IID_PPV_ARGS(&g_pIManipProc));
if (FAILED(hr))
{
ASSERT(SUCCEEDED(hr) && L"InitInstance: failed to instantiate the ManipulationProcessor object");
return FALSE;
}
// Instantiate the event sink with the manipulation processor and pointer to the rectangle object
g_pManipulationEventSink = new CManipulationEventSink(&g_cRect);
if (g_pManipulationEventSink == NULL)
{
ASSERT(g_pManipulationEventSink && L"InitInstance: failed to instantiate the CManipulationEventSink class");
g_pIManipProc->Release();
g_pIManipProc = NULL;
return FALSE;
}
// Establish the link between ManipulationEventSink and ManipulationProcessor
if (!g_pManipulationEventSink->Connect(g_pIManipProc))
{
ASSERT(FALSE && L"InitInstance: failed to connect ManipulationEventSink and ManipulationProcessor");
g_pIManipProc->Release();
g_pIManipProc = NULL;
g_pManipulationEventSink->Release();
g_pManipulationEventSink = NULL;
return FALSE;
}
Il codice seguente mostra il costruttore per il sink dell'evento di manipolazione , CManipulationEventSink.
CManipulationEventSink::CManipulationEventSink(CDrawingObject* pcDrawingObject)
: m_cRefCount(1),
m_pConnection(NULL),
m_dwCookie(0),
m_pcDrawingObject(pcDrawingObject)
{
ASSERT((pcDrawingObject != NULL) && L"CManipulationEventSink constructor: incorrect argument");
}
Il codice seguente mostra come il sink di eventi è connesso al processore di manipolazione.
bool CManipulationEventSink::Connect(IManipulationProcessor* pManipulationProcessor)
{
// Check input arguments
if (pManipulationProcessor == NULL)
{
ASSERT((pManipulationProcessor != NULL) && L"CManipulationEventSink::Create : incorrect arguments");
return false;
}
// Check object state
if ((m_dwCookie != 0) || (m_pConnection != NULL))
{
ASSERT((m_dwCookie == 0) && (m_pConnection == NULL) && L"CManipulationEventSink::Connect : connection already established");
return false;
}
// Get the container with the connection points.
IConnectionPointContainer* pConnectionContainer = NULL;
HRESULT hr = pManipulationProcessor->QueryInterface(&pConnectionContainer);
if (FAILED(hr))
{
ASSERT(SUCCEEDED(hr) && L"CManipulationEventSink::Connect : failed to get the container with the connection points");
return false;
}
// Get a connection point.
hr = pConnectionContainer->FindConnectionPoint(__uuidof(_IManipulationEvents), &m_pConnection);
if (FAILED(hr))
{
ASSERT(SUCCEEDED(hr) && L"CManipulationEventSink::Connect : failed to get a connection point");
pConnectionContainer->Release();
return false;
}
// Release the connection container.
pConnectionContainer->Release();
// Advise. Establishes an advisory connection between the connection point and the
// caller's sink object.
hr = m_pConnection->Advise(this, &m_dwCookie);
if (FAILED(hr))
{
ASSERT(SUCCEEDED(hr) && L"CManipulationEventSink::Connect : failed to Advise");
m_pConnection->Release();
m_pConnection = NULL;
return false;
}
return true;
}
Il codice seguente mostra come i dati tocco vengono passati al sink dell'evento di manipolazione.
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
(...)
switch (message)
{
(...)
// WM_TOUCH message handlers
case WM_TOUCH:
{
// WM_TOUCH message can contain several messages from different contacts
// packed together.
// Message parameters need to be decoded:
UINT cInputs = (int) wParam; // Number of actual per-contact messages
TOUCHINPUT* pInputs = new TOUCHINPUT[cInputs]; // Allocate the storage for the parameters of the per-contact messages
if (pInputs == NULL)
{
break;
}
// Unpack message parameters into the array of TOUCHINPUT structures, each
// representing a message for one single contact.
if (GetTouchInputInfo((HTOUCHINPUT)lParam, cInputs, pInputs, sizeof(TOUCHINPUT)))
{
// For each contact, dispatch the message to the appropriate message
// handler.
for (unsigned int i = 0; i < cInputs; i++)
{
if (pInputs[i].dwFlags & TOUCHEVENTF_DOWN)
{
g_pIManipProc->ProcessDown(pInputs[i].dwID, (FLOAT)pInputs[i].x, (FLOAT)pInputs[i].y);
}
else if (pInputs[i].dwFlags & TOUCHEVENTF_MOVE)
{
g_pIManipProc->ProcessMove(pInputs[i].dwID, (FLOAT)pInputs[i].x, (FLOAT)pInputs[i].y);
}
else if (pInputs[i].dwFlags & TOUCHEVENTF_UP)
{
g_pIManipProc->ProcessUp(pInputs[i].dwID, (FLOAT)pInputs[i].x, (FLOAT)pInputs[i].y);
}
}
}
else
{
// error handling, presumably out of memory
ASSERT(FALSE && L"Error: failed to execute GetTouchInputInfo");
delete [] pInputs;
break;
}
if (!CloseTouchInputHandle((HTOUCHINPUT)lParam))
{
// error handling, presumably out of memory
ASSERT(FALSE && L"Error: failed to execute CloseTouchInputHandle");
delete [] pInputs;
break;
}
delete [] pInputs;
// Force redraw of the rectangle
InvalidateRect(hWnd, NULL, TRUE);
}
break;
Nel codice seguente viene illustrato come i gestori eventi aggiornano l'orientamento e le dimensioni dell'oggetto sugli eventi delta di manipolazione.
HRESULT STDMETHODCALLTYPE CManipulationEventSink::ManipulationDelta(
/* [in] */ FLOAT /* x */,
/* [in] */ FLOAT /* y */,
/* [in] */ FLOAT translationDeltaX,
/* [in] */ FLOAT translationDeltaY,
/* [in] */ FLOAT scaleDelta,
/* [in] */ FLOAT /* expansionDelta */,
/* [in] */ FLOAT rotationDelta,
/* [in] */ FLOAT /* cumulativeTranslationX */,
/* [in] */ FLOAT /* cumulativeTranslationY */,
/* [in] */ FLOAT /* cumulativeScale */,
/* [in] */ FLOAT /* cumulativeExpansion */,
/* [in] */ FLOAT /* cumulativeRotation */)
{
m_pcDrawingObject->ApplyManipulationDelta(translationDeltaX,translationDeltaY,scaleDelta,rotationDelta);
return S_OK;
}
Il codice seguente è l'implementazione di ApplyManipulationDelta nella classe CDrawingObject .
// This function is responsible for manipulation of the rectangle.
// It is called from CManipulationEventSink class.
// in:
// translationDeltaX - shift of the x-coordinate (1/100 of pixel units)
// translationDeltaY - shift of the y-coordinate (1/100 of pixel units)
// scaleDelta - scale factor (zoom in/out)
// rotationDelta - rotation angle in radians
void CDrawingObject::ApplyManipulationDelta(
const FLOAT translationDeltaX,
const FLOAT translationDeltaY,
const FLOAT scaleDelta,
const FLOAT rotationDelta
)
{
_ptCenter.x += (LONG) (translationDeltaX / 100.0);
_ptCenter.y += (LONG) (translationDeltaY / 100.0);
_dScalingFactor *= scaleDelta;
_dRotationAngle -= rotationDelta; // we are subtracting because Y-axis is down
}
Dopo l'aggiornamento dei punti centrale, del fattore di scala e dell'angolo di rotazione di CDrawingObject, l'oggetto si trasformerà.
Argomenti correlati
Esempio di manipolazione multitocco, manipolazione e inerzia, esempi di tocco di Windows