Entwicklerleitfaden für Ultrabook™ Geräte und Tablets mit Windows* Touch

Artikel herunterladen

Entwicklerleitfaden für Ultrabook™ Geräte und Tablets mit Windows* Touch herunterladen [PDF 958,6 KB]

Inhalt

• Auszug
• Einführung
• Hardwareanforderungen
• Betriebsumgebungen für Ultrabook Geräte
• Touch-Interaktionen: Zeiger, Gesten und Manipulation
  • Zeiger-Interaktionen
  • Manipulations- und Gesten-Interaktionen
  • Individuelle Gestenerkennung
• Touch-Unterstützung in Webbrowsern
  • Internet Explorer 10 und seine Kompatibilität mit Windows 7
• Ermittlung der Touch-Funktionalität
• UI-Design für touchfähige Ultrabook Geräte
• Ressourcen für die Entwicklung von Touch-Anwendungen
  • Verwandte Artikel in der Intel Developer Zone
  • Verwandte Artikel im MSDN
• Zusammenfassung
• Zur Autorin

Kurzbeschreibung

Dieser Leitfaden enthält Informationen zu den APIs, die Anwendungsentwickler bei der Entwicklung von Apps speziell für Ultrabook™ Geräte verwenden müssen. Er enthält Informationen zur Entwicklung von Apps, die auf Windows* 7, Windows* 8 Desktop und Windows* Modern UI oder auch in Webbrowsern laufen.

Darüber hinaus beschreibt dieser Leitfaden, was Benutzer im Bereich Gestik allgemein erwarten, und bietet Hilfestellung bei der Entwicklung überzeugender Touch-Schnittstellen.

Einführung

Mit dem wachsenden Angebot an touchfähigen Ultrabook™ Geräten ist Software-Entwicklern daran gelegen, speziell für die Touch-Eingabe konzipierte Software zu entwickeln. Damit eine App uneingeschränkt touchfähig ist, muss sie drei Kriterien erfüllen:

• Die am häufigsten verwendeten Bedienelemente sind mindestens 40 x 40 Pixel groß, also ausreichend für die Bedienung per Fingerkuppe.
• Entsprechende Gesten werden unterstützt (Verschieben, Zoomen, Drehen, Tippen mit zwei Fingern, Drücken und Tippen), und die Oberfläche reagiert unmittelbar am Berührungspunkt.
• Die App bietet beim Verschieben, Zoomen und Drehen ein sauberes, reaktionsfreudiges visuelles Feedback und fühlt sich somit höchst interaktiv an.

Egal ob es um die Programmierung einer neuen App oder die Aktualisierung einer bestehenden App für Touch-Unterstützung geht, dieser Leitfaden bietet in jedem Fall nützliche Hilfestellung.

Hardwareanforderungen

Das Angebot an touchfähigen Geräten für Verbraucher ist riesig. Für Entwickler besteht die schwierige Aufgabe darin, Apps zu entwickeln, die sich auf jedem Gerät natürlich anfühlen. Allgemein gilt, dass touchfähige Apps auf jedem der Zielgeräte laufen und gleichzeitig die jeweilige Touch-Funktionalität in vollem Umfang ausnutzen sollten. Ultrabook Geräte bieten ein Höchstmaß an Touch-Funktionalität und sollten beim Design der Touch-Oberfläche einer App die Grundlage bilden.

Ultrabook Geräte mit Touchscreens sind seit 2011 im Handel erhältlich:

• Intel® Core™ Prozessoren der 2. Generation (Codename Sandy Bridge). Diese Systeme wurden mit Windows 7 am Markt eingeführt und haben teilweise Touchscreens.
• Intel® Core™ Prozessoren der 3. Generation (Codename Ivy Bridge). Diese Systeme wurden zunächst ebenfalls mit Windows 7 am Markt eingeführt, werden aber jetzt mit Windows 8 verkauft. Ab 2013 werden diese in größerem Umfang Touch-Funktionalität aufweisen, insbesondere da viele der neuen Designs „Convertibles“ sind.

