MSDN Magazin > Home > Ausgaben > 2008 > Oktober >  Unterwegs: Freihandaktivierte Anwendungen für T...
Unterwegs
Freihandaktivierte Anwendungen für Tablet PC
Gus Class
Aus einer grundlegenden Perspektive ist der Prozess für die Erfassung von Freihandeingaben und die Analyse auf dem Tablet PC einfach. In verwaltetem Code, wo die Objekterstellung und der Zugriff konsistent und einfach sind, ist es einfach, verwaltete Anwendungen für Tablet PC zu entwickeln. Für erfahrene Windows-Entwickler wird es nicht sehr viel schwieriger sein, solche Anwendungen in nicht verwaltetem Code zu entwickeln. Für den unerfahrenen Entwickler kann das Erstellen von nicht verwalteten Tablet PC-Anwendungen ziemlich schwierig sein.
Die Verarbeitung von Stifteingaben und ihre Transformation in lesbare Daten ist eine häufig vorkommende und möglicherweise anstrengende Aufgabe für Entwickler. Im Fall von Tablet PC ist dieser Prozess vereinfacht, weil wir das Stiftberechnungssystem mit einer abstrahierten Architektur entworfen haben, um Ihren Entwurfsaufwand zu verringern.
In diesem Artikel erhalten Sie eine kurze Einführung in die Tablet PC-Freihandarchitektur. Außerdem wird veranschaulicht, wie Sie Freihandeingaben in Tablet PC-Anwendungen erfassen und erkennen. In einem Beispielcode wird dargestellt, wie Sie das Tablet PC SDK verwenden, damit eine Handschrift als Text erkannt wird, und es wird eine einfache stiftbasierte Illustrationseingabe erstellt.

Tablet PC: Erstellung und Erkennung
In der Tablet PC-Welt wird die Stifteingabe am PC als „Freihand“ (ink) bezeichnet. Freihand ist eine nützliche Art von Eingabedaten, da es problemlos in andere Datentypen (Zahlen, Text und Zeichen) transformiert werden oder als Freihandeingabe belassen werden kann, wenn es besser ist, die Art der Eingabe nicht zu ändern. Schnell hingekritzelte Notizen vermischt mit Diagrammen sind ein solches Beispiel, bei dem es logisch ist, die Eingabe als Freihand zu speichern.
Freihandeingabe besteht aus Paketen, die alle Arten von Informationen enthalten, z. B. die X-Position, Y-Position und den Zustand des Stifts. Freihandeingabe enthält außerdem Strichsammlungen, die Attribute wie Breite, Farbe und Transparenzwerte besitzen. Abbildung 1 zeigt den allgemeinen Entwurf der Stifteingabedaten (Freihand) für Tablet PCs.
Abbildung 1 Freihanddatenkomponenten (zum Vergrößern auf das Bild klicken)
Das Lesen von Strichdaten ist so wie das Lesen jedes anderen Eingabedatenstroms. Die Striche werden von Betriebssystemhooks erfasst und können dann gerendert oder erkannt werden. Microsoft hat Schnittstellen, Klassen und verwaltete Objekte für das Repräsentieren, Rendern und Erkennen der oben genannten Datentypen implementiert. Diese Objekte wurden ursprünglich an Entwickler im Tablet PC SDK in Windows XP verteilt und sind jetzt Teil des Windows Vista SDK.
Freihanderkennung – der Prozess der Transformation von Stifteingabe in Text – ist in das Tablet PC SDK integriert und wird dadurch erzielt, dass die Freihandeingabe aufgezeichnet und an ein Objekt übergeben wird, das diese Freihandeingabe erkennen kann. Freihandeingabe wird mittels InkCollector oder mithilfe eines abgeleiteten Objekts, wie z. B. InkOverlay, erfasst. Nachdem InkCollector oder InkOverlay Pakete erfasst haben, die in Striche umgeformt werden, können die Striche abgerufen werden. Durch die Übergabe der Striche an eine Erkennung und das Aufrufen einer Methode, mit der die erfassten Striche analysiert werden, können die Freihanddaten in einen erkennbaren Inhalt übersetzt werden. Abbildung 2 zeigt den Freihanderkennungsprozess.
\\msdnmagtst\MTPS\MSDN\issues\en\08\10\Class - GoingPlaces.1008\figures\fig02.gif
Weitere Informationen zur Freihanderkennung finden Sie im Tablet PC SDK (verfügbar unter msdn.microsoft.com/library/ms812486). Eine andere hervorragende Ressource für die Tablet PC-Entwicklung ist das Mobile PC-Entwicklercenter (msdn.microsoft.com/mobilepc).

