Nicht erst mit seiner neuesten Version hat sich der Office SharePoint Server im Webbereich als äußerst flexibles Allround-Werkzeug etabliert und ist entsprechend weit verbreitet. Trotzdem pflegen nicht wenige Entwickler ihre Vorurteile gegenüber der Anwendung, etwa: SharePoint ist eh nur ein System zum Verwalten von Listen!
Dass die Realität weit von dem entfernt ist, zeigt Ihnen MSDN im Rahmen der kostenlosen TechTalk-Roadshow, die im März wieder in fünf Städten Station macht. MSDN-Experte Tom Wendel gibt dabei einen umfassenden Einblick in den Funktionsumfang des neuen SharePoint 2010 und zeigt aus Entwicklersicht, wo überall Sie bei der Anwendung selbst Hand anlegen können, um dem SharePoint zu vollem Potential zu verhelfen.
Daten/Locations:
Details und Anmeldung unter: http://www.microsoft.com/germany/msdn/techtalk/aktuell2/default.mspx
Jetzt wird es richtig spannend.
“Conferences just don't get any better than this-announcing Windows Phone 7
Join us at MIX10 and be among the first to learn how to build applications and games for Windows Phone 7. We'll introduce you to the development platform, show you how to work with the Windows Phone 7 development tools, and give you a tour of the Windows Phone Marketplace. All MIX10 attendees will receive access to the Windows Phone 7 development tools and have access to a dedicated track on the Windows Phone 7 platform that runs throughout the event.
MIX10 attendees will get exclusive free developer support for the Windows Phone 7 development tools. Don't miss this unique opportunity to be among the first to learn about Windows Phone 7.
REGISTER NOW FOR MIX10
The ONLY way to learn about Windows Phone 7 is to register now for MIX10-we've even extended the special discount on registration through February 21st-you have less than a week to take advantage of this $200 discount.
Don't wait! This is absolutely your last chance to receive this discount. “
Ich bin dort, wer noch?
TheOliver
Vor wenigen Minuten wurde der Weltöffentlichkeit zum ersten mal “Windows Phone 7 Series” vorgestellt: Microsofts neue mobile Plattform der nächsten Generation. Integrierte Benutzerkonzepte, aggregierte Informationen aus unterschiedlichen Quellen, einfach zusammengefasst und bedienbar für den Benutzer.
Die offizielle Homepage, inklusive eines sehr guten Simulators, heißt: http://www.windowsphone7series.com/
Den offiziellen deutschen Blog zu diesem Thema findet man ab sofort hier: http://blogs.msdn.com/windowsphone/
Weitere Informationen über die Entwicklerstory wird es auf der MIX’10 in Las Vegas im März und parallel hier in diesem Blog geben.
Es wird extrem spannend. Ich freu mich.
Gleich zwei heiße Top-Themen präsentiert die aktuelle Ausgabe von msdn tv: wir gehen der Frage nach, was Windows 7 und Bob Dylan gemeinsam haben und präsentieren Mitglieder der Microsoft-Community, die erstmals vor der Kamera auspacken. Aber der Reihe nach: im Interview mit Moderator Jan Schenk informiert diesmal MSDN-Experte und Windows-Entwickler Oliver Scheer unter trickreicher Zuhilfenahme sogenannter CueCards über einige interessante Features von Windows 7 und über Ressourcen, die jeder Developer kennen sollte. Beispiel: das Windows API Code Pack.
In den Kurznachrichten gibt’s Infos zum Windows 7 Developer Center, zur neuesten Version der Microsoft-Vortragssammlung Webcast DVD Edition 2009, zur frisch gelaunchten Übersicht über die deutschsprachigen Microsoft Social Media Angebote auf dem Web-Portal „Community Guide“, zum Imagine Cup Wettbewerb 2010 und einem wichtigen Termin, den Verwender des Release Candidate von Windows 7 beachten sollten.
Schließlich bedanken sich noch drei Gewinner des Expression Studio Gewinnspiels vom Herbst letzten Jahres per Video für die übersandten Preise. Ach so – wegen Bob Dylan: Die Vorlage zum CueCard-Video stammt aus dem Jahr 1965 und ist hier anzuschauen.
MSDN - das Microsoft Developer Network - unterstützt Entwickler mit einem reichhaltigen Angebot von Online- und Offline-Services und liefert mit seinem umfangreichen Know-how-Fundus effiziente Hilfe, wenn es um Fragen der Anwendungsprogrammierung auf Basis von Microsoft-Produkten und -Technologien geht. Angefangen beim .NET Framework, den verschiedenen .NET-Sprachen und der Entwicklungsumgebung Visual Studio, über Windows und Webprogrammierung, bis hin zur Entwicklung für mobile Plattformen bietet Ihnen MSDN Online genug Treibstoff, um Ihre Probleme und Fragen hinter sich zu lassen und Ihre Ziele schnell zu erreichen. Natürlich auch zu neuen Themen und Technologien wie Windows 7, Cloud Computing, Silverlight oder Multicore-Programmierung. Lesen Sie auch gerne, was die deutschsprachige Wikipedia über uns schreibt: MSDN auf Wikipedia Mit MSDN Online möchten wir Ihnen unter der Internetadresse www.msdn-online.de grundsätzlich eine umfangreiche Grundversorgung anbieten. Dort, wo wir Ihnen einen extra Service oder die Extraportion Know-how anbieten, bemühen wir uns dies natürlich kostenfrei für Sie zu realisieren. So sind 99.5% aller unserer Online-Angebote kostenfrei nutzbar.
Mehr Infos: http://msdn-online.de/willkommen
Der Release Candidate (RC) von Visual Studio 2010, die letzte Vorabversion vor der Produktveröffentlichung am 12. April 2010, steht nun allen Interessierten in den kommenden Editionen als öffentlicher Download zur Verfügung. Zum Wochenbeginn hatten bereits Inhaber einer MSDN Subscription exklusiven Zugriff auf die – gegenüber der früheren Vorabversion Beta 2 dank umfassenden Kundenfeedbacks immens beschleunigte – Entwicklungsumgebung gehabt. Die ausschließlich englischsprachig verfügbaren Vorabversionen verfügen weiterhin über eine „Go Live“-Lizenz, die den produktiven Einsatz bereits heute erlaubt. Zeitgleich zu Visual Studio 2010 hat auch das grundlegende .NET Framework 4, in den Visual Studio 2010-Installationen bereits enthalten, den RC-Status erreicht und ist von MSDN Online auch separat herunterladbar. Download: Visual Studio 2010 (RC) und .NET Framework (RC) Visual Studio General Manager Jason Zander bittet die geneigten Tester der Release Candidates ein weiteres Mal um ihr wertvolles Feedback und stellt in einem Channel 9-Interview die jüngste Entstehungsgeschichte der Release Candidates vor. Tagesaktuelle Nachrichten rund um Visual Studio finden Sie auch im Visual Studio Developer Center auf MSDN. Im MSDN Forum zu Visual Studio können Sie sich mit der Community austauschen und in der MSDN Mediathek finden Sie zahlreiche weitere Multimediainhalte zu Visual Studio 2010: MSDN Mediathek
Verwandte Links:
MSDN Library zu Visual Studio 2010
Microsoft Surface
Heute habe ich mir für das Video des Tages Unterstützung von unserem User Experience-Evangelisten Clemens Lutsch geholt. Er ist ein Experte auf dem Gebiet der neuartigen Benutzeroberflächen. Er befasst sich seit der ersten Stunde mit Microsoft Surface, einem Tisch, der über eine Oberfläche bzw. eine Tischplatte verfügt, mit der man sämtliche Interaktionen steuern kann. Die gesamte Interaktion wird über grafische Elemente, Bluetooth-fähige Geräte oder aber mit den Händen vorgenommen. Spannend dabei ist, dass man gleichzeitig mit nahezu beliebig vielen Händen und Fingern mit dem Tisch interagieren kann. Ein einfaches Beispiel ist die zeitgleiche Betrachtung von Bildern durch verschiedene Benutzer. Jeder kann Bilder auf dem Tisch ansehen, heranziehen, vergrößern, drehen und sortieren. Im Prinzip fast genauso, wie man es von herkömmlichen Fotoabenden mit Familie und Freunden gewohnt ist. Aber haben sie schon mal versucht ein klassisches Foto auf dem Tisch zu vergrößern, um die Details genauer zu betrachten? Ja, so etwas funktioniert nur mit dem Surface.
Ganz ehrlich, der Surface ist wegen der integrierten Hardware und der enorm wuchtigen Tischplatte, nicht ganz preiswert und derzeit nur über Microsoft direkt zu beziehen – beim Multimedia-Fachhändler um die Ecke steht er also noch nicht zur Verfügung. Allerdings kann ich jedem empfehlen, mal in den O2-Flagship-Store in Köln zu gehen, dort haben Partner von Microsoft eine Lösung für O2 erstellt, die echt „Wow“ ist.
Was hat Surface mit Windows 7 gemeinsam?
Während der Entwicklung von Windows 7 hat man sehr eng mit dem Surface-Team zusammengearbeitet und dieses Know-How in das neue Betriebssystem einfliessen lassen. Das große Geheimnis von Surface ist eigentlich, dass das darunterliegende Betriebssystem „nur“ Windows Vista Business ist, angereichert mit einigen Kameras für die Erkennung der Finger, Hände oder sonstigen Eingabegeräte. Zusätzlich gibt es noch diverse Treiber für die Eingabe sowie Software, die die Oberfläche von Surface ausmacht. Diese Software ist, etwas einfach formuliert, nur WPF (Windows Presentation Foundation) mit speziellen Steuerelementen. Für den „normalen“ Entwickler heißt das, er kann eigentlich sofort für Surface programmieren. Die Entwicklungswerkzeuge sind die gleichen, wie für Silverlight und WPF, nämlich Expression Studio und/oder Visual Studio.
In Windows 7 ist die Möglichkeit eingeflossen, den Computer über den Bildschirm mit Hilfe von Fingern zu steuern. Es gibt bereits eine Vielzahl von Computern und Notebooks, die sich mit einem Finger steuern lassen. Darüber hinaus gibt es derzeit schon eine überschaubare Anzahl von Computern, die sich schon mit zwei oder mehreren Fingern gleichzeitig steuern lassen. Wieviele gleichzeitige Eingaben unterstützt werden, ist von der Display-Hardware und damit vom Hersteller direkt abhängig.
Was hat man unter Windows 7 von Multitouch?
Eine nette Anekdote zum Thema Multitouch: Die Steuerelemente auf der Taskleiste sind wesentlich größer geworden. Der Grund dafür liegt in der natürlichen Beschaffenheit von menschlichen Fingern. Haben SIe schon einmal probiert, die kleinen Symbole der Windows Vista- oder Windows XP-Oberfläche in der Taskleiste mit dem Finger präzise zu treffen? Selbst mit einem Stift (von Tablet PCs) ist das eher ein Geschicklichkeitsspiel als ein präzises Arbeiten. Jetzt lassen sich die neuen Steuerelemente auch einfach mit dem Finger treffen und steuern.
Anwendungen, die die Basisfunktionen aus dem Betriebssystem unterstützen, wie z.B. das Vergrößern und Verkleinern, sind bereits sehr gut für Mutlitouch ausgelegt. Durch das auseinanderziehen zweier Fingern kann man beliebige Dokumente, die diese Funktion unterstützen, vergrößern oder verkleinern. Hinzu kommt die Fähigkeit der Anwendungen, natürliches Feedback zu geben, gelangt man z.B. an das Ende eines Dokumentes, so „bounced“ dieses (Bouncen heißt so viel wie „kurz über das Ziel hinausfahren und wieder zurückzukommen“). Damit erhält der Benutzer tatsächlich das Gefühl von „Ich bin am Ende des Dokumentes angekommen“. Aber auch die Docking-Funktionen von Windows sind hervoragend auf Multitouch eingestellt: bewegt man ein Fenster mit dem Finger an eine Bildschirmseite, so dockt es dort automatisch an.
Eine andere Anekdote ist, dass sich die Open Source Gemeinde um einen Browser damit rühmt, jetzt auch Multitouch unter Windows 7 zu unterstützen. Leider haben die Kollegen nicht mitbekommen, dass das ein fester Bestandteil von Windows 7 ist und sofort „ohne Code“ von jeder Anwendung automatisch verwendet werden kann.
Es gibt bereits eine Vielzahl von Anwendungen, die Multitouch direkt verwenden. Microsoft selbst liefert ein Beispielpaket aus, das Multitouch Pack, das aus einigen Spielen, Visualisierungsdemonstrationen und Surface Globe besteht. So kann man mit dem Surface Globe sehr leicht die Welt mit den eigenen Fingern erkunden.
Anwender ohne ein Multitouch-fähiges Gerät müssen aber nicht zurückstecken, die Anwendungen lassen sich zumindest starten und größtenteils auch mit der Maus steuern, wenn auch nicht ganz so komfortabel.
Wie kann man nun eigene Multitouch-fähigen Anwendungen entwickeln?
Auf MSDN-Online gibt es dazu einen sehr guten Webcast.
In diesem Webcast zeigt Ihnen Dariusz Parys, wie Sie Anwendungen für Windows 7 multi-touch-fähig machen. Unter anderem erfahren Sie, wie man einen Emulator installiert, um Multi-Touch zu simulieren, welche Gesten standardmäßig in Windows 7 unterstützt werden und wie man eine WPF-Anwendung um Multi-Touch-Funktionalität erweitert.
Link zum Webcast
Weitere technische Dokumentation zur Multitouch-API gibt es hier:
Yochay Kriaty – Multitouch-Funktionen in Windows 7
Heute kommen die Fans des Windows Explorer voll auf ihre Kosten. Er verfügt im Prinzip über alle wichtigen Funktionen, die man für die Navigation durch Ordner, Netze, Dateien, Bibliotheken und Suchen benötigt. Der Windows Explorer ist das Ergebnis jahrelanger Entwicklungsarbeit und spiegelt dabei die Implementierung vieler Bedürfnisse des Standardbenutzers wieder. Wer dennoch Funktionen braucht, die nicht enthalten sind, oder diese gerne auf andere Art und Weise implementieren möchte, darf dies gerne tun.
Die Funktionen des Windows Explorer stehen jedem Entwickler frei zur Verfügung. Dank des Windows API Code Packs lässt sich der Explorer in Windows Forms- oder Windows Presentation Foundation-Anwendungen integrieren.
Die Funktionen und die Visualisierung steht in Form von Steuerelementen direkt in Visual Studio zur Verfügung. Der Name der Steuerelemente ist sowohl in Windows Forms als auch in WPF ExplorerBrowser.
Die Konfiguration ist ebenfalls sehr leicht über das Eigenschaften-Fenster möglich.
Zwei Referenzimplementierungen sind direkt im Windows API Code Pack enthalten. Sie demonstrieren einfach und kompakt die volle Leistungsfähigkeit und sehen dabei sehr technisch aus. Meine Bitte an Sie, bitte bauen sie so etwas nicht, sondern machen sie es dem Benutzer leicht. J
Die WPF-Variante zum Testen der ExplorerBrowser-Funktionen.
Die Windows Forms-Variante zum Testen.
Ein altes Sprichwort sagt: „Wer suchet, der findet.“. Warum lassen wir nicht unsere eigenen Anwendungen suchen? Windows 7 liefert die notwendige Search API dafür mit.
Um die Search API aus .NET-Code ansprechen zu können, ist wirklich nicht viel nötig. Man muss lediglich das Windows API Code Pack einbinden und schon kann in wenigen Zeilen der eigene Suchclient entwickelt werden.
Was man sucht und vor allem wo man sucht, ist jedem Entwickler selbst überlassen. Die Qualität der Suche hängt aber wesentlich von diversen Kriterien ab: So ist es ziemlich sinnlos nach Liedern ihrer Lieblingsband im System-Ordner von Windows zu suchen. Und Bilder vom letzten Firmenfest werden sie nicht in ihren Musikordnern finden. Es sei denn, sie haben eine sehr interessanten Organisationsstil.
Aus gutem Grund bietet die API daher auch die nötigen Konfigurationswerkzeuge für die Suche an. In welchen Typen von Ordner soll gesucht werden? Was für Daten suchen wir? Sollen alle Suchbegriffe oder zumindest ein Suchbegriff im Dokument gefunden werden? Handelt es sich um aktuelle Daten oder vor langer Zeit angelegte Dokumente?
Eine eigene Suchanwendung ist sehr schnell implementiert. Dafür sind lediglich zwei Bibliotheken aus dem Windows API Code Pack notwendig:
Die Methode zum Suchen:
private void StartSearch(string searchText) { // Erzeuge Suchbedingungen SearchCondition searchCondition = GetSearchCondition(searchText); // Datum als weiteres Suchkriterium hinzufügen SearchCondition dateCondition = SearchConditionFactory.CreateLeafCondition( SystemProperties.System.Title, searchText, SearchConditionOperation.ValueContains); // Zusammensetzen der Suchbedingungen SearchCondition finalSearchCondition = SearchConditionFactory.CreateAndOrCondition( SearchConditionType.Or, false, searchCondition, dateCondition);
// Erzeuge einen ShellSearchFolder ShellSearchFolder searchFolder; if (ShellLibrary.IsPlatformSupported) { searchFolder = new ShellSearchFolder( finalSearchCondition, (ShellContainer)KnownFolders.DocumentsLibrary, (ShellContainer)KnownFolders.PicturesLibrary, (ShellContainer)KnownFolders.VideosLibrary); } else { searchFolder = new ShellSearchFolder( finalSearchCondition, (ShellContainer)KnownFolders.Documents, (ShellContainer)KnownFolders.Pictures, (ShellContainer)KnownFolders.Videos); }
// DataList die die Ergebnisse anzeigt _result.ItemsSource = searchFolder; }
Die Methode GetSearchCondition ist folgendermaßen implementiert:
private SearchCondition GetSearchCondition(string searchText) { // Einzelne Suchbegriffe aus dem Textbilden string[] words = searchText.Split(' '); // Das Suchergebnis ist erstmal leer SearchCondition combinedPropertyCondition = null; // Für jedes Word im Suchtext eine Suchbedingung erzeugen foreach (string word in words) { // Erste Suchbedingung --> Suche nach Dateinamen SearchCondition propertyCondition1 = SearchConditionFactory.CreateLeafCondition( SystemProperties.System.FileName, word, SearchConditionOperation.ValueContains); // Zweite Suchbedingung --> Suche nache Keywords/Tags in Datei SearchCondition propertyCondition2 = SearchConditionFactory.CreateLeafCondition( SystemProperties.System.Keywords, word, SearchConditionOperation.ValueContains); // Wir wollen eine Oder-Bedingung für Tags oder Dateiname SearchCondition tmpCombinedCondition = SearchConditionFactory.CreateAndOrCondition( SearchConditionType.Or, false, propertyCondition1, propertyCondition2);
// Falls es bereits eine Suchbedingung gibt,
// verknüpfe die neue und die alten mit AND if (combinedPropertyCondition != null) { combinedPropertyCondition = SearchConditionFactory.CreateAndOrCondition( SearchConditionType.And, false, combinedPropertyCondition, tmpCombinedCondition); } else { combinedPropertyCondition = tmpCombinedCondition; } } return combinedPropertyCondition; }
Die Suche an sich wird über die Klasse ShellSearchFolder ausgeführt. Die Definition der Suchanfrage erfolgt über die SearchConditions. Welche Ordner durchsucht werden sollen, wird mit Hilfe von „KnownFolders“, so genannten bekannten Ordner definiert.
searchFolder = new ShellSearchFolder( finalSearchCondition, (ShellContainer)KnownFolders.DocumentsLibrary, (ShellContainer)KnownFolders.PicturesLibrary, (ShellContainer)KnownFolders.VideosLibrary);
Das Suchergebnis kann man nun visualisieren wie man möchte. Ich habe mich in diesem Beispiel auf eine einfache Liste beschränkt. Im Windows API Code Pack steht dazu eine vollwertige WPF-Visualisierung zur Verfügung.
Meine Programme stürzen nicht ab! Nein ganz bestimmt nicht! Versprochen! Großes Indianer-Ehrenwort!
Aber falls es doch mal passiert, dass eine Anwendung „abstürzt“, bzw. einfach nicht das tut, was man von ihr erwartet, dann kann man das jetzt stilvoll und mit einem automatischen Neustart der Anwendung geschehen lassen. Hierbei hilft die Restart-And-Recovery-API, die bereits in Windows Vista eingeführt und nun in Windows 7 erweitert wurde.
Jeder von uns war bestimmt schon einmal in der Situation, dass er lange an einem Dokument gearbeitet hat bis die Anwendung plötzlich einfach abgestürzt ist. Die Anwendung reagiert einfach nicht mehr und alle Daten sind verloren. Vielleicht haben sie es auch schon einmal gesehen, dass einige Anwendungen nach einem Absturz anbieten, direkt wieder neu zu starten. Und im Startvorgang werden dann die verloren geglaubten Daten wiederhergestellt. Benutzer solcher Anwendungen können sich glücklich schätzen.
Die Anwendung läuft noch ….
Ups, die Anwendung funktioniert nicht mehr.
Und startet sich von selbst neu.
Eine quasi sich selbst regenerierende Anwendung kann jeder mit Hilfe der Restart-And-Recovery-API erstellen. Es sind nur wenige Schritte dazu notwendig:
Schritt 1: Registrieren der Anwendung für einen Restart
private void RegisterForRestart() { ApplicationRestartRecoveryManager.RegisterForApplicationRestart( new RestartSettings("/restart", RestartRestrictions.NotOnReboot | RestartRestrictions.NotOnPatch)); }
Schritt 2: Registrieren der Anwendung für die Wiederherstellung von Daten
private void RegisterForRecovery() { RecoveryData data = new RecoveryData(new RecoveryCallback(RecoveryProcedure), null); RecoverySettings settings = new RecoverySettings(data, 0); ApplicationRestartRecoveryManager.RegisterForApplicationRecovery(settings); }
Schritt 3: Implementieren der Recovery-Methode
private int RecoveryProcedure(object state) { PingSystem();
File.WriteAllText(RecoveryFile, string.Format("{1}{0}{2}{0}{3}", DataSeparatorString, CurrentFile.Filename, CurrentFile.IsDirty, CurrentFile.Contents));
Debug.WriteLine("File path: " + RecoveryFile); Debug.WriteLine("File exists: " + File.Exists(RecoveryFile)); Debug.WriteLine("Application shutting down...");
ApplicationRestartRecoveryManager.ApplicationRecoveryFinished(true); return 0; }
Schritt 4: Prüfen, ob der Benutzer den Restart abgebrochen hat
private void PingSystem() { // Find out if the user canceled recovery. bool isCanceled = ApplicationRestartRecoveryManager.ApplicationRecoveryInProgress();
if (isCanceled) { Console.WriteLine("Recovery has been canceled by user."); Environment.Exit(2); } }
Schritt 5: Daten beim Neustart wiederherstellen
private void RecoverLastSession(string command) { if (!File.Exists(RecoveryFile)) { MessageBox.Show(this, string.Format("Recovery file {0} does not exist", RecoveryFile)); internalLoad = true; textBox1.Text = "Could not recover the data. Recovery data file does not exist"; internalLoad = false; UpdateAppTitle(); return; }
// Perform application state restoration actions here. string contents = File.ReadAllText(RecoveryFile); CurrentFile.Filename = contents.Remove(contents.IndexOf(Form1.DataSeparatorString)); contents = contents.Remove(0, contents.IndexOf(Form1.DataSeparatorString) + Form1.DataSeparatorString.Length); CurrentFile.IsDirty = contents.Remove(contents.IndexOf(Form1.DataSeparatorString)) == "True" ? true : false; contents = contents.Remove(0, contents.IndexOf(Form1.DataSeparatorString) + Form1.DataSeparatorString.Length); CurrentFile.Contents = contents;
// Load our textbox textBox1.Text = CurrentFile.Contents;
// Update the title UpdateAppTitle();
// Reset our variable so next title updates we don't show the "recovered" text recovered = false; }
Schritt 0: Die eigentliche Anwendung
public Form1() { Debug.WriteLine("ARR: Demo started"); InitializeComponent(); UpdateAppTitle(); RegisterForRestart(); RegisterForRecovery();
if (System.Environment.GetCommandLineArgs().Length > 1 && System.Environment.GetCommandLineArgs()[1] == "/restart") { RecoverLastSession(System.Environment.GetCommandLineArgs()[1]); } }
Das vollständige Codebeispiel befindet sich im Windows API Code Pack.
Was ist die Windows 7 Sensor API?
Die Windows 7 Sensor API ist eine neue Programmierschnittstelle für die Steuerung von Sensoren. Bei Sensoren kann es sich um interne und externe Erweiterungen des PCs handeln, die dem Computer Informationen über „äußere“ Zustände vermitteln. Die häufigsten Einsatzszenarien sind derzeit die Erkennung der Umgebungshelligkeit, der Beschleunigung des PCs selbst oder des angeschlossenen Sensors. Darüber hinaus kann man Software-Sensoren erstellen, die bestimmte Werte ermitteln und an die API übergeben und damit unseren Anwendungen bereitstellen.
Was kann man tun, wenn man keine Sensoren installiert hat?
Man muss sich nicht unbedingt einen neuen Rechner mit Sensorhardware kaufen, denn es gibt durchaus Alternativen. Das Windows 7 SDK bringt zum Beispiel einen Sensor für Licht mit. Es handelt es sich um einen Lichtsensor-Emulator, den der User über einen einfachen Schieberegler steuern kann.
Um den Treiber dafür erfolgreich im System zu installieren, muss man wie folgt vorgehen:
Ausführen des virtuellen Lichtsensors
Programmieren mit Sensor API
Die Funktionen, um auf die Sensoren im Computer zugreifen zu können, sind über die SensorManager-Klasse erreichbar. Sie ist Bestandteil des Windows API Code Pack und kann über die darin enthaltene Bibliothek „Sensors“ eingebunden werden.
Um generell erkennen zu können, ob sich an den Sensoren etwas ändert (Aktivierung und Deaktivierung), reicht das Ereignis SensorsChanged. Um zu erkennen, welche Sensoren im System enthalten sind, kann die Methode GetAllSensors verwendet werden. Diese liefert alle Sensoren zurück, die im System derzeit aktiv sind. Jedes zurückgelieferte Objekt ist von der Klasse Sensor abgeleitet.
private void InitSensors() { SensorManager.SensorsChanged += new SensorsChangedEventHandler(SensorManager_SensorsChanged);
foreach (var sensor in SensorManager.GetAllSensors()) { sensor.DataReportChanged += new DataReportChangedEventHandler(sensor_DataReportChanged); sensor.StateChanged += new StateChangedEventHandler(sensor_StateChanged); Debug.WriteLine(sensor.FriendlyName); } }
Um mit einem Lichtsensor zu arbeiten, kann man den AmbientLightSensor verwenden. Dieser verfügt über die Eigenschaft CurrentLuminousIntensity, welche die Intensität in Lux zurückliefert. Darüber kann erkannt werden, ob das aktuelle Umgebungslicht hell oder dunkel ist. Das macht besonders dann Sinn, wenn man in wechselnden Umgebungen arbeitet, wie z.B. im ICE (Tunnel, Sonnenlicht, Bahnhof, usw.). Einige Notebookhersteller haben dafür schon Sensoren im Rechner eingebaut und regeln so die Helligkeit des Bildschirms.
SensorList<AmbientLightSensor> alsList = SensorManager.GetSensorsByTypeId<AmbientLightSensor>( ); int ambientLightSensors = 0;
foreach( AmbientLightSensor sensor in alsList ) { // set intial progress bar value sensor.TryUpdateData( ); float current = sensor.CurrentLuminousIntensity.Intensity; pb.Value = Math.Min( (int)current, maxIntensity );
// Set up automatc data report handling. sensor.AutoUpdateDataReport = true; sensor.DataReportChanged += new DataReportChangedEventHandler( DataReportChanged ); ambientLightSensors++; }
if( ambientLightSensors == 0 ) { // No Sensor found } } catch( SensorPlatformException exc) { // This exception will also be hit in the Shown message handler. }
Das Ereignis DataReportChanged wird immer dann ausgelöst, wenn sich am Sensor etwas verändert. Das geschieht asynchron als Hintergrundprozess und muss daher bei Interaktion mit dem UI-Thread wieder mit diesem synchronisiert werden. Die Umsetzung lässt sich sehr einfach mit der folgenden Ereignisbehandlung realisieren:
void DataReportChanged( Sensor sender, EventArgs e ) { AmbientLightSensor als = sender as AmbientLightSensor; BeginInvoke( new MethodInvoker( delegate { float current = als.CurrentLuminousIntensity.Intensity; } ) ); }
Arbeiten mit Bewegungs- bzw. Beschleunigungssensoren
Inzwischen gibt es auch immer mehr Hardware mit so genannten Bewegungssensoren. Diese erkennen Beschleunigung in den drei Bewegungsachsen. Dadurch ergeben sich ganz neue Möglichkeiten der Steuerung.
Ich selbst habe ein externes Sensorboard der Firma Freescale zu Testzwecken an meinem Rechner. Damit verfügt man quasi über einen Joystick, der eine dreidimensionale Steuerung erlaubt.
Um diesen Sensor anzusprechen, benötigt nicht viel mehr Code als für Lichtsensoren.
Das Auslesen der Daten geschieht ebenfalls im DataReportChanged-Ereignis der SensorManager-Klasse:
void sensor_DataReportChanged(Sensor sender, EventArgs e) { Debug.WriteLine(sender.FriendlyName); if (sender is Accelerometer3D) { Dispatcher.BeginInvoke(new Action(delegate { Accelerometer3D accel = sender as Accelerometer3D; MoveBall(accel.CurrentAcceleration[AccelerationAxis.X], accel.CurrentAcceleration[AccelerationAxis.Y], accel.CurrentAcceleration[AccelerationAxis.Z]); })); } }
Die Methode MoveBall macht nichts anderes als einen Ball um die übergebenen X-,Y- und Z-Koordinaten zu verschieben.
Ein schönes Beispiel ist im Windows API Code Pack enthalten. Dieses visualisiert die aktuelle Beschleunigung des Sensors in X-,Y- und Z-Richtung.
Heute möchte ich eine kleine Zusammenfassung für Entwickler bereit stellen – für jeden der schnell und kompakt eine Übersicht über die vielen kostenfreien Angebote von Microsoft haben möchte.
Die folgenden Webseiten bieten kostenfreie Downloads oder Inhalte an, die von jedem genutzt werden dürfen, die sich gerne mit der Windows-Programmierung und im Besonderen mit Windows 7 befassen möchten.
MSDN Online –Microsoft Developer Network
Was kann man bei MSDN Online finden? Im Prinzip ist die Antwort einfach formuliert: Alles! Im Detail heißt das, dass es dort alles zu unseren Programmiersprachen (Visual Basic, Visual C++, Visual C#), unseren Werkzeugen für Entwickler (Visual Studio, Visual Studio Express, Visual Studio Team System) und unseren Betriebssystemen (Windows Client, Windows Server, Windows Mobile, Windows Embedded) zu finden gibt.
Neben Webcasts und Videos, die von Experten auf ihren Gebieten erstellt wurden, finden sich dort auch viele technische Artikel und Downloads. Man kann sich auf MSDN Online aber auch für Newsletter (http://www.microsoft.com/germany/msdn/flash/default.mspx) und RSS-Feeds (http://msdn.microsoft.com/de-de/bb821267.aspx) registrieren, die in regelmäßigen Abständen über aktuelle Themen informieren.
Außerdem findet man dort seit kurzem das sehr spannende und amüsante MSDN TV. Link: http://www.microsoft.com/germany/msdn/msdntv/default.mspx
Wer mehr über die MSDN Subscription erfahren möchte, ist dort ebenfalls hervorragend aufgehoben. Kurz formuliert handelt es sich dabei um ein Abonnement für sämtliche aktuellen und kommenden Microsoft-Produkte und -Technologien, die man uneingeschränkt als Entwickler für sich verwenden kann. Link: http://msdn.microsoft.com/de-de/subscriptions/default.aspx
Link: http://www.msdn-online.de
Windows 7 Software Development Kit
Beim Microsoft® Windows® SDK handelt es sich um einen Satz von Tools, Codebeispielen, Dokumentationen, Compilern, Headern und Bibliotheken, mit denen Entwickler Anwendungen erstellen können, die unter Microsoft Windows-Betriebssystemen mit systemeigenen (Win32) oder verwalteten (.NET Framework) Programmiermodellen ausgeführt werden.
In den meisten Fällen sollten Sie die neueste Windows SDK-Version verwenden, die mehrere Windows-Betriebssysteme und .NET Framework-Versionen unterstützt
Link: http://msdn.microsoft.com/de-de/windows/bb980924.aspx
Blog des Windows SDK Teams: http://blogs.msdn.com/windowssdk/
Windows API Code Pack for Microsoft .NET Framework
Das Windows API Code Pack for Microsoft .NET Framework bietet eine Quellcodebibliothek an, die es ermöglicht, die neuen Windows 7 Funktionen in .NET-Anwendungen zu verwenden.
Link: http://code.msdn.microsoft.com/WindowsAPICodePack
Windows 7 Training Kit
Das Windows 7 Training Kit beinhaltet Präsentationen, Hands-on-labs und Demos, die dafür entwickelt wurden, die neuen Funktionen von Windows 7 verwenden zu können.
Link: http://www.microsoft.com/downloads/details.aspx?FamilyID=1C333F06-FADB-4D93-9C80-402621C600E7&displaylang=en
Gibt es weitere Quellen habe und die ich vergessen habe? Her damit
1. Windows 7 beinhaltet das .NET Framework 3.5 SP1
Das .NET Framework 3.5 SP1 ist in Windows 7 enthalten. Das sind gute Nachrichten:
2. Visual Studio 2008 funktioniert problemlos mit Windows 7
Ich benutze Visual Studio 2008 zusammen mit Windows 7 auf meinen Notebook und meinem Entwicklungsdesktop und habe keinerlei Probleme. Wie gewohnt, kann man mit Visual Studio 2008 noch .NET 2.0, .NET 3.0 und .NET 3.5 SP1 Anwendungen für andere OS-Versionen, z.B. Windows XP oder Windows Vista, erstellen.
3. Man kann Anwendungen schreiben, die unter Windows XP bis Windows 7 laufen …
und die Features des Gast-Betriebssystems nutzen. Es gibt eine Beispielanwendung „PhotoView“, die demonstriert, wie man eine .NET-Anwendung schreibt, die von XP bis Windows 7 lauffähig ist und die Features der einzelnen Gast-Betriebssysteme optimal ausnutzt. Den Sourcecode und eine Beschreibung der Anwendung gibt’s unter –> http://code.msdn.microsoft.com/XP2Win7.
4. Man kann heute .NET-Anwendungen schreiben, welche die coolen Features von Windows 7 nutzen
In meinen letzten Blogeintrag habe ich die Windows 7 API Code Packs vorgestellt, mit denen man schon heute über Managed Code auf diese Features zugreifen kann –> http://blogs.msdn.com/mtcmuc/archive/2009/08/13/windows-7-codepack-v1-0-released.aspx.
Eine Reihe von weiteren Beispielen, wie man für Windows 7 entwickelt, gibt es auch im Microsoft Windows SDK for Windows 7 and .NET Framework 3.5 SP1 –> http://www.microsoft.com/downloads/details.aspx?FamilyID=c17ba869-9671-4330-a63e-1fd44e0e2505&displaylang=en
5. Powershell ist Bestandteil von Windows 7
Für komplexe administrative Scripts und der Verwendung von Powershell aus Anwendungen haraus ist die Powershell V2.0 Bestandteil von Windows 7.
6. Es gibt einen ausführlichen Windows 7 UX Guide
Als PDF-Download gibt es einen User Interface Design Guide zu Themen wie Bildschirmauflösungen, DPIs, Windows Sizing, Controlausrichtung und Control Spacing, u.v.a.m. –> http://download.microsoft.com/download/e/1/9/e191fd8c-bce8-4dba-a9d5-2d4e3f3ec1d3/ux%20guide.pdf
7. Freie Kapitel aus Windows 7-Büchern
Es gibt einige kostenfreie Kapitel aus den Büchern "Windows 7 Inside Out", "Windows 7 Resource Kit" und "Windows 7 for Developers" zum Download –> http://www.microsoft.com/learning/en/us/offers/windows-7-chapters-thankyou.aspx
8. Windows 7 Trainingskit für Entwickler
Wie in meinem Blogeintrag http://blogs.msdn.com/mtcmuc/archive/2009/07/08/schnelleinstieg-in-die-windows-7-entwicklung-mit-dem-windows-7-trainingskit.aspx berichtet, gibt es ein Windows 7 Training Kit für Entwickler. Dieses Kit liegt nun in Version 1.0.1 vor und kann unter –-> http://www.microsoft.com/downloads/thankyou.aspx?familyId=1c333f06-fadb-4d93-9c80-402621c600e7&displayLang=en heruntergeladen werden.
9. Deutsche Windows 7 Developer Tipps
Auf http://msdn.microsoft.com/de-de/windows/dd433113.aspx gibt es viele neue Artikel, HowTo Guides, die erste Schritte auf dem neuen Betriebssystem, aber auch komplexere Windows 7-Programmierthemen ansprechen.
Die Multifunktionsleiste wurde neu in Windows 7 integriert und entspricht nahezu der Multifunktionsleiste von Office 2007. Nahezu bedeutet dabei, dass sie konsequent weiterentwickelt wurde.
Windows 7 und die Multifunktionsleiste
Die Multifunktionsleiste ist in einige Klassiker eingeflossen: Paint und WordPad. Schade ist, dass sie es nicht auch in Notepad geschafft hat.
Die Multifunktionsleiste ist ebenso in Windows Live Movie Maker integriert worden. Dieser läuft auch unter Windows Vista und zeigt, dass die Multifunktionsleiste auch auf Vista verfügbar sein wird.
Entwickeln mit der Multifunktionsleiste
Windows 7 führt ein neues natives API für Multifunktionsleisten-basierte Oberflächen ein. Dieses API ist COM-basiert. Das API wird in Zukunft auch für Windows Vista verfügbar sein und nahezu den gleichen Funktionsumfang wie die Office 2007-Multifunktionsleiste haben.
Um als Entwickler die Multifunktionsleiste verwenden zu können, benötigt man das Windows 7 SDK (Link). Im SDK finden Sie unter anderem die Header-Datei (UIRibbon.h), die den Zugriff auf die Multifunktionsleiste bietet.
Die Programmierung der Multifunktionsleiste teilt sich in zwei Bereiche auf: Im Deklarationsteil werden die verschiedenen Elemente, wie z.B. Tabreiter, Gruppierungen oder Kommandos, deklariert und ihr Aussehen beschrieben. Diese Beschreibung kann mit XAML (Extensible Markup Language) geschrieben werden. Die Ausführung der Kommandos und das Wechseln in verschiedene Zustände wird über C++-Code beschrieben, der die Darstellung mit der Anwendungslogik verknüpft, der eigentlichen Anwendungslogik.
Dadurch erhält man eine starke Separation in Model, Sicht und Controller, die den Code und das Markup entkoppelt. Die gesamte C++-API dazu ist sehr kompakt gehalten. Sie ist auf Kommandos fokussiert und nicht auf Steuerelemente oder Darstellungsdetails.
Welche Steuerelemente bringt die Multifunktionsleiste mit
Die Multifunktionsleiste verfügt über ein sehr großes Repertoire an Steuerelementen, die wir bereits aus Paint, WordPad und dem Windows Live Movie Maker her kennen.
Eine Funktion die nicht direkt in der Multifunktionsleiste integriert ist, sondern an beliebigen Stellen in der Anwendung verwendet werden kann, ist das erweiterte Kontextmenü. In WordPad erscheint dies leicht transparent, wenn man einen Text markiert. Darüber kann man dann zum Beispiel den selektierten Text formatieren. Diese Funktion erspart dem Benutzer, größere Strecken mit der Maus zurückzulegen und somit seinen aktuellen Fokus (den Text) zu verlassen.
Markup der Multifunktionsleiste
Der Markup-Code für die Multifunktionsleiste unterteilt sich in zwei Bereiche: Command-Sektion und Views-Sektion.
Die Command-Sektion beinhaltet die einzelnen Command-Elemente: einen Referenznamen, ein Label, eine eindeutige ID, ein Bild (BMP) und einen Tooltip.
<?xmlversion="1.0" encoding="utf-8"?> <Applicationxmlns='http://schemas.microsoft.com/windows/2009/Scenic/Intent'> <Application.Commands> <CommandName='Home' LabelTitle='Home'/> <CommandName='HomePage' LabelTitle='HomePage'> <Command.LargeImages> <ImageSource='res/HomePageHH.bmp'/> </Command.LargeImages> </Command> </Application.Commands>
Die Views-Sektion legt die Organisation der Kommandos in Tabs, Gruppen, Quick Access-Toolbar und Anwendungsmenü fest. Sie bestimmt außerdem, welches Steuerelement für welches Kommando verantwortlich ist.
<Application.Views> <Ribbon> <Ribbon.Tabs> <Tab CommandName='Home'> <Group CommandName='GoHomePage' SizeDefinition='OneButton'> <Button CommandName='HomePage'/> </Group> </Tab> </Ribbon.Tabs> </Ribbon> </Application.Views> </Application>
Die Multifunktionsleiste unterstützt zwei Arten von “Sichten”: die Multifunktionsleisten-Sicht und die kontextuelle UI-Sicht. Die kontextuelle UI-Sicht bietet ein reicheres Kontextsystem als bisherige Kontextmenüs.
Da es sich bei der Multifunktionsleiste um eine native API handelt, muss aus der XAML-Datei erst einmal eine native Ressource erstellt werden. Dies geschieht mit einem Tool aus dem Windows SDK: UICC.exe. Dieses generiert aus der XAML-Datei eine Ressource, die man wiederum in seine Anwendung einbinden kann und dadurch die Multifunktionsleiste als nativen Code vorliegen hat.
UICC.exe konvertiert XAML in ein binäroptimiertes Format und erstellt eine .rc-Datei, welche den binären “blob” mit den verwendeten Ressourcen enthält. Man sollte einen benutzerdefinierten Build-Step für die Erstellung der .rc-Datei mittels UICC.exe in sein Projekt einbauen, damit dieses automatisch während des Erstellens geschieht. Eine .h-Datei, die die #defines für die diversen Command-IDs enthält, wird ebenfalls generiert.
Anwendungsmodi
Durch Anwendugsmodi lässt sich die Darstellung von Elementen an den aktuellen Anwendungszustand koppeln, denn nicht immer soll alles sichtbar sein. In Microsoft Paint wird z.B. der Text-Tab nur angezeigt wenn man Text bearbeitet. Ansonsten wird diese Funktion nicht benötigt. Im Markup-Code definiert man die Anwendungsmodi, in denen die Elemente sichtbar sein sollen. Der Anwendungsmodus wird auf untergeordnete Steuerelemente automatisch vererbt.
<Button CommandName='Paste' ApplicationModes='1,3'/>
Im Code kann man den Modus durch die Funktion IUIFrameworkSetModes ändern.
Die API-Interfaces im Überblick
Codebeispiel: Initialisierung
IUIFramework* g_pFramework = NULL; ::CoCreateInstance(CLSID_UIMultifunktionsleisteFramework, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&g_pFramework)); CComObject<CApplication> *pApp = NULL; CComObject<CApplication>::CreateInstance(&pApp); CComPtr<IUIApplication> spApp(pApp); g_pFramework->Initialize(hWindowFrame, spApp); g_pFramework->LoadUI(GetModuleHandle(NULL), L"APPLICATION_Multifunktionsleiste");
Codebeispiel: Behandeln von Ereignissen
class CApplication : public CComObjectRootEx<CComMultiThreadModel>, public IUIApplication, public IUICommandHandler { public: BEGIN_COM_MAP(CApplication) COM_INTERFACE_ENTRY(IUIApplication) COM_INTERFACE_ENTRY(IUICommandHandler) END_COM_MAP()
...
STDMETHOD(OnSichtChanged)(UINT32 nSichtID, __in UI_SichtTYPE typeID, __in IUnknown* pSicht, UI_SichtVERB verb, INT32 uReasonCode) { return E_NOTIMPL; } STDMETHOD(OnCreateUICommand)(UINT32 nCmdID, __in UI_COMMANDTYPE typeID, __deref_outIUICommandHandler** ppCmdHndlr) { return QueryInterface(IID_PPV_ARGS(ppCmdHndlr)); } STDMETHOD(OnDestroyUICommand)(UINT32 commandId, __in UI_COMMANDTYPE typeID, __in_optIUICommandHandler* pCommandHandler) { return E_NOTIMPL; } STDMETHODIMP Execute(UINT nCmdID, UI_EXECUTIONVERB verb, __in_opt const PROPERTYKEY* key, __in_opt const PROPVARIANT* ppropvarValue, __in_optIUISimplePropertySet* pCmdExecProps) { if (verb == UI_EXECUTIONVERB_EXECUTE && nCmdID == HomePage) MessageBox(NULL, L"Clicked on HomePagebtn”, L"HomePage Button Execute“, MB_OK); return S_OK; } STDMETHODIMP UpdateProperty(UINT nCmdID, __in REFPROPERTYKEY key, __in_opt const PROPVARIANT* ppropvarCurrentValue, __out PROPVARIANT* ppropvarNewValue) { if (key == UI_PKEY_Enabled && nCmdID == HomePage && m_bPressed) { return UIInitPropertyFromBoolean( UI_PKEY_Enabled, FALSE, ppropvarNewValue); } return E_NOTIMPL; }
Ein vollständiges Beispiel befindet sich im Windows 7 SDK (Link).
Die Taskleiste in Windows 7 hat eine lange Geschichte hinter sich.
Geschichte der Taskleiste
In Windows 1 gab es die Taskleiste noch nicht, es gab lediglich einfache Symbole am unteren Rand. Man konnte die Symbole noch nicht einmal verschieben. Aber der Kenner weiß, dass bereits in dieser Version das „Docking“ der Fenster von Microsoft erfunden wurde. Dieses Feature ist zwar in folgenden Versionen verschwunden, aber in Windows 7 „wieder auferstanden“.
In Windows 2.x konnte man Anwendungen mit Hilfe des Program Managers starten. Man hangelte sich dabei durch verschiedene Fenster, die innerhalb des Program Managers geöffnet und geschlossen werden konnten. Um schneller auf Anwendungen zugreifen zu können, konnte man bereits „Shortcuts“ auf den Desktop legen.
In Windows 95 hielt die Taskleiste und der Start-Knopf Einzug. Erstmals wurden ausgeführte Anwendungen als Symbole in der Taskleiste angezeigt und konnten darüber hinaus minimiert, maximiert und geschlossen werden. Darin hat sich bis zum heutigen Tage auch wenig verändert.
In Windows XP wurde die komplette Taskleiste in ein neues Design überführt.
Mit Windows Vista kam zum ersten Mal die Möglichkeit auf, innerhalb des Startmenüs nach Programmen und Funktionen zu suchen bzw. die Suche über den gesamten Computer zu starten. Dieses Feature wurde auch nötig, da die Programmflut im Startmenü dank vieler Zeitschriften mit CD-Beilagen ins Unermessliche gestiegen war ;)
In Windows 7 wurde Taskleiste visuell sehr „vereinfacht“ und mit vielen neuen Funktionen erweitert. Gestartete Programme werden in der gleichen Leiste angezeigt wie Verknüpfungen. Lediglich das Aussehen unterscheidet nun zwischen den verschiedenen Status der Anwendung.
Bei diversen Benutzerumfragen wurden folgende Fakten festgestellt:
Die Ziele für die Entwicklung der neuen Taskleiste sind daher wie folgt definiert worden:
Terminologie und Funktionen der neuen Taskleiste
Taskleisten-Schaltflächen Jede Anwendung, jedes Ziel und jede Verknüpfung wird durch ein Symbol auf der Taskleiste dargestellt. Gestartete bzw. geöffnete Anwendungen und Ziele werden als Schaltfläche dargestellt. Sind mehrere Instanzen ein und derselben Anwendungen geöffnet, werden diese kaskadierend dargestellt. Dies kann aber über die Eigenschaften der Taskleiste nach eigenen Wünschen verändert werden.
Die Schaltflächen lassen sich sehr vielseitig anpassen. Folgende Möglichkeiten hat der Benutzer:
Damit hat man die Möglichkeit den Status der Anwendung innerhalb der Startleiste zu visualisieren. Folgende Szenarien wären denkbar: Läuft die Anwendung, behält sie das normale Symbol. Muss der User eine Interaktion durchführen, lässt man das Symbol pulsieren, liegt ein Problem vor, zeigt man zum Beispiel ein rotes Kreuz an.
Sprunglisten, Ziele und Aufgaben Jedes Symbol in der Taskleiste hat eine so genannte Sprungliste. Innerhalb dieser Sprungliste gibt es Elemente die jede Anwendung besitzt: Öffnen, Alle Fenster schließen und an die Taskleiste heften bzw. von dieser entfernen. Darüber hinaus kann eine Sprungliste noch zusätzliche Dinge anzeigen. Ist eine Anwendung z.B. mit einem bestimmten Dateityp assoziiert, wie z.B. Word mit Doc-Dateien, dann werden diese automatisch unter „Zuletzt verwendet“ in der Sprungliste angezeigt. Möchte man dort vielleicht ein Dokument immer wieder öffnen, so kann man dies „anheften“. Dadurch steht es solange in dieser Liste, bis man es wieder entfernt. Diese Funktionen stehen jeder Anwendung sofort aus dem Stand zur Verfügung, ohne dass dazu Code notwendig ist. Zusätzlich lassen sich innerhalb der Sprungliste aber auch noch Aufgaben integrieren. Das können beliebige Tätigkeiten sein. Der Windows Live Messenger macht es vor und bietet die folgenden Aufgaben an: MSN Startseite anzeigen, Postfach öffnen, Sofortnachricht senden, Online, Offline, Abwesend, usw. Das neue Outlook 2010 bietet ähnliche Funktionalitäten, so kann man über die Sprungliste sofort eine Email erstellen, einen Termin planen, direkt den Kalender aufrufen, u.v.m. Wenn man dieses Feature einmal verwendet hat, möchte man es nicht mehr missen.
Thumbnail-Toolbars Ein weiteres neues Feature sind die Thumbnail-Toolbars. Als gutes Beispiel geht der Windows Media Player voran. Geht man mit der Maus über das Symbol des laufenden Mediaplayers, sieht man das aktuelle Video oder Musikcover und zusätzlich die Möglichkeit den Player zu starten, ein Element zurück- oder eines vorzuspringen. Dadurch lässt sich der Player direkt aus der Startleiste steuern, ohne dass man ihn erst einmal in den Vordergrund holen muss.
Auch die Darstellung der Vorschau in der Taskleiste ist individuell anpassbar. Man hat in der Startleiste und deren Vorschau ja nicht beliebig viel Platz. Daher kann man die Darstellung in der Vorschau nach eigenen Wünschen gestalten und nur das Wesentliche anzeigen lassen.
Verwendung von Managed Code
Die einfachste Art und Weise, um auf die Funktionen der Taskleiste zuzugreifen ist das Windows API Code Pack (http://code.msdn.microsoft.com/WindowsAPICodePack). Dieses wurde bereits vor einigen Tagen vorgestellt. Bindet man dieses in sein eigenes Projekt ein, kann man direkt auf die Funktionen der Taskleiste zugreifen.
Um beispielsweise ein Overlay-Symbol über dem Anwendungssymbol einzublenden, ist der folgende Code notwendig.
windowsTaskbar.SetOverlayIcon(this.Handle, TaskbarDemo.Properties.Resources.Yellow, "Yellow");
Dabei wird auf ein Bild zugegriffen, das im Projekt als Ressource mit dem Namen “Yellow” eingebunden wurde.
Möchte man die zuletzt verwendeten Dokumente in der Sprungliste anzeigen, reicht dieser Code.
jumpList.KnownCategoryToDisplay = JumpListKnownCategoryType.Recent;
Oder
jumpList.KnownCategoryToDisplay = JumpListKnownCategoryType.Frequent;
Möchte man den Fortschritt der Anwendung in der Taskleiste darstellen, ist dieser Code ausreichend.
TaskbarManager.Instance.SetProgressValue(trackBar1.Value, 100);
Was sind Sprunglisten?
Bei den Sprunglisten handelt es sich um eine neue Funktionalität, die es ermöglicht, dem Anwendungssymbol zusätzliche Funktionen hinzuzufügen. Einfach auf dem Symbol die rechte Maustaste drücken und schon erscheint die Sprungliste. Standardmäßig sind die Funktionen zum Öffnen, Schließen und Anheften enthalten. Wenn die Anwendung die Funktionen „Zuletzt verwendete Dokumente“ und „Häufig verwendete Dokumente“ unterstützt, so werden diese Dokumente ebenfalls direkt in der Sprungliste angezeigt. Diese Liste der Dokumente kann für eigene Anwendungen sehr leicht angepasst werden.
Für einen einfachen Zugriff empfiehlt sich die Verwendung des Windows API Code Pack (Link kommt hier rein). Verwendet man diese Bibliothek, dann lässt sich die Liste der Dokumente über die folgenden Zeilen Code steuern:
private JumpListCustomCategory category1 = new JumpListCustomCategory("Custom Category 1");
// Add shell item to custom category String path = “mydocument.txt”; category1.AddJumpListItems(new JumpListItem(path));
Möchte man eine eigene Aufgabe zur Taskleiste hinzufügen, die dafür sorgt, dass ein bestimmtes Programm geöffnet wird, so geht dies mit den folgenden Zeilen Code.
// Path to Windows system folder string systemFolder = Environment.GetFolderPath(Environment.SpecialFolder.System);
// Add our user tasks jumpList.AddUserTasks(new JumpListLink(Path.Combine(systemFolder, "notepad.exe"), "Open Notepad") { IconReference = new IconReference(Path.Combine(systemFolder, "notepad.exe"), 0) }); jumpList.AddUserTasks(new JumpListLink(Path.Combine(systemFolder, "mspaint.exe"), "Open Paint") { IconReference = new IconReference(Path.Combine(systemFolder, "mspaint.exe"), 0) }); jumpList.AddUserTasks(new JumpListSeparator()); jumpList.AddUserTasks(new JumpListLink(Path.Combine(systemFolder, "calc.exe"), "Open Calculator") { IconReference = new IconReference(Path.Combine(systemFolder, "calc.exe"), 0) });
Externe Tools für Sprunglisten
Wer gerne Schnellzugriff auf frei konfigurierbare Tools haben möchte, dem kann ich den Jumplist-Launcher empfehlen. Ein kostenfreies Tool, das es hier (Link: http://www.ali.dj/jumplist-launcher/) gibt. Damit lassen sich bis zu 60 Programme frei in der Jumplist konfigurieren.
Das Windows API Code Pack for Microsoft .NET Framework ist eine .NET-Bibliothek für die Nutzung einiger der neuen Windows 7-Features sowie Funktionen aus älteren Betriebssystemen. Diese Bibliothek beinhaltet Funktionen, die so heute noch in keinem .NET Framework enthalten sind. Die nächste Version des .NET Framework wird große Teile dieser Bibliothek übernehmen, allerdings dauert das noch eine Weile. Leider kann aber wegen des Open Source-Charakters momentan keine hundertprozentige Gewährleistung gegeben werden, dass die Bibliotheken im .NET Framework genauso aussehen werden, wie im Code Pack.
Das tolle an diesen Bibliotheken ist, dass sie im Quellcode vorliegen und so von jedem erweitert werden können. Dadurch erhält man die Sicherheit, dass die eigenen Anwendungen auch noch mit späteren Versionen des .NET Framework funktionieren werden.
Wo bekommt man das Code Pack her?
Alle notwendigen Ressourcen können in einer einzelnen Datei heruntergeladen werden. Der Download ist hier verfügbar: http://code.msdn.microsoft.com/WindowsAPICodePack
Das Code Pack gibt es derzeit in der Version 1 und enthält die folgenden Bestandteile:
Die Anforderungen des Code Pack
Erstellen und Verwenden der Bibliothek
Um die Bibliothek zu erstellen (ausgenommen die DirectX betreffenden Features), benötigt man Visual Studio 2008. Der gesamte Inhalt des Pakets „WindowsAPICodePack.zip“ sollte dafür in einen neuen Ordner entpackt werden. Darin enthalten ist die Datei „WindowsAPICodePack.sln“, die die gesamte Lösung beinhaltet.
Für das Erstellen der DirectX-Features wird“DirectX.sln“ innerhalb des DirectX-Verzeichnisses benötigt. Eine genauere Beschreibung der Anforderungen ist in der einer Hilfedatei im selben Ordner beschrieben
Welche Beispiele sind im Code Pack enthalten?
Das Code Pack beinhaltet neben den Bibliotheken auch einige Beispielanwendungen, die sofort lauffähig sind, um die Verwendung erfolgreich zu demonstrieren. Jedes Beispiel ist sowohl in C# also auch in Visual Basic .NET verfügbar.
Konkret enthalten sind Beispiele für Explorer-, Netzwerk-, Ribbon-, Startleiste-, Sensor- und Dialog-Bibliotheken.
Microsoft bringt für jede Version von Windows ein besonderes Kit für die Entwicklung von Anwendungen heraus. Dieses steht Interessierten kostenfrei zur Verfügung: Das Windows Software Development Kit.
Beim Microsoft Windows SDK handelt es sich um einen Satz von Tools, Codebeispielen, Dokumentationen, Compilern, Headern und Bibliotheken, mit denen Entwickler Anwendungen erstellen können, die unter Windows-Betriebssystemen mit systemeigenen (Win32) oder verwalteten (.NET Framework) Programmiermodellen ausgeführt werden.
Natürlich gibt es dieses SDK auch für Windows 7. Je nach Funktionsumfang ist es zwischen 300 KB und 4 GB groß. Daher kann die Installation je nach Netzwerkverbindung auch mal etwas länger dauern. Im SDK findet sich für jeden Entwickler einiges an hilfreichen Codebeispielen und Werkzeugen für den eigenen Werkzeugkasten.
Hier an der Stelle noch mal der sehr wichtiger Hinweis: Das Windows SDK ist ein Kit an Software-Entwicklungshilfen. Es ist teilweise sehr komplex und umfangreich. Da die Dokumentation teilweise direkt von den Entwicklern kommt, sind alle Bestandteile ausnahmslos im Englisch gehalten. Wäre es ganz einfach, dann könnte es ja jeder ;).
Möchte man sehen, welche Version des SDKs für welches Betriebssystem installiert ist, kann man das mit dem Configuration Tool ermitteln und einstellen. Ein wichtiger Einstiegspunkt ist die Dokumentation die mitgeliefert wird.
Wer behauptet, dass sich von Windows Vista zu Windows 7 nicht viel getan hat, der darf sich gerne die folgende Liste mit neuen und erweiterten APIs auf der Zunge zergehen lassen:
Einige davon, definitiv nicht alle, werden wir hier noch genauer vorstellen.
Was befindet sich im SDK?
Im SDK befinden sich Beispielanwendungen auf „Hallo Welt“-Niveau für erste Schritte in bestimmten Bereichen bis hin zu sehr komplexen Beispielen, die die Technologien tiefer demonstrieren.
Tools für Managed Code
Tools für Native (Win32 und COM) Entwicklung
Tools für beide Welten
Weitere Werkzeuge, die man aus dem SDK nach installieren kann
Das Windows SDK wird pro Version übrigens mehr als eine Millionen mal heruntergeladen. Das Team besteht aus 25 Personen und wer könnte da besser das Video des Tages liefern als die Program Managerin Lori Pearce
Weiterführende Links
Teamblog der Windows SDK Entwickler: http://blogs.msdn.com/windowssdk/
Download-Link für das Windows 7 SDK: http://www.microsoft.com/downloads/details.aspx?FamilyID=c17ba869-9671-4330-a63e-1fd44e0e2505&displaylang=en
Als Fan von Windows Sidebar-Gadgets stößt man unter 64-Bit-Versionen von Windows schnell auf bestimmte Probleme. Dieser Blogeintrag beschreibt, wie man als Benutzer und Entwickler am besten damit umgehen kann.
Grundsätzlich sind Gadgets (bzw. Miniaturanwendungen) nicht anderes als HTML-Anwendungen. Damit die Sidebar diese Anwendungen darstellen kann, wird der installierte Internet Explorer von Windows verwendet. Auf einem 64-Bit System ist dies automatisch der Internet Explorer in der 64-Bit Version. Dies gilt explizit nur für die Sidebar.
Klickt man auf einen Link in einer Email, oder ruft auch sonst irgendeinem Grund den Internet Explorer auf, so startet standardmäßig der Internet Explorer in der 32-Bit-Version. Nachteile entstehen dem Benutzer dadurch absolut nicht. Einzige Ausnahme bildet hier die Sidebar, diese verwendet automatisch den 64-Bit Internet Explorer, wenn man mit einer 64-Bit Version von Windows arbeitet.
Das hat nun zur Folge, dass Sidebar-Gadgets auch die 64-Bit-Variante verwenden. Leider stellen die wenigsten Hersteller von Browsererweiterungen ihre Plug-Ins in 32- und 64-Bit-Versionen zur Verfügung. Ganz ehrlich, es gibt quasi fast keine 64-Bit-Erweiterungen für 64-Bit Browser. Das liegt vielleicht unter anderem daran, dass außer Microsoft kein Browserhersteller aktuell eine 64-Bit Version eines Browsers für Windows geliefert hat. Weder Google Chrome, noch der Firefox, stehen in einer 64-Bit Version für Windows 64-Bit-Versionen zur Verfügung.
Silverlight und Flash stehen ebenfalls nicht in 64-Bit-Version zur Verfügung. Sie lassen sich dennoch ohne Probleme auf einem 64-Bit-System installieren, keine Sorge. Alles läuft wie gewohnt. Bis auf die Sidebar.
Hat man nun eine Windows 64-Bit Version und verwendet ein Gadget, das auf Flash oder Silverlight basiert bekommt man die Gadgets wie auf dem folgenden Bild dargestellt:
Ich habe hier testweise das Channel9-Gadget verwendet.
Wie kann man nun dieses Problem beheben?
Die Sidebar.exe, die Anwendung die für die Darstellung der Gadgets zuständig ist, gibt es auch in zwei Versionen: 32- und 64-Bit.
Einmal im Ordner C:\Program Files\Windows Sidebar.
Und ein weiteres Mal im Ordner C:\Program Files (x86)\Windows Sidebar.
Um nun seine Silverlight- oder Flash-Gadgets in auf einem 64-Bit System darstellen zu können muss lediglich die 32-Bit-Variante von sidebar.exe beim Starten von Windows aufgerufen werden. Dies geschieht am besten über die Autostart-Funktion von Windows.
Einfach einen Shortcut in den Order C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Startup hinzufügen, der die Siderbar.exe aus dem Ordner: C:\Program Files (x86)\Windows Sidebar\sidebar.exe verlinkt.
Anschließend wird die Sidebar im 32-Bit-Modus gestartet und verwendet den Internet Explorer in der 32-Bit-Version.