Beim Rest dieses Entwicklerleitfadens wird davon ausgegangen, dass es sich bei der Zielplattform um ein touchfähiges Ultrabook System handelt. Für dieses Gerät konzipierte Software kann für andere touchfähige Geräte angepasst werden, auf denen das gleiche Betriebssystem läuft.

Betriebsumgebungen für Ultrabook Geräte

Beim App-Design muss heute sorgfältig überlegt werden, in welcher Umgebung sich die Kunden am häufigsten bewegen und für welche Umgebung sich eine App am besten eignet. Sowohl bei Apps für den Windows 8 Desktop als auch bei Apps für den Windows Store muss sich der Entwickler darüber im Klaren sein, um welche Oberflächen es sich genau handelt.

Wenn eine App auf die Windows 8 UI ausgelegt ist (auch als Windows Store App bezeichnet), dann müssen die WinRT APIs verwendet werden. Soll eine App auf dem Windows 8 Desktop laufen, gibt es mehrere Möglichkeiten: die alten APIs aus Windows 7 und die neuen Windows 8 APIs für Touch. Diese Schnittstellen werden weiter unten genauer betrachtet. Bei der Entwicklung von Web-Apps gibt es wiederum andere Möglichkeiten. Touch-Schnittstellen für Webbrowser werden ebenfalls weiter unten behandelt.

Touch-Interaktionen: Zeiger, Gesten und Manipulation

Bei der Touch-Eingabe gibt es verschiedene Interpretationsstufen. Zeigerereignisse sind die einfachsten aufgrund des Touch-Kontakts per Berührung eines Einzelpunkts. Gesten- und Manipulationsereignisse bauen auf dieser Basis auf. Gestenereignisse eignen sich gut zum Erfassen einfacher Tippen-und-Halten-Gesten. Manipulationsereignisse stehen in Zusammenhang mit Touch-Interaktionen, bei denen mittels physischer Gesten die physische Manipulation von UI-Elementen emuliert wird. Die Interaktion mit den UI-Elementen am Bildschirm mittels Manipulationsereignissen fühlt sich für den Benutzer natürlicher an. Die verfügbaren Touch-Schnittstellen bieten ein unterschiedliches Maß an Unterstützung für diese drei Interpretationsstufen.

Zeiger-Interaktionen

Ein Zeigerereignis ist eine einzelne eindeutige Eingabe oder „Berührung“ durch ein Eingabegerät wie Maus, Eingabestift, einzelner Finger oder mehrere Finger. Bei Berührung erstellt das System einen Zeiger, sobald dieser erkannt wird. Wenn der Zeiger den Erfassungsbereich verlässt oder abgebrochen wird, wird er zerstört. Bei Multi-Touch-Eingabe ist jede Berührung ein eindeutiger Zeiger. Tabelle 1 zeigt die Schnittstellen für grundlegende Zeigerereignisse, die für Ultrabook™ Geräte mit Windows 7 und Windows 8 zur Verfügung stehen.

Tabelle 1. Für Ultrabook Geräte verfügbare Zeiger-APIs

Touch-Schnittstelle für Windows 7 und Windows 8: WM_TOUCH

Mit der Meldung WM_TOUCH kann angezeigt werden, dass ein oder mehrere Zeiger, wie ein Finger oder Stift, den Bildschirm berührt haben.

Touch-Schnittstelle für Windows 8 Desktop: WM_POINTER

Die Meldungen WM_POINTER sind Teil der Direct Manipulation APIs und gelten speziell für den Windows 8 Desktop. Mit dieser Schnittstelle können sowohl einzelne Touch-Zeiger als auch Gesten und Manipulationen erfasst werden. Auf die Meldungen WM_POINTER wird im Abschnitt zu Manipulations- und Gesten-Interaktionen näher eingegangen.

Touch-Schnittstelle für Windows Modern UI: PointerPoint

Die Klasse PointerPoint gehört zur Windows Laufzeitumgebung und ist nur mit Windows Store-Apps kompatibel. Sie stellt grundlegende Eigenschaften bereit für den Eingabezeiger in Zusammenhang mit einer einzelnen Maus-, Eingabestift- oder Touch-Berührung. Das MSDN stellt Code-Beispiele bereit, die Entwicklern beim Einstieg mit der PointerPoint Schnittstelle helfen.