InkEdit und InkPicture
Die einfachste Möglichkeit, die leistungsfähige Funktionalität des Tablet PC SDK in einem nicht verwalteten Kontext zu nutzen, besteht darin, die ActiveX-Steuerelemente „InkEdit“ und „InkPicture“ zu verwenden. Diese Steuerelemente vereinfachen die verschiedenen Verfahren, die in der Regel mit den Tablet PC-Objekten durchgeführt werden. Zum Beispiel führt das Steuerelement für die Freihandbearbeitung das InkRecognition-Verfahren für Sie automatisch in einer optimalen Weise durch. Dadurch kommen Sie mit der Tablet PC-Entwicklung schneller voran, als wenn Sie ein solches Steuerelement selbst erstellen müssten.
Jedes Steuerelement hat Anwendungen, bei denen es sinnvoller ist, eher die eine als die andere zu verwenden. Die Unterschiede zwischen den Anwendungen werden in Abbildung 3 gezeigt. Das InkEdit-Steuerelement ermöglicht die Freihanderkennung, ähnelt in seiner Arbeitsweise aber mehr dem RichEdit-Steuerelement. InkEdit kann in eine Anwendung integriert werden, die für den Zugriff auf die Handschrifterkennung auf Tablet PCs abzielt, ohne sich durch die Anzeige des Tablet PC-Eingabebereichs auf die Benutzerfunktionalität auszuwirken. Wenn Sie eine Anwendung erstellen, die eine Eingabe verarbeiten muss, die letzten Endes in Text umgewandelt wird, sollten Sie im Allgemeinen das InkEdit-Steuerelement verwenden.
Function InkEdit InkPicture
Freihanderfassung Ja Ja
Freihanderkennung Ja Nein
Bearbeiten der Freihanddarstellung Nein Ja
Löschen der Freihandeingabe Nein Ja
Bearbeiten von Text pro Zeichen Ja Nein
Konvertieren von Freihandeingabe in Text Ja Nein
Stiftbewegungen in Text Ja Nein
Skalieren zu Schriftgrad Ja Nein
Bildverarbeitung Nein Ja
Das InkPicture-Steuerelement ermöglicht die Illustrationseingabe, führt die Freihanderkennung aber nicht automatisch durch. Wenn Sie eine Anwendung erstellen, in der mit dem Stift gezeichnete Eingaben erfolgen, sollten Sie im Allgemeinen das InkPicture-Steuerelement verwenden. Dieses Steuerelement ist nützlich, wenn Sie möchten, dass der Benutzer eine Freihandeingabe vornimmt und dies beibehält.

