Erstellen von Tablet PC-Anwendungen mit Visual FoxPro

von Mike Stewart  
Visual FoxPro-Team  
Microsoft Corporation  

Einführung

Die Steuerelemente und APIs, die erforderlich sind, um viele der Ink-Features der Microsoft Windows® Tablet PC Edition nutzen zu können, finden Sie im Tablet PC Platform SDK. Das Tablet PC Platform SDK können Sie von http://www.microsoft.com/windowsxp/tabletpc/developers/default.asp herunterladen. Es stellt die Ink-Objekte auf zwei Arten bereit: über die Component Object Model (COM) Automation, sowie über die Common Language Runtime (CLR) des Microsoft .NET Frameworks über managed APIs. Da Visual FoxPro nicht in die CLR kompiliert, konzentriert sich dieser Artikel auf die COM Automation APIs.  

Der Tablet PC betrachtet Ink anders als frühere Geräte, die ebenfalls Ink als Funktionalität umfassten. Bei früheren Geräten wie dem Apple Newton oder Microsoft Windows CE/Pocket PC-Geräten lag der Schwerpunkt auf der Erkennung von Ink als Handschrift. Beim Tablet PC hat sich diese Philosophie geändert, so dass Ink jetzt als Dateneingabe betrachtet wird, die Umwandlung in Text wird als zweiter Schwerpunkt betrachtet. Beispielsweise können Sie Notizen im Windows Journal, da im Tablet PC und Microsofts OneNote enthalten ist, erfassen, ohne dass es erforderlich ist, diese Notizen in Text umzuwandeln. Das bedeutet, dass die Erkennungsfähigkeiten des Tablet PCs sehr gut sind, und dass für den Fall, dass Sie Ink in Text umwandeln müssen, eine sehr hohe Erkennungsquote erreicht wird.  

Die für VFP-Entwickler interessanten Objekte sind InkEdit, InkPicture und InkOverlay. Das Steuerelement InkEdit entspricht der Editbox von VFP. Der Unterschied besteht darin, dass InkEdit digitale Tinte akzeptiert und erkennt. Das Steuerelement InkPicture ist genau das, was Sie erwarten: in diesem Steuerelement kann ein Bild platziert werden und der Anwender kann mit der digitalen Tinte auf diesem Bild malen. Das Steuerelement liegt unsichtbar über einem Fenster und kann Ink annehmen und verarbeiten.  