Manipulations- und Gesten-Interaktionen

Mit Gestenereignissen werden statische Fingerinteraktionen wie Tippen oder Drücken-und-Halten verarbeitet. Doppeltippen und Rechtstippen werden aus diesen grundlegenden Gesten abgeleitet:

• Gesten: die physische Handlung oder Bewegung, die auf oder von dem Eingabegerät durchgeführt wird. Dabei kann es sich um einen oder mehrere Finger, einen Eingabestift oder eine Maus handeln.
• Manipulation: die unmittelbare, ununterbrochene Reaktion eines Objekts auf eine Geste. So bewirkt beispielsweise die Ziehbewegung, dass sich ein Objekt auf irgendeine Weise bewegt.
• Interaktionen: wie eine Manipulation interpretiert wird sowie der Befehl oder die Aktion, die auf die Manipulation folgt. So ähneln sich zwar die Zieh- und Streifbewegung, aber das Resultat hängt davon ab, ob eine Grenzdistanz überschritten wurde.

Tabelle 2.Grundlegende Gesten für Manipulations-Interaktikonen

Tabelle 3.Für Ultrabook™ Geräte verfügbare Gesten-Schnittstellen

Tabelle 4. Standardmäßig erwartete Interaktionen und Konsequenzen für Touch-Interaktionen

Interpretation von Manipulations- und Gesten-Interaktionen für Windows 7 Desktop

Die Schnittstelle IManipulationProcessor kann zusammen mit der WM_TOUCH API verwendet werden, um für UI-Objekte die Funktionen Übersetzung, Drehung, Skalierung und Trägheit zu ermöglichen. Die aus dieser Kombination resultierende Funktionalität ähnelt den Gestenerkennungsmerkmalen von WM_POINTER. Wenn der Manipulation Processor aktiviert ist, startet die Manipulation unmittelbar nach der Initiierung einer Touch-Geste.

Die Meldungen WM_GESTURE besitzen eine Struktur mit der Bezeichnung GESTUREINFO, mit der Gesten und Manipulationen interpretiert werden können. Die MSDN Webseite für WM_GESTURE zeigt beispielhaft, wie mithilfe der Struktur GESTUREINFO gestenspezifische Informationen erhalten werden können

Beachten Sie, dass bei WM_GESTURE Einschränkungen bestehen. Beispielsweise gibt es maximal nur zwei gleichzeitige Touch-Eingaben, und gleichzeitige Gesten werden nicht unterstützt. Verwenden Sie bei Apps, die einen größeren Funktionsumfang erfordern, aber trotzdem Windows 7 Desktop unterstützen sollen, die WM_TOUCH Schnittstelle und programmieren Sie entweder einen individuellen Gesture Recognizer wie in Abschnitt Individuelle Gestenerkennung unten beschrieben oder verwenden Sie die Manipulation Processor-Schnittstelle mit WM_TOUCH.

Verarbeitung von Manipulations- und Gesten-Interaktionen für Windows 8 Desktop

Anwendungen, die exklusiv für den Windows 8 Desktop konzipiert sind, können die Direct Manipulation APIs (Meldungen WM_POINTER) verwenden. Die Pointer-Meldungen werden an ein internes Interaction Context Objekt weitergeleitet, das für die Erkennung der Manipulation verantwortlich ist, ohne dass ein individueller Gesture Recognizer implementiert werden muss. Es gibt eine Callback-Infrastruktur, die alle Interaktionen mit nachverfolgten Berührungen verwaltet.

Direct Manipulation kann sowohl Manipulations- als auch Gesten-Interaktionen verarbeiten und unterstützt zwei Modelle für die Eingabeverarbeitung:

1. Automatisch/unabhängig: Fenstermeldungen werden von Direct Manipulation auf dem delegierten Thread automatisch abgefangen und ohne die Ausführung von Anwendungscode verarbeitet, weshalb diese Methode von der Anwendung unabhängig ist.
2. Manuell/abhängig: Fenstermeldungen werden von der im UI-Thread ausgeführten Fensterprozedur empfangen, die daraufhin Direct Manipulation zur Verarbeitung der Meldungen aufruft, weshalb diese Methode von der Anwendung abhängig ist.