Verwenden des InkEdit-Steuerelements
Um die Funktionalität und die Anpassung des InkEdit-Steuerelements zu zeigen, wird als Nächstes gezeigt, wie Sie das InkEdit-Steuerelement einer Anwendung hinzufügen und die Triggererkennung mit einer Schaltfläche auslösen können. In den folgenden Anweisungen werden Sie durch die Schritte geführt, mit denen eine grundlegende MFC-Anwendung und ein Dialogfeld erstellt werden. Beginnen Sie mit dem Erstellen eines neuen MFC-Anwendungsprojekts in Visual Studio. Ändern Sie den Projektnamen in „Einfache Erkennung“ (oder wahlweise einen anderen Namen).
Klicken Sie auf „OK“, und es wird der MFC-Anwendungs-Assistent anzeigt. Der Assistent gibt Ihnen einen schnellen Überblick über die Projekteinstellungen. Sie sollten nichts ändern müssen.
Auf der Seite „Anwendungstyp“ müssen Sie den Anwendungstyp auf „Dialog“ setzen. Klicken Sie auf „Weiter“, um die Seite „Benutzeroberflächenfeatures“ anzuzeigen. Deaktivieren Sie alle Kontrollkästchen auf der Seite „Benutzeroberflächenfeatures“.
Klicken Sie auf „Weiter“, um die Seite „Erweiterte Features“ anzuzeigen. Es sollte nicht notwendig sein, eines der erweiterten Features auf dieser Seite zu ändern. Klicken Sie also auf „Weiter“. Überprüfen Sie Ihre Einstellungen, und klicken Sie auf „Fertig stellen“, um Ihr Projekt zu erstellen.
Auf der Registerkarte „Ressourcen“ für Ihr Projekt finden Sie die .rc-Datei mit den Benutzeroberflächeninformationen für Ihre Dialoganwendung. Doppelklicken Sie darauf, um zu sehen, wie die Anwendung bei ihrer Ausführung aussehen wird. Löschen Sie alle Texte und Schaltflächen im Formular.
Ziehen Sie von der Toolbox eine Schaltfläche (den Erkennungstrigger), ein Gruppenfeld und etwas statischen Text in Ihr neues Dialogfeld (siehe Abbildung 4). Ändern Sie die ID für das Gruppenfeld in IDC_PLACEHOLDER, da dieses Feld (und sein zugehöriges hWnd) das Freihandsteuerelement über sich haben muss. Sie sind jetzt bereit, die Tablettsteuerelemente in Visual Studio einzurichten und den Code zum Laufen zu bringen.
Abbildung 4 Neues Dialogfeld (zum Vergrößern auf das Bild klicken)

Hinzufügen von Freihandsteuerelementen zu Visual Studio
Durch die vorhandenen Freihandsteuerelemente wird das Hinzufügen der Freihandunterstützung zu einer Anwendung sehr erleichtert. Die ActiveX-Steuerelemente (InkEdit und InkPicture) sind in Windows Vista (Home Premium-Version und höher) zusätzlich zu Windows XP für Tablet PC Edition enthalten. Nachdem Sie die Steuerelemente installiert und in Visual Studio aktiviert haben, können Sie die Steuerelemente einfach in Ihrer Anwendung ablegen.
Laden Sie als Erstes das Tablet PC SDK oder das Windows Vista SDK herunter, und installieren Sie es. Nachdem die Installation abgeschlossen ist, starten Sie Visual Studio neu. Öffnen Sie das Projekt, das Sie eben erstellt haben, und kehren Sie zum Ressourcen-Editor zurück, indem Sie auf die .rc-Datei doppelklicken. Nachdem Sie diese Datei geöffnet haben, ändert sich der Toolboxbereich und zeigt die verschiedenen Komponenten an, die Sie für das Entwerfen von Anwendungen verwenden können. Klicken Sie mit der rechten Maustaste auf diesen Bereich, und wählen Sie „Elemente auswählen“ aus.
Das Fenster „Toolboxelemente auswählen“ wird angezeigt. Wählen Sie die Registerkarte „COM-Steuerelemente“ aus, führen Sie einen Bildlauf nach unten durch, und wählen Sie „Microsoft InkEdit Control“ und „Microsoft InkPicture Control“ aus. Nachdem Sie diese Steuerelemente aktiviert haben, werden sie in Ihrer Toolbox angezeigt, und Sie können sie Anwendungen hinzufügen.