Anforderungen an das System

  • Microsoft Tablet PC Platform SDK
  • Microsoft Windows XP. Sie können das Tablet PC Platform SDK auch auf Microsoft Windows XP einsetzen, aber die Microsoft XP Tablet PC Edition ist dringend empfohlen.
  • Microsoft Visual FoxPro 8.0 oder höher. Es ist auch mit früheren Versionen von VFP möglich, nahezu alle Funktionalitäten des Tablet PC Platform SDK zu nutzen. Allerdings sind in VFP 8.0 verschiedene Bugs, die die Zusammenarbeit mit der Microsoft XP Tablet PC Edition betreffen, beseitigt worden.
  • Digitizer. Verschiedene Hersteller bieten Digitizer für die USB-Schnittstelle an, beispielsweise Wacom (http://www.wacom.com) oder es können Anwendungen entwickelt werden, die den eingebauten Digitizer eines Tablet PCx einsetzen.

Nur auf einem Tablet PC?

Das Tablet PC Platform SDK erfordert lediglich Microsoft Windows XP. Allerdings wird die Funktionalität der Steuerelemente durch den Einsatz von Windows XP Tablet PC Edition signifikant erweitert. Ist das SDL nicht auf einem Tablet PC installiert, ist keine Erkennungsengine vorhanden und einige Steuerelemente akzeptieren kein Ink. Es ist also ratsam, wenn Sie zumindest zum Testen und Debuggen Zugriff auf einen Tablet PC haben.  

Im Idealfall können Sie Ihre Anwendungen auf einem Tablet PC codieren und debuggen. Aber wer will schon Code mit einem Stift schreiben? Auch die Tastaturen, über die einige Tablet PCs verfügen, haben nicht die volle Größe. Es gibt verschiedene Möglichkeiten, um dieses Problem zu umgehen. Eine Möglichkeit besteht darin, eine USB-Tastatur und -Maus einzusetzen (oder Sie nutzen eine Dockingstation, falls für Ihren Tablet PC eine solche verfügbar ist). Eine andere Möglichkeit besteht darin, das Feature Remote Desktop von Windows XP zu verwenden, um mit einem Desktop-Rechner auf den Tablet PC zuzugreifen.  

Entscheidungen zum Design

Eine häufig gestellte Frage lautet: „Woher weiß ich, ob meine Anwendung auf einem Tablet PC ausgeführt wird?“ Die Antwort erhalten Sie durch einen Aufruf der Win32®-Funktion GetSystemMetrics mit dem Parameter SM_TABLETPC(86). Ein Rückgabewert ungleich 0 zeigt an, dass Windows XP Tablet PC Edition ausgeführt wird; der Rückgabewert 0 zeigt an, dass dies nicht der Fall ist.  

#define SM_TABLETPC 86
Declare Integer GetSystemMetrics in Win32API Integer
retVal = GetSystemMetrics(SM_TABLETPC)
If retVal <> 0
  Wait Window "Running on a Tablet PC"
Else
  Wait Window "*Not* running on a Tablet PC"
Endif

Ein Rückgabewert ungleich 0 zeigt allerdings noch nicht an, ob alle Komponenten des Tablet PC installiert sind und funktionieren. Um festzustellen, ob eine Komponente installiert ist, versuchen Sie, eine Instanz der Komponente zu erstellen und prüfen Sie dabei auf Fehler während der Erstellung.  

Ein Beispiel:  

Try
oInkEdit = Newobject("InkEd.InkEdit.2")
Catch To oException
Wait Window "InkEdit control is not installed!"
Endtry

Abbildung 1. Der Tablet PC im Hochformat

Abbildung 2. Der Tablet PC im Querformat.

Ein Tablet PC kann über zwei Anzeigemodi verfügen: Quer- und Hochformat. Meist wird das Querformat genutzt, wenn der Tablet PC angedockt ist oder als Standard-Laptop eingesetzt wird; im Hochformat wird er genutzt, wenn er als Tablet eingesetzt wird.  

Es kann vorkommen, dass Ihre Anwendung feststellen muss, ob der Tablet PC des Anwenders im Hoch- oder im Querformat ausgeführt wird, damit die Größe der Bildschirmelemente entsprechend angepasst wird. Durch den Einsatz der Funktion SYSMETRIC() von VFP mit den Parametern 1 oder 2 können Sie die Breite und Höhe der Anzeige feststellen. Ist die Breite geringer als die Höhe, befindet sich der Tablet PC im Hochformat.  

Sie müssen beim Design Ihrer Anwendung noch weitere Entscheidungen treffen. Lesen Sie in der Hilfedatei des Tablet PC SDKs den Eintrag „Planning Your Application“.  

Digitale Tinte sammeln

Die einfachste Möglichkeit, Eingaben per Stift entgegenzunehmen, ist der Einsatz des Objekts InkCollector, das durch das Tablet PC Platform SDK zur Verfügung gestellt wird. Es ist extre  

m einfach einzusetzen und erfordert lediglich drei einfache Schritte zum Einrichten und Aktivieren. InkCollector wird einem Formular über das Windows-Handle (hWnd) des Formulars hinzugefügt und ermöglicht dem gesamten Formular die Eingabe per Stift.  

Ink Collection auf einem Formular ermöglichen

  1. Erstellen Sie ein neues Objekt mit dem InkCollector.
  2. Fügen Sie dem Windows-Handle des Formulars den InkCollector hinzu.
  3. Aktivieren sie den InkCollector, indem Sie dessen Eigenschaft Enabled auf .T. setzen.

Führen Sie den folgenden Code aus und starten Sie die Eingabe per Stift.  

Local oInkCollector as MSINKAUT.inkcollector.1
Local oForm1 as Form
oForm1 = NewObject("form")

*-- Erstellen Sie einen neuen InkCollector und stellen Sie das 
*-- Fensterhandle auf das Formular ein, auf dem wir
*-- mit dem InkCollector arbeiten wollen.
oInkCollector = NewObject("msinkaut.inkcollector.1")
oInkCollector.hWnd = oForm1.HWnd

*-- Das war es, wir haben alles eingerichtet. Aktivieren
*-- Sie den InkCollector, damit wir ihn verwenden können.
oInkCollector.Enabled = .t.

*-- Der InkCollector ist aktiv, zeigen wir das Formular an.
oForm1.Show
Read Events

Der folgende Code ist der Tablet PC-spezifische:  

oInkCollector = NewObject("msinkaut.inkcollector.1")
oInkCollector.hWnd = oForm1.HWnd

Wenn Sie das Windows Journal eingesetzt haben, werden Sie eventuell erwarten, dass Sie in einer Tablet PC-Anwendung die Möglichkeit haben, Ink zu markieren, zu ändern und zu löschen. Wenn Sie das Objekt InkCollector einsetzen, können Sie auf Ihrem Formular zeichnen, das Geschriebene akzeptieren und die Ink anschließend löschen. Allerdings können Sie die Methode InkCollector in Ihrer VFP-Anwendung nicht einsetzen, um Ink zu markieren, zu ändern oder zu löschen. Dafür setzen Sie die Klasse InkOverlay ein. InkOverlay ist ein erweitertes InkCollector, so dass Sie über die vollständige Funktionalität verfügen.  

Die Klasse InkOverlay

Der Einsatz der Klasse InkOverlay ist so einfach wie der Einsatz der Klasse InkCollector. Aufgrund der zusätzlichen Funktionalitäten ist aber bei dieser Klasse einiges mehr zu beachten. Beginnen wir mit einem einfachen Formular, das InkOverlay enthält und das die Möglichkeit hinzufügt, festzustellen, was der Anwender schreibt. Beachten Sie, dass Sie, um die Schaltfläche Recognize zu betätigen, Alt-R betätigen müssen. Gleich erfahren Sie, weshalb dies so ist.  

*-------------------------------------
*--    Program:   InkOl1.prg
*--

*--    Author:    Mike Stewart
*--    Comments:  Simple InkOverlay demo using an
*--               InkOverlay class with a recognizer
*--               button.
*-------------------------------------
PUBLIC oform1
oform1=NEWOBJECT("InkOverlayDemo1")
oform1.Show
RETURN
DEFINE CLASS InkOverlayDemo1 AS form
    Top = 0
    Left = 0
    Height = 416
    Width = 659
    DoCreate = .T.
    Caption = "Form1"
    Name = "Form1"
    ADD OBJECT inkRecognize AS Commandbutton WITH ;
        Top = 368, ;
        Left = 20, ;
        Caption = "\<Recognize ", ;
        Name = "Inkbutton1"
    ADD OBJECT edtrecognized AS editbox WITH ;
        Height = 121, ;
        Left = 20, ;
        Top = 236, ;
        Width = 589, ;
        Name = "edtRecognized"
    PROCEDURE Init
        PUBLIC oink As msinkaut.inkoverlay.1
        oInk = NEWOBJECT("msinkaut.inkoverlay.1")
        WITH oInk
            *-- Point it to the window for which you
            *-- want to capture ink. Because VFP does
            *-- not have hWnds for individual controls,
            *-- this can only be done at the form level.
            .hwnd = thisform.HWnd

            *-- The Attachmode property
            *-- determines whether the
            *-- InkOverlay sits in front
            *-- or behind the controls on
            *-- the form.
            .AttachMode = 0  && IOAM_Behind
            *-- Set everything before enabling,
            *-- or else error occurs.
            .enabled = 1

*-- Set to collect both ink and gestures
        .CollectionMode = 2  && ICM_InkAndGesture
        ENDWITH
    ENDPROC
    PROCEDURE inkRecognize.Click
    thisform.edtRecognized.value = ;
    oInk.ink.strokes.tostring
    ENDPROC
ENDDEFINE

Abbildung 3. Das Formular mit der Klasse InkOverlay, nachdem auf die Schaltfläche Recognize geklickt wurde.

Mit nur 38 Zeilen Code verfügen wir über ein funktionierendes Formular, das Ink akzeptiert und das die Fähigkeit besitzt, die Eingabe zu erkennen und sie in ein Steuerelement von VFP zu schreiben, das an ein Feld gebunden ist und dessen Wert in eine Tabelle geschrieben werden kann.  

Wenn Sie den oben stehenden Code ausführen, werden Sie festgestellt haben, dass es schwierig war, mit dem Stift oder der Maus auf die Schaltfläche Recognize zu klicken. Dies liegt daran, dass das gesamte Formular umfasst wird, wenn Sie ihm das Objekt InkOverlay hinzufügen. Dieses Verhalten entspricht dem der Klasse InkCollector. Offensichtlich klappt dies bei den meisten Anwendungen nicht, da der Großteil der Formulare Textboxen und andere Steuerelemente enthält, in denen die Eingaben der Benutzer aufgenommen werden.  

Für dieses Problem gibt es eine einfache Lösung. Sie besteht darin, für InkOverlay ein Rechteck zu definieren. Das Tablet PC Platform SDK stellt für genau diesen Zweck das Objekt InkRectangle und die Methode InkOverlay.SetWindowInputRectangle bereit. Die Änderungen am oben stehenden Code sind minimal. Zunächst einmal erstellen Sie mit dem folgenden Code die Methode SetRectangle.  

Procedure SetRectangle
LOCAL oInkRectangle as MSINKAUT.inkrectangle
oInkrectangle = NEWOBJECT("msinkaut.inkrectangle") 

*-- Den Fuß des Rechtecks
*-- über die Editbox setzen.
*-- Dadurch überlappt das InkOverlay
*-- nicht die Steuerelemente.
oInkRectangle.Bottom = thisform.edtRecognized.Top 

*-- Die anderen Ausdehnungen des Rechtecks
*-- entsprechen denen des Formulars
oinkrectangle.Top = thisform.Top
oinkrectangle.Left = thisform.Left
oinkrectangle.Right = thisform.Width - thisform.Left 

*-- Aufruf der Methode, wobei InkRectangle
*-- übergeben wird, und das war's auch schon.
ThisForm.InkOverlay.SetWindowInputRectangle(oInkRectangle)

Anschließend rufen Sie diese Methode aus der Methode Init des Formulars heraus auf:  

.AttachMode = 1  && IOAM_InFront this.setrectangle
this.setrectangle

Führen Sie den Code aus und Sie werden feststellen, dass der Eingabebereich für den Stift jetzt auf den Bereich der Editbox beschränkt ist.  

Eine andere Lösung besteht darin, die Eigenschaft InkOverlay.AttachMode auf 0 (IOAM_Behind) zu setzen. Damit wird InkOverlay hinter den Steuerelementen auf dem Formular platziert, so dass Sie die Steuerelemente wie normal nutzen können. Ein Problem dieser Lösung besteht darin, dass der Anwender zwischen den Steuerelementen schreiben kann, aber nicht auf ihnen. Eine mit der Methode SetInputWindowTectangle gut definierte Inking-Oberfläche könnte für Ihre Anwender die bessere Lösung sein.  

Auswählen und Löschen digitaler Tinte

Der folgende Code zeigt, wie eine Combobox für die Auswahl zwischen drei Cursorn hinzugefügt wird:  

  • Ink Cursor – für Zeichnen und Schreiben.
  • Selection Lasso – eingesetzt für die Markierung von Ink.
  • Eraser – eingesetzt für das Löschen von Ink.

Zunächst fügen Sie der Klassendefinition eine Combobox hinzu:  

ADD OBJECT inkPenType AS combobox WITH ;
    RowSourceType = 1, ;
    RowSource = "Ink,Select,Delete", ;
    Height = 24, ;
    Left = 36, ;
    Top = 428, ;
    Width = 168, ;
Name = "inkPenType"

Jetzt fügen Sie dem Ereignis InteractiveChange der Combobox den folgenden Code hinzu, um die Eigenschaft EditingMode auf der Basis der Auswahl des Anwenders einzustellen:  

PROCEDURE inkPenType.InteractiveChange
    DO Case
    CASE this.Value = "Ink"
        thisform.inkoverlay.EditingMode = 0  && IOEM_Ink
    CASE this.Value = "Select"
        thisform.inkoverlay.EditingMode = 2  && IOEM_Select
    CASE this.Value = "Delete"
        thisform.inkoverlay.EditingMode = 1  && IOEM_Delete
        *-- Letztendlich stellen Sie den EraserMode ein,
        *-- je nachdem, ob die gesamte Linie gelöscht
        *-- werden soll, wenn der Stift den Monitor berührt,
        *-- oder ob nur einzelne Pixel gelöscht werden:
        *-- Set EraserMode to 0 to erase strokes,
        *--                or 1 to erase pixels
        *-- thisform.inkoverlay.EraserMode = 0
        thisform.Inkoverlay.EraserMode = 1
    ENDCASE
ENDPROC

Durch eine Auswahl der entsprechenden Option in der Combobox kann der Anwender jetzt das Verhalten des Stifts ändern.  

Speichern und Laden von Digitaler Tinte

Vermutlich will der Anwender das von ihm Geschriebene speichern und zu einem späteren Zeitpunkt neu laden.  

Zunächst einmal lassen Sie uns der Klassendefinition des Formulars einige Schaltflächen hinzufügen, eine für das Speichern des Inks und eine, um Ink in das Formular zu laden:  

ADD OBJECT cmdSave AS commandbutton WITH ;
    Top = 360, ;
    Left = 357, ;
    Height = 27, ;
    Width = 84, ;
    Caption = "\<Save", ;
    Name = "cmdSave"
ADD OBJECT cmdLoad AS commandbutton WITH ;
    Top = 360, ;
    Left = 456, ;
    Height = 27, ;
    Width = 84, ;
    Caption = "L\<oad", ;
    Name = "cmdLoad"

Nun fügen Sie dem Ereignis Save der Schaltfläche Code hinzu:  

PROCEDURE cmdSave.Click
    lsInk = ThisForm.inkoverlay.Ink.Save()
    STRTOFILE(lsInk, GETFILE("isf"))
ENDPROC

Das Ink-Objekt des InkOverlay nutzt seine Methode Save, um ein Byte-Array zurückzugeben, das das Ink auf dem InkOverlay repräsentiert. Mit Hilfe von FoxPros Funktion STRTOFILE() kann dieses Byte-Array (das FoxPro als String behandelt) anschließend auf der Festplatte gespeichert werden.  

Um das gespeicherte Ink-Objekt über die Schaltfläche Load neu zu laden, nutzen Sie die Methode Ink.Load:  

PROCEDURE cmdLoad.Click
    lsInk = CREATEBINARY(FILETOSTR(GETFILE("isf")))
    thisform.inkoverlay.Enabled = 0
    thisform.inkoverlay.ink.Load(lsInk)
    thisform.inkoverlay.Enabled = 1
 
    *-- Weisen Sie das Steuerelement an, sich neu zu zeichnen,
         *-- oder die Änderungen werden nicht angezeigt.
    *-- Verwenden Sie während des Init des Formulars
         *-- das von uns erstellte Objekt InkRectangle.
    ThisForm.inkoverlay.Draw(ThisForm.InkRectangle)
ENDPROC

Beachten Sie den Einsatz der Funktion CREATEBINARY(), wenn die Ink-Datei in eine FoxPro-Variable eingelesen wird. Dies ist erforderlich, um sie in ein Format zu bringen, die das Objekt InkOverlay akzeptiert. Beachten Sie auch, dass das InkOverlay zunächst deaktiviert werden muss, bevor das Ink geladen wird. Andernfalls würde ein Fehler auftreten.  

Versuchen Sie folgendes: Speichern Sie etwas Ink in einer Datei, beenden Sie das Formular, führen es erneut aus und laden Sie das von Ihnen erstellte Ink. Jetzt klicken Sie auf die Schaltfläche Recognize. Das InkOverlay erkennt das Ink! Dies liegt daran, dass das InkOverlay nicht nur die Position der Pixel speichert, so dass es später erneut angezeigt werden kann, sondern es werden auch die Metadaten gespeichert, die für die Erkennung erforderlich sind.  

Was ist in diesen Metadaten enthalten? Die Metadaten der Datei enthalten Informationen wie das Datum und den Zeitstempel sowie auch eine eindeutige Identifizierung für jeden Stich.  

Das Steuerelement InkEdit

Das Steuerelement InkEdit ist ein erweitertes RichText-Steuerelement. Es wurde entworfen, um eine einfache Möglichkeit zu schaffen, Ink zu akzeptieren, anzuzeigen und zu erkennen. Um ein Steuerelement InkEdit auf einem VFP-Formular zu implementieren, ziehen Sie ein ActiveX-Steuerelement von der Steuerelemente-Toolbar des Formulars. Wenn Sie danach gefragt werden, markieren Sie das InkEdit-Steuerelement.  

Abbildung 4. Vor der Erkennung

Abbildung 5. Nach der Erkennung

Da das Steuerelement InkEdit auf dem Steuerelement RichText basiert, können die Anwender Eingaben im Steuerelement InkEdit vornehmen, genau wie sie es von der Standard-Textbox oder -Editbox gewohnt sind. Durch den Einsatz des Steuerelements InkEdit können Sie Anwendungen erstellen, die dem Anwender die Option eröffnen, Daten wahlweise mit der Tastatur oder mit dem Stift einzugeben.  

Das Steuerelement InkPicture

Das Steuerelement InkPicture kombiniert die meisten der Attribute des Steuerelements InkOverlay mit der Fähigkeit, Ink über eine Grafikdatei zu legen. Der folgende Code demonstriert, wie ein Formular mit einem InkPicture-Steuerelement erstellt wird und gibt dem Anwender die Möglichkeit, die Grafik auszuwählen, die geladen werden soll. Das Steuerelement InkPicture kann auch genau wie ein InkEdit-Steuerelement auf ein Formular gezogen werden. In Abbildung 4 ist es das Steuerelement direkt unter dem InkEdit.  

PUBLIC ofrminkpicture

ofrminkpicture=NEWOBJECT("frminkpicture")
ofrminkpicture.Show
RETURN

DEFINE CLASS frminkpicture AS form
    Top = 0
    Left = 0
    Height = 460
    Width = 469
    DoCreate = .T.
    Caption = "InkPicture Form"
    AllowOutput = .F.
    Name = "frmInkPicture"

    ADD OBJECT olecontrol1 AS olecontrol WITH ;
        Top = 12, ;
        Left = 7, ;
        Height = 444, ;
        Width = 360, ;
        OleClass = "msinkaut.inkpicture.1"
        OleLCID = "1033"
        Name = "Olecontrol1"

    ADD OBJECT cmdload AS commandbutton WITH ;
        Top = 24, ;
        Left = 374, ;
        Height = 27, ;
        Width = 84, ;
        Caption = "\<Load Image", ;
        Name = "cmdLoad"

    ADD OBJECT cmdcolor AS commandbutton WITH ;
        Top = 60, ;
        Left = 374, ;
        Height = 27, ;
        Width = 84, ;
        Caption = "\<Color", ;
        Name = "cmdColor"

    PROCEDURE cmdLoad.Click
        WITH thisform.olecontrol1
            Try
                .Picture =;
LoadPicture;
(GetFile("bmp;jpg;jpeg;gif",;
"Graphics files"))
            Catch To oException
                MessageBox("No file selected")
            Endtry
        ENDWITH
    ENDPROC
    PROCEDURE cmdcolor.Click
        thisform.olecontrol1.DefaultDrawingAttributes.Color =;
        GetColor()
    ENDPROC
ENDDEFINE

Das OleControl ist in folgendem Codeteil definiert:  

OleClass = "msinkaut.inkpicture.1"
OleLCID = "1033"

Nachdem das Steuerelement definiert ist, gibt es dem Anwender die Möglichkeit, eine Grafikdatei in die Methode Click der Schaltfläche Load zu laden. Dafür ist nur eine Zeile Code erforderlich. Selbstverständlich können Sie in den Code auch eine Fehlerbehandlung aufnehmen.  

PROCEDURE cmdLoad.Click
WITH thisform.olecontrol1
Try
        .Picture =;
        LoadPicture;
        (GetFile("bmp;jpg;jpeg;gif",;
        "Graphics files"))
            Catch To oException
            MessageBox("No file selected")
    Endtry
ENDWITH
ENDPROC

Sie können auch noch eine Schaltfläche Color hinzufügen, um dem Anwender die Möglichkeit zu geben, die Farbe des Ink zu ändern. Diese Fähigkeit steht auch im Steuerelement InkOverlay zur Verfügung.  

PROCEDURE cmdcolor.Click
thisform.olecontrol1.DefaultDrawingAttributes.Color =;
GetColor()
ENDPROC

Die Collection DefaultDrawingAttributes bietet eine Vielzahl an Möglichkeiten, die Art zu ändern, in der das Ink gezeichnet wird. In diesem Beispiel ist Color das einzige Element der Collection und der Code ruft einfach FoxPros Funktion GETCOLOR() auf, um die Farbwahl des Anwenders entgegenzunehmen.  

Wie schon das Steuerelement InkOverlay kann auch das Steuerelement InkPicture Ink erkennen, speichern und laden. Der Code für die Erledigung dieser Aufgabe mit dem Steuerelement InkOverlay führt direkt über das Steuerelement InkPicture.  

Zusammenfassung

Dies sind lediglich einige der Dinge, die Sie mit dem Tablet PC SDK und Visual FoxPro auf dem Tablet PC erledigen können. Der Artikel hat die Aufgabe, Sie auf die Möglichkeiten aufmerksam zu machen, die Ihnen beim Schreiben von Anwendungen für den Tablet PC zur Verfügung stehen. Eine vollständige Liste der Eigenschaften, Ereignisse und Methoden der hier behandelten Steuerelemente finden Sie in der Hilfedatei des Tablet PC SDK.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.