Gesten können erfasst werden, indem Direct Manipulation initialisiert und das System für die Eingabeverarbeitung vorbereitet wird.

Verarbeitung von Manipulations- undGesten-Interaktionen für Windows 8 Modern UI

Die GestureRecognizer API ist verantwortlich für Zeigereingaben, um Manipulations- und Gestenereignisse zu verarbeiten. Jedes von der Methode PointerPoint ausgegebene Objekt dient der Versorgung von GestureRecognizer mit Zeigerdaten. Der Gesture Recognizer hört auf und wickelt die Zeigereingaben ab und verarbeitet statische Gestenereignisse. Ein Beispiel zur Erstellung eines GestureRecognizer-Objekts mit nachfolgender Implementierung der Manipulation von Gestenereignissen an diesem Objekt finden Sie auf der MSDN GestureRecognizer Webseite (siehe Info unten.)

Individuelle Gestenerkennung

Verwenden Sie sofern möglich die integrierten Gesture Recognizer (siehe Tabelle 3). Falls sich die erforderlicher Funktionalität aber durch die bereitgestellten Gesten- und Manipulations-Schnittstellen nicht realisieren lässt oder die App beispielsweise schneller zwischen Tippen und Gesten unterscheiden muss, muss eventuelle eine Software zur individuellen Gestenerkennung programmiert werden. In diesem Fall erwarten die Kunden ein intuitives Erlebnis bei direkter Interaktion mit den UI-Elementen der App. Die individuellen Interaktionen sollten am besten auf den standardmäßigen Bedienelementen aufbauen, um konsistente und erkennbare Benutzeraktionen zu ermöglichen. Individuelle Interaktionen sollten nur dann angewendet werden, wenn eine klare, ausdrücklich definierte Anforderung existiert und die Standard-Interaktionen die gewünschte Funktionalität der App nicht unterstützen. Eine Liste gängiger und erwarteter Interaktionen und Konsequenzen für Touch-Interaktionen finden Sie in Tabelle 4.

Touch-Unterstützung in Webbrowsern

Touch-Eingabe gibt es auch für Apps, die in Webbrowsern laufen. Der Grad der Unterstützung ist von Browser zu Browser unterschiedlich. Der Funktionsumfang bei Webbrowsern ändert sich rasend schnell. Daher ist es besser, unterstützte Funktionen zu erkennen als bestimmte Browser. Die Funktionserkennung hat sich als die wirksamere Methode gezeigt, wenn erst einmal ermittelt wurde, ob es sich um Internet Explorer (IE) 10, einen auf Webkit* aufbauenden Browser oder einen anderen Browser handelt, der Unterstützung erfordert. Die Funktionserkennung kommt aus folgenden Gründen mit weniger Wartung aus:

• Neue Browser werden veröffentlicht und bestehende Browser werden häufig aktualisiert. Vorhandener Code wird bei neuen Browserversionen nicht zwingend wiederverwendet. Aktualisierte Browser unterstützen möglicherweise Standards und Funktionen, die beim Design des Browsererkennungscode nicht unterstützt wurden.
• Neue Geräte sind häufig mit neuen Versionen von Browsern ausgestattet, weshalb der Browsererkennungscode ständig überprüft werden muss, damit die neuen Browser unterstützt werden. Individuelle Implementierungen für jeden einzelnen Browser können sich als extrem kompliziert herausstellen.
• Viele Browser unterstützen die Möglichkeit zur Änderung des User-agent-Strings, was die korrekte Browsererkennung zu einer schwierigen Aufgabe macht.

Apple Safari* und Google Chrome* bauen auf WebKit auf, und Opera wird mit seinem Browser bald folgen. Internet Explorer 10 baut NICHT auf WebKit auf; sowohl WebKit als auch IE 10 sind jedoch auf die Document Object Model (DOM) Level 3 Core Spezifikation aufgesetzt. Informationen zu den Standards in Zusammenhang mit Touch-Ereignissen finden Sie in Touch Events Version 1 des Standards mit Stand Januar 2013.