Hinzufügen des InkEdit-Steuerelements
Ziehen Sie zum Verwenden der Erkennung das InkEdit-Steuerelement von der Toolbox Ihrer Anwendung, und platzieren Sie es innerhalb des Gruppensteuerelements. Aktualisieren Sie die Caption-Eigenschaft für das Gruppensteuerelement, um anzuzeigen, dass der InkEdit-Bereich für das Erstellen gedacht ist, und nehmen Sie die Größenänderung des InkEdit-Steuerelements vor, damit es gut in den Bereich passt. Stellen Sie in Ihrer Anwendung sicher, dass sich Ihr Gruppensteuerelement nicht mit dem InkEdit-Steuerelement überschneidet. Vorsicht ist außerdem geboten, um nicht versehentlich die Reihenfolge der Steuerelemente zu ändern, wenn Sie das Gruppenfeld-Steuerelement entfernen und wieder hinzufügen. Das InkEdit-Steuerelement sollte das oberste Steuerelement sein.
Erstellen Sie Ihre Anwendung, und führen Sie sie aus. In Abbildung 5 sehen Sie Text, der noch nicht erkannt wurde, und Text, der in meiner Version der Anwendung erkannt wurde.
Abbildung 5 InkEdit führt Texterkennung durch (zum Vergrößern auf das Bild klicken)
Weil das InkEdit-Steuerelement ein automatisches Timeout besitzt, nach dessen Ablauf es die Freihandeingabe erkennt, mussten Sie bislang für die Erkennung der Freihandeingabe nur ein Steuerelement per Drag & Drop auf das Dialogfeld Ihrer Anwendung ziehen. Als Nächstes fügen Sie etwas Code hinzu, um das Verhalten anzupassen.
Zur Texterkennung beim Klicken auf die Schaltfläche „Recognize“ (Erkennen) statt der automatischen Erkennung aufgrund des Standardtimeoutzeitraums für das InkEdit-Steuerelement müssen Sie bei Anwendungsstart das Aktualisierungstimeout von InkEdit ändern und dann die Freihanderkennung auslösen, wenn auf die Schaltfläche „Recognize“ geklickt wird. Dies ist praktisch, weil das InkEdit-Steuerelement ein ActiveX-Steuerelement ist, und Sie können nur die SendMessage-Methode verwenden, um diese Funktionalität in dem Fenster, von dem das ActiveX-Steuerelement gehostet wird, anzugeben.
Fügen Sie als Erstes der OnInitDialog-Funktion den folgenden Code für Ihre Anwendung hinzu:
// Controls are now initialized; set control settings.
CWnd* pInkWnd = NULL;
pInkWnd = GetDlgItem(IDC_INKEDIT3);
if (pInkWnd != NULL){
  // Set the timeout to a large number. 
  // LPARAM specifies the timeout in millisecs.
  // WPARMA must be left at 0.
  LRESULT result  = 
    pInkWnd->SendMessage(EM_SETRECOTIMEOUT, 1000000042, 0);
}else{
  // Indicate that an error occurred.
  ERROR_MSG(L'ERROR: Could not specify recognizer timeout');
}
Fügen Sie als Nächstes den folgenden Code zum Button.Click-Handler für die Recognize-Schaltfläche hinzu. Die einfachste Möglichkeit für das Hinzufügen eines Button.Click-Handlers ist das Doppelklicken auf die Schaltfläche in der Ressourcenansicht des Ressourcen-Editors. Dadurch gelangen Sie direkt zum Codeabschnitt für die Schaltfläche, die Sie erstellt haben:
void Csimplest_recognizerDlg::OnBnClickedButton1() {
  CWnd* pInkWnd = NULL;
  pInkWnd = this->GetDlgItem(IDC_INKEDIT3);
  if (pInkWnd != NULL){
    // Trigger recognition within the InkEdit control.
    LRESULT result  = pInkWnd->SendMessage(EM_RECOGNIZE, 0, 0);
  }
}
Wenn Sie jetzt die Anwendung erstellen und ausführen, werden Sie feststellen, dass das InkEdit-Steuerelement den geschriebenen Text nicht automatisch erkennt und das Klicken auf die Recognize-Schaltfläche erfordert, um die Erkennung auszulösen.

