Jumplist

Die Jumplist  ist ebenfalls ein neues Feature, das mit Windows 7 eingeführt wurde. Unter einer Jumplist versteht man ein Kontextmenü, das eingeblendet wird, wenn der Anwender mit der rechten Maustaste auf ein TaskBar Symbol klickt. Die Jumplist soll den Start einer Anwendung beschleunigen, indem sie zum Beispiel eine Liste der zuletzt verwendeten Dateien anzeigt oder eine Anwendung mit bestimmten Parametern startet.
Es ist aber genau so gut möglich, über die Jumplist einer Anwendung auch andere Programme zu starten. Alles, was der Entwickler tun muss, ist eine neue JumpList zu erzeugen und dieser Liste Objekte vom Typ JumpListLink hinzuzufügen. Mit etwas Geschick kann man sich das anzuzeigende Icon direkt aus der Anwendung selbst holen.

JumpList list = JumpList.CreateJumpList();
list.ClearAllUserTasks();

string systemFolder = Environment.GetFolderPath(Environment.SpecialFolder.System);

list.AddUserTasks(
        new JumpListLink(System.IO.Path.Combine(systemFolder, "calc.exe"),
        "Rechner öffnen")
{
        IconReference =
        new IconReference(System.IO.Path.Combine(systemFolder, "calc.exe"), 0)
});


list.AddUserTasks(
        new JumpListLink(System.IO.Path.Combine(systemFolder, "mspaint.exe"),
        "Paint öffnen")
{
        IconReference =
        new IconReference(System.IO.Path.Combine(systemFolder, "mspaint.exe"), 0)
});
list.Refresh();

Es ist wichtig, die Jumplist erst dann zu erzeugen, wenn die Anwendung schon ein geladenes Fenster hat. In einer WPF Anwendung bietet sich dafür die Methode Window_Loaded an. Versucht man hingegen die JumpList schon im Konstruktor des Fensters zu erstellen, ist das wenig erfolgreich und führt zu einem Programmabbruch.

Ein auf diese Art erstellte Jumplist bleibt erhalten, nachdem die Anwendung beendet wurde. Sie können das sehr leicht selbst ausprobieren, indem Sie die von Visual Studio erstellte Anwendung an der TaskBar anheften und anschliessend beenden. Wenn Sie nun auf mit der rechten Maustaste auf das Symbol klicken, wird die Jumplist wieder dargestellt. Wählen Sie jetzt den Eintrag "Paint öffnen", wird das Programm Paint gestartet. Die zur Jumplist gehörende Anwendung bleibt allerdings weiterhin geschlossen. Man könnte also auch über Jumplisten Schnellstart Funktionen für Programme verwirklichen, indem man eine Anwendung entwickelt, die nichts anderes tut, als eine Jumplist zur Verfügung zu stellen.

Etwas ungewöhnlich sind in diesem Beispiel auch die Zuweisung der Symbole zu den Einträgen. Diese werden nicht wie gewohnt als Icon, sondern als IconReference erzeugt, denn sie werden tatsächlich von den anderen Anwendung geholt. Möchte man das Symbol des eigenen Programms anzeigen, ist ein etwas anderer Weg nötig.

IconReference =
new IconReference(Assembly.GetEntryAssembly().Location, 0);

In der Regel will man mit einer Jumplist aber nicht fremde, sondern die eigene Anwendung mit bestimmten Parametern starten. Dafür ist es zunächst nötig, einen JumpListLink zu erzeugen, der auf die eigenen Anwendung verweist.

string myExecutablePath = Assembly.GetEntryAssembly().Location;
JumpListLink myJumpLink = new JumpListLink(myExecutablePath, "Befehl A ausfhren");

myJumpLink.IconReference =
new IconReference(Assembly.GetEntryAssembly().Location, 0);
myJumpLink.Arguments ="Command-A";
list.AddUserTasks(myJumpLink);
list.Refresh();

Wird später auf diesen JumpListLink geklickt, startet das Programm mit dem Commandozeilenparameter "Command-A". Diesen Parameter kann man in der main-Methode der Anwendung auswerten und dann entsprechend darauf reagieren.