IE 10 hat seine eigenen Touch-Schnittstellen, die zur Verarbeitung von Touch-Ereignissen aufgerufen werden müssen. Verwenden Sie das Objekt navigator mit der Eigenschaft userAgent, um herauszufinden, ob der Browser die gewünschten Funktionen unterstützt. Das folgende Beispiel zeigt auf, dass es sich bei dem Browser um Internet Explorer handelt.

Verwendung:

[javascript]
<script type="text/JavaScript">
If (navigator.userAgent.indexOf(“MSIE”)>0)
    { 
         // Run custom code for Internet Explorer.
    }
</script>
[/javascript]

Abb. 1. Snippet zur Ermittlung, ob es sich bei dem Browser um Internet Explorer* handelt

Verwenden Sie die Methode hasFeature, um herauszufinden, ob der Browser bestimmte Funktionen unterstützt. So lässt sich beispielsweise ermitteln, ob ein Browser Touch-Ereignisse unterstützt (dies funktioniert ebenfalls für IE 10):

[javascript]
var touchSupported = document.implementation.hasFeature("touch-events","3.0");
[/javascript]

Hierbei ist „touch-events“ die Funktion, auf die wir überprüfen, und „3.0“ ist das DOM Spezifikations-Level, an dem wir interessiert sind. Eine App kann auf die folgenden Touch-Ereignisse hören: touchstart, touchend, touchmove und touchcancel.

Um Touch-Ereignisse mit einem WebKit-basierten Browser (wie Chrome oder Safari) zu verarbeiten, konfigurieren Sie einfach die folgenden drei Ereignisse für die wichtigsten Eingabestatus:

[javascript]
canvas.addEventListener( ‘touchstart’, onTouchStart, false );
canvas.addEventListener( ‘touchmove’, onTouchMove, false);
canvas.addEventListener( ‘touchend’, onTouchEnd, false);
[/javascript]

Referenzieren Sie für Internet Explorer stattdessen das Ereignis MSPointer:

[javascript]
canvas.addEventListener( ‘MSPointerDown’, onTouchStart, false );
canvas.addEventListener( ‘MSPointerMove’, onTouchMove, false);
canvas.addEventListener( ‘MSPointerUp’, onTouchEnd, false);
[/javascript]

Gleichermaßen gibt es Listener für Gestenereignisse. Für andere Browser als IE 10 sind dies gestureStart, gestureChange und gestureEnd.

Internet Explorer 10 und seine Kompatibilität mit Windows 7

IE 10 baut zwar nicht auf WebKit auf, ist jedoch auf die DOM Level 3 Events, HTML5 und Progress Event Standards aufgesetzt. Hier erfahren Sie mehr über IE 10 und seine Interaktion mit Windows 7.

Internet Explorer 10 auf Windows 7 verarbeitet Touch- und Stifteingaben als simulierte Mauseingaben für die folgenden Document Object Model (DOM) Ereignisse:

• MSPointerCancel
• MSPointerDown
• MSPointerMove
• MSPointerOver
• MSPointerUp

IE 10 auf Windows 7 spricht auf die folgenden DOM Gestenereignisse NICHT an:

• MSGestureChange
• MSGestureEnd
• MSGestureHold
• MSGestureStart
• MSGestureTap
• MSManipulationStateChanged

Tabelle 5.Touch-Schnittstellen für Internet Explorer* 10

Ermittlung der Touch-Fähigkeit

Egal ob es sich bei einer App um eine native App oder eine Web-App handelt – eine Überprüfung der Touch-Fähigkeit der Hardware sollte implementiert werden, damit die App ihre UI korrekt konfigurieren kann. Es gibt folgende Methode zur Überprüfung der Touch-Fähigkeit.

Windows 7 und Windows 8 Desktop

Für Windows 7 oder Windows 8 Desktop entwickelte Apps können GetSystemMetrics mit SM_DIGITIZER als Argument aufrufen. Das folgende Code-Snippet stammt aus einem Touch-Beispiel, das von der Intel Developer Zone heruntergeladen werden kann: Touch für Windows Desktop