Verwenden des InkPicture-Steuerelements
Das InkPicture-Steuerelement ermöglicht Anwendungsdesignern, Anwendungen zu erstellen, in denen Stifteingaben erfolgen, die als Bild behandelt werden sollen. Auf diese Weise kann ein Benutzer im Steuerelementbereich Objekte zeichnen, die vom Steuerelement interpretiert oder verarbeitet werden können. Für dieses Beispiel werden Sie durch die Erstellung einer sehr einfachen Anwendung geführt, die dem Benutzer ermöglicht, mit dem Stift Striche einzugeben und diese Striche zu löschen und auszuwählen (siehe Abbildung 6).
Abbildung 6 Verwenden von InkPicture (zum Vergrößern auf das Bild klicken)
Wenn die Anwendung gestartet wird, ist der Benutzer im Freihandmodus und kann im Zeichenbereich schreiben. Wenn die Benutzer auf die Schaltfläche „Eraser“ (Radierer) klicken, können sie die Zeilen löschen, die gezeichnet werden. Durch Klicken auf die Auswahlschaltfläche wird der Auswahlmodus aktiviert, und gezeichnete Objekte können ausgewählt werden.
In derselben Weise, in der Sie die Erkennungsanwendung einrichten, erstellen Sie das Dialogfeld für diese Anwendung. Der einzige Unterschied zwischen dieser Anwendung und der letzten besteht darin, dass Sie das InkPicture-Steuerelement statt des InkEdit-Steuerelements verwenden und dass Sie dem unteren Abschnitt des Anwendungsdialogfelds drei Schaltflächen hinzufügen. Der weiße Bereich ist ein InkPicture-Steuerelement. Beachten Sie, dass das Klicken auf die Schaltfläche „Pen“ (Stift), „Eraser“ (Radierer) bzw. „Selection“ (Auswahl) noch nicht funktioniert. Auch wird die Anwendung den Radierer nicht aktivieren, wenn Sie den Stift invertieren.
Jetzt müssen Sie dafür sorgen, dass die Schaltflächen den Status des InkPicture-Steuerelements ändern. Dafür müssen Sie wissen, welche Eigenschaften zu ändern sind. Sie legen dann die Eigenschaften fest, indem Sie das dem Steuerelement zugeordnete CWnd nehmen und die SetProperty-Methode verwenden, um den Status des Steuerelements zu ändern. Um diesen Prozess zu vereinfachen, erstellen Sie eine Funktion namens „setEditingMode“, die einen Wert aus der InkOverlayEditingMode-Enumeration abruft (siehe Abbildung 7).
void CInkPaintDlg::setEditingMode(short mode){
  CComPtr<IInkPicture> ip;    

  // Retrieve the DISPID by using a COM Client for the InkPicture  // control.
  DISPID dispid = 0;
  OLECHAR FAR* szMember = OLESTR('EditingMode');
  ip.CoCreateInstance(CLSID_InkPicture);
  ip->GetIDsOfNames(IID_IInkPicture, &szMember, 1, 
    LOCALE_SYSTEM_DEFAULT, &dispid);                

  // Retrieve the CWnd for the InkPicture Control.
  CWnd* pInkWnd = NULL;
  pInkWnd = this->GetDlgItem(IDC_INKPICTURE1);

  pInkWnd->SetProperty(dispid, VT_I2, mode);
  ip.Release();
}
Nachdem Sie eine Funktion haben, um den Bearbeitungsmodus festzulegen, müssen Sie nur noch Schaltflächen hinzufügen, die den Bearbeitungsmodus in verschiedene Status ändern. Doppelklicken Sie auf die Schaltflächen, die Sie im Ressourcen-Designer erstellt haben, und fügen Sie Handler hinzu, um den Modus entsprechend festzulegen. Der folgende Code zeigt an, wie meine Button.Click-Handler den Bearbeitungsmodus des InkPicture-Steuerelements in die richtigen Status ändern:
// Pen mode
void CInkPaintDlg::OnBnClickedButton1() {
  setEditingMode(InkOverlayEditingMode::IOEM_Ink);
}
// Eraser mode
void CInkPaintDlg::OnBnClickedButton2() {
  setEditingMode(InkOverlayEditingMode::IOEM_Delete);
}
// Selection mode
void CInkPaintDlg::OnBnClickedButton3() {
  setEditingMode(InkOverlayEditingMode::IOEM_Select);
}
Nachdem Ihr Programm löschen und auswählen kann, können Sie darin über das Zeichnen von Strichen mit dem Stifttool hinaus neue Vorgänge durchführen. Das Auswählen des Radierermodus ermöglicht Benutzern, Zeilen zu löschen, das Auswählen des Auswahltools ermöglicht die Strichauswahl und so weiter. Abbildung 8 zeigt die Größenanpassung des ausgewählten Inhalts.
Abbildung 8 Größenanpassung in InkPicture (zum Vergrößern auf das Bild klicken)
Nach dem Ausführen des Programms entscheiden Sie möglicherweise, dass Sie für den Radierer den Punktmodus statt des Strichmodus bevorzugen. Ich habe eine Funktion hinzugefügt, die über einen booleschen Wert die Wahl des einen oder anderen Modus ermöglicht (siehe Abbildung 9).
void CInkPaintDlg::setPointEraseMode(bool setToPointMode){
  CComPtr<IInkPicture> ip;    

  // Retrieve dispid.
  DISPID dispid = 0;
  OLECHAR FAR* szMember = OLESTR('EraserMode');    
  ip.CoCreateInstance(CLSID_InkPicture);
  ip->GetIDsOfNames(IID_IInkPicture, &szMember, 1, 
    LOCALE_SYSTEM_DEFAULT, &dispid);    

  // Retrieve the CWnd for the InkPicture control.
  CWnd* pInkWnd = NULL;
  pInkWnd = this->GetDlgItem(IDC_INKPICTURE1);

  // Toggle the property based on the point mode.
  if (setToPointMode){
    pInkWnd->SetProperty(dispid, VT_I2, 
      InkOverlayEraserMode::IOERM_PointErase);
  }else{
    pInkWnd->SetProperty(dispid, VT_I2, 
      InkOverlayEraserMode::IOERM_StrokeErase);
  }

  ip.Release();
}
Diese Funktion wird im zusätzlichen Initialisierungscode für meine Dialogfeldanwendung aufgerufen:
BOOL CInkPaintDlg::OnInitDialog() {
  // TODO: Add extra initialization here.
  this->setPointEraseMode(true);
  ...
}
Nachdem der Radierermodus auf das Löschen von Punkten gesetzt ist, können Sie Abschnitte der Illustrationen statt ganzer Linien löschen. In einer voll funktionsfähigen Anwendung wäre es logisch, dass alle diese Einstellungen durch ein Kontextmenü umgeschaltet werden.