[STAThread]
public static void Main()
{
        string[] args = Environment.GetCommandLineArgs();
        if (args.Count() > 1)
        {
                if (args[1] == "Command-A")
                {
                        MessageBox.Show("Command-A");
                }
        }
//...

Aber Achtung! Wird bei einer schon laufenden Anwendung erneut auf diesen Link geklickt, ist es wahrscheinlich, dass sich eine weitere Instanz der Anwendung öffnet. Das ist nicht immer im Sinne des Entwicklers und mit einem einfachen Mutex kann verhindert werden, dass mehrere Instanzen einer Anwendung gleichzeitig ausgeführt werden können. Wichtig ist, dass der Mutex statisch und ausserhalb der Main-Methode angelegt wird.

static Mutex mutex = new Mutex(false, "Win7ApiDemo");

[STAThread]
public static void Main()
{
        if (!mutex.WaitOne(TimeSpan.FromMilliseconds(500), false))
        {
                MessageBox.Show("Ein andere Instanz läuft schon");
        return;
}

//...

Es ist durchaus möglich mit einer Jumplist auch Funktionen in einer schon gestarteten Anwendung auszuführen. Dazu muss aber zuerst ermittelt werden, ob schon eine Instanz dieser Anwendung läuft, und die Anweisungen werden dann entsprechend durchgereicht. Zwei Verfahren wie so etwas funktionieren könnte finden Sie unter den folgenden Links.
 
http://www.codeproject.com/KB/statusbar/Clipz.aspx

http://www.developer.com/net/article.php/10916_3850661_2/Creating-Windows-7-Jump-Lists-With-The-API-Code-Pack-and-Visual-Studio-2008.htm
 
Um etwas mehr Ordnung in die Jumplist zu bekommen ist es möglich, eigene Kategorien zu erzeugen und dort dann JumpListItem einzufügen. 

string myExecutablePath = Assembly.GetEntryAssembly().Location;
 
JumpListCustomCategory personalCategory
= new JumpListCustomCategory("Persnliche Kategorie");
list.AddCustomCategories(personalCategory);
 
JumpListLink myJumpLinkA =
new JumpListLink(myExecutablePath, "Befehl A ausfhren");
myJumpLinkA.IconReference =
new IconReference(Assembly.GetEntryAssembly().Location, 0);
myJumpLinkA.Arguments ="Command-A";
personalCategory.AddJumpListItems(myJumpLinkA);
 
JumpListLink myJumpLinkB = new JumpListLink(myExecutablePath, "Befehl B ausfhren");
myJumpLinkB.IconReference =
new IconReference(Assembly.GetEntryAssembly().Location, 0);
myJumpLinkB.Arguments ="Command-B";
personalCategory.AddJumpListItems(myJumpLinkB);
 
list.Refresh();

Eine weitere nützliche Eigenschaft einer Jumplist ist die Möglichkeit, die zuletzt verwendeten Dateien der Anwendung anzuzeigen. Auf diesem Wege kann das Programm gestartet werden und erhält gleichzeitig Informationen darüber, welche Datei es anschliessend laden soll. Diese Liste wird natürlich nicht automatisch verwaltet, sondern ist Aufgabe des Entwicklers.
Um das ganze noch weiter zu verkomplizieren, funktioniert es nicht mit beliebigen Dateien, sondern nur mit solchen Typen, die auch für die Anwendung registriert wurden. Mehr Informationen über den etwas komplexen Vorgang der Registrierung finden Sie auch in der Beispielen des Windows 7 API Code Pack. Die von Microsoft zur Verfügung gestellten Klassen erledigen diese Aufgabe perfekt.
Sind alle Hürden genommen, können Dateien mit nur eine einzelnen Anweisung der Jumplist hinzugefügt werden.

list.AddToRecent("c:\test1.txt");

Wird später auf diesen Eintrag geklickt, findet sich die zu ladenden Datei wieder in der Commandozeilenparametern. 
 
Falls Ihnen dieser Vorgang zu kompliziert erscheint, können Sie sicherlich im einer persönlichen Kategorie das gleiche Resultat mit weniger Aufwand erreichen.

nächste Seite