[cpp]
    // Touch-Unterstützung überprüfen
    // GetSystemMetrics aufrufen, um Touch-Fähigkeit zu ermitteln
    BYTE digitizerStatus = (BYTE)GetSystemMetrics(SM_DIGITIZER);
    // Hardware-Touch-Fähigkeit (0x80); Bereitschaft (0x40)
    if ((digitizerStatus & (0x80 + 0x40)) != 0) //Stack Ready + MultiTouch
{
        RegisterTouchWindow(m_pWindow->GetHWnd(), TWF_WANTPALM);
}
[/cpp]

Abb. 2. Beispiel zur Ermittlung der Touch-Fähigkeit für Windows* 7

Beachten Sie, dass sich mit GetSystemMetrics die maximale Anzahl der verfügbaren Berührungspunkte ermitteln lässt:

[cpp]
	BYTE nInputs = (BYTE)GetSystemMetrics(SM_MAXIMUMTOUCHES);
[/cpp]

Windows 8 (Windows Store-Apps)

Mit der Klasse TouchCapabilities können Sie die Touch-Fähigkeit für Windows Store-Apps ermitteln. Das folgende Code-Snippet finden Sie in dem Code-Beispiel im MSDN, wo seine Verwendung veranschaulicht wird: Eingabe: Beispiel für Gerätefähigkeit.

[cpp]
void SDKSample::DeviceCaps::Touch::TouchGetSettings_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
{
    Button^ b = safe_cast<Button^>(sender);
    if (b != nullptr)
    {
        TouchCapabilities^ pTouchCapabilities = ref new TouchCapabilities();
        Platform::String^ Buffer;

        Buffer = "There is " + (pTouchCapabilities->TouchPresent != 0 ? "a" : "no") + " 
              digitizer present\n";
        Buffer += "The digitizer supports " + pTouchCapabilities->Contacts.ToString() + " 
              contacts\n";

        TouchOutputTextBlock->Text = Buffer;
    }
}
[/cpp]

Abb. 3. Beispiel zur Ermittlung der Touch-Fähigkeit für Windows*UI

Web-Apps

Verwenden Sie für Internet Explorer die Eigenschaft msMaxTouchPoints wie im Folgenden beschrieben:

Überprüfung der Touch-Fähigkeit der Hardware:
If (navigator.msMaxTouchPoints) {…}

Überprüfung der Multi-Touch-Fähigkeit der Hardware:
If (navigator.msMaxTouchPoints >1) {…}

Ermittlung der maximalen Anzahl der von der Hardware unterstützten Berührungspunkte:
Var touchPoints = navigator.msMaxTouchPoints;

Verwenden Sie für Chrome und Safari Folgendes (wie oben, aber maxTouchPoints anstatt msMaxTouchPoints):

[javascript]
var result = navigator.maxTouchPoints;
[/javascript]

Die generische Überprüfung auf Touch-Geräte aus Web-Apps kann sich als fehlerbehaftet erweisen. Einige Funktionen laufen zwar fehlerfrei auf einigen Browsern, jedoch zeigen andere fälschlicherweise Touch-Fähigkeit an. Mit anderen Worten, wenn der Browser selbst Touch unterstützt, wird möglicherweise angezeigt, dass Touch-Fähigkeit besteht, selbst wenn das Gerät Touch nicht unterstützt.

Beachten Sie, dass MaxTouchPoints in IE 10 (Desktop) auf Windows 7 „0“ ausgibt.

UI-Design für touchfähige Ultrabook Geräte

Für Ultrabook Geräte entwickelte Apps müssen eventuell Gesten wie Tippen, Verschieben, Zoomen usw. verarbeiten. Touchfähige Apps stellen möglicherweise mit den Zeigerrohdaten wenig an und geben sie lediglich an die Gestenerkennung weiter.

Neue Anwendungen sollten unter der Annahme entwickelt werden, dass Touch die primäre Eingabemethode ist. Unterstützung für Maus und Stylus erfordern keinen Mehraufwand. Softwareentwickler sollten allerdings beim Design touchoptimierter Apps einige weitere Faktoren berücksichtigen.