Ändern der Zeichnungsattribute
Nachdem Ihre Anwendung funktioniert und Sie auswählen, radieren und zeichnen können, können Sie sie erweitern, um die Breite und Farbe des Stifts zu ändern. Fügen Sie Ihrer Anwendung als Erstes mehr Schaltflächen für die verschiedenen Farben hinzu, die Sie unterstützen wollen, z. B. Rot, Blau, Grün und Schwarz. Fügen Sie als Nächstes eine oder zwei Schaltflächen zum Ändern der Strichbreite in dick und dünn hinzu. Um dies zu vereinfachen, habe ich zwei Hilfsfunktionen, setStrokeThickness und setColor, erstellt. Den Code für setStrokeThickness sehen Sie in Abbildung 10.
void CInkPaintDlg::setStrokeThickness(bool isThick){ 

  CComPtr<IInkPicture> ip;
  CComPtr<IInkDrawingAttributes> spIInkDrawAttrs = NULL;

  // Set to thick or thin based on bool.
  // 50 is the default width.
  // 250 is a good thickness.
  float newWidth= isThick ? 250 : 50;

  DISPID dispid = 0;
  OLECHAR FAR* szMember = OLESTR('DefaultDrawingAttributes');

  ip.CoCreateInstance(CLSID_InkPicture);
  ip->GetIDsOfNames(IID_IInkPicture, &szMember, 1,     LOCALE_SYSTEM_DEFAULT, &dispid); 

  CWnd* pInkWnd = NULL;
  pInkWnd = this->GetDlgItem(IDC_INKPICTURE1);

  // Retrieve the drawing attributes interface.
  pInkWnd->GetProperty(dispid, VT_UNKNOWN, &spIInkDrawAttrs);

  // Now use the interface to set the width.
  spIInkDrawAttrs->put_Width(newWidth);

  // Now pass the interface back to set the drawing attributes.
  pInkWnd->SetProperty(dispid, VT_DISPATCH, spIInkDrawAttrs);

  // Free.
  spIInkDrawAttrs.Release();
  ip.Release();
} 
Es gibt nur einen wesentlichen Unterschied zwischen den Hilfsfunktionen und den anderen Funktionen, die feste Eigenschaften im Freihandsteuerelement festlegen. In diesem Beispiel rufen Sie eine untergeordnete Schnittstelle ab (die selbst eine Eigenschaft ist), und dann verwenden Sie diese Schnittstelle, um Änderungen vorzunehmen statt Änderungen in den Eigenschaften der übergeordneten Schnittstelle durchzuführen. Jetzt können Sie die Strichfarbe und -dicke problemlos mithilfe der Hilfsfunktionen ändern:
// RED 
void CInkPaintDlg::OnBnClickedButton4() {
  COLORREF color = RGB(255,0,0);
  setColor(color);
}