Tabelle 6.Überlegungen bei touchfähigen Apps

Softwareentwickler sollten bei Interaktionen für geeignetes visuelles Feedback sorgen, damit Benutzer damit vertraut werden, wie ihre Interaktionen von der App und dem Betriebssystem interpretiert werden und sich darauf einstellen können. Visuelles Feedback ist für Benutzer wichtig, damit sie den Erfolg ihrer Interaktionen beurteilen und ihr Gefühl der Kontrolle verbessern können. So können Fehler vermieden werden, und der Benutzer lernt den Umgang mit dem System und dem Eingabegerät.

Ressourcen für die Entwicklung von Touch-Anwendungen

Verwandte Artikel in der Intel Developer Zone:

1. Methodenvergleich bei der Touch-Codierung – Touch-Beispiel für Windows 8 Desktop
2. Touch-Beispiele für Windows* 8 Apps
3. Touch-Code-Beispiel für Windows* 8 Store
4. Touch-Code-Beispiel für Windows* 8 Desktop
5. Portierung von Win32 Apps auf Windows 8 Desktop
6. Echtzeitstrategiespiel mit Touchscreen

Verwandte Artikel im MSDN

1. Programmierleitfaden für Windows 7 Touch Input
2. Architekturübersicht (Windows 7)
3. Fehlerbehebung bei Anwendungen
4. Hinzufügen von Manipulations-Unterstützung bei nicht verwaltetem Code
5. Touch-Beispiele für Windows
6. Entwicklung ausgeklügelter Touch-Apps in Windows 8* (Video)
7. Windows 8 SDK
8. Eingabe: Testbeispiel für Touch-Treffer
9. Dokumentation für die Entwicklung von Desktop-Apps (Windows)
10. Übersicht Windows Touch-Gesten (Windows)
11. Erste Schritte mit Windows Touch-Meldungen (Windows)
12. Funktion Get PointerTouchInfo (Windows)
13. (MSDN) Internet Explorer 10 Guide for Developers

Zusammenfassung

App-Entwickler, die touchfähige Apps entwickeln möchten (entweder native oder Web-Apps), müssen sich im Klaren darüber sein, welche APIs sie potenziell nutzen können. In diesem Leitfaden wurden die Schnittstellen beschrieben, die es für die folgenden Umgebungen gibt: Windows 7, Windows 8 Desktop, Windows Modern UI sowie Apps, die in Webbrowsern laufen. Gesten und Manipulationen sind in Windows 7 zwar möglich; für den App-Entwickler können sich jedoch die Windows 8 APIs (speziell für Desktop und/oder Modern UI) als die bessere Lösung für die automatische Gestenerkennung erweisen.

App-Entwickler, die touchfähige Web-Apps programmieren, müssen ihren Code auf IE 10 überprüfen, da IE 10 seine eigene Schnittstelle besitzt, die zur Verarbeitung von Touch, Gesten und Manipulation verwendet werden muss. Andere Webkit-basierte Browser basieren ebenfalls auf den DOM Level 3 Standards und unterstützen Touch- und Gestenereignisse.

Darüber hinaus wurden in diesem Leitfaden gängige Gesten- und Manipulations-Interaktionen beschrieben und Hilfestellung bei der Entwicklung touchfähiger Apps geleistet.

Zur Autorin

Gael Hofemeier arbeitet als Evangelist Application Engineer bei der Intel Corporation. Sie verfasst hauptsächlich technische Inhalte, die Entwickler bei der Programmierung von Software für die Intel® Architektur benötigen. Zudem moderiert sie das Business Client Forum in der Intel Developer Zone.

Lesen Sie Gaels Blog-Autorenseite

Intel, das Intel-Logo, Ultrabook und Core sind Marken der Intel Corporation in den USA und anderen Ländern.

Copyright © 2013 Intel Corporation. Alle Rechte vorbehalten.

*Andere Marken oder Produktnamen sind Eigentum der jeweiligen Inhaber.