// Set thin strokes.
void CInkPaintDlg::OnBnClickedButton8() {
  this->setStrokeThickness(false);
}
Abbildung 11 zeigt die verschiedenen Farben und Strichdicken in der fertigen Anwendung.
Abbildung 11 Benutzerdefinierte Farb- und Linienstärke (zum Vergrößern auf das Bild klicken)

Zusammenfassung
Das Erstellen von Tablet PC-fähigen Anwendungen in MFC mit nicht verwaltetem C++ und den Steuerelementen „InkEdit“ und „InkPicture“ ist ziemlich einfach! Die Funktionalität der Steuerelemente ermöglicht Ihnen außerdem, Anwendungen durch die gängigsten tablettbasierten Features zu erweitern. Standardmäßig verhalten sich Steuerelemente in der Regel so, wie Sie es wünschen. Wenn Sie das Steuerelementverhalten ändern müssen, können Sie den Steuerelementen Nachrichten senden oder relevante Eigenschaften für sie abrufen und festlegen. Zusätzliche Informationen zur Tablet-API finden Sie in der MSDN-Bibliothek (verfügbar unter msdn.microsoft.com/library/ms950406).
Vielen Dank an Jason Groce und Eliot Graff für all ihre technische Hilfe bei diesem Artikel.

Senden Sie Fragen und Kommentare in englischer Sprache an goplaces@microsoft.com.

Gus „gclassy“ Class arbeitet für Microsoft als Programming Writer und Evangelist und hat insbesondere an Tablet PC, Windows Mail und DRM-Systemen mitgearbeitet. In seinem Blog unter gclassy.com erörtert er Entwicklungsprobleme und bietet Programmierbeispiele.

Page view tracker