JumpList Klasse

Definition

public ref class JumpList sealed : System::ComponentModel::ISupportInitialize

[System.Windows.Markup.ContentProperty("JumpItems")]
public sealed class JumpList : System.ComponentModel.ISupportInitialize

[System.Windows.Markup.ContentProperty("JumpItems")]
[System.Security.SecurityCritical]
public sealed class JumpList : System.ComponentModel.ISupportInitialize

[<System.Windows.Markup.ContentProperty("JumpItems")>]
type JumpList = class
    interface ISupportInitialize

[<System.Windows.Markup.ContentProperty("JumpItems")>]
[<System.Security.SecurityCritical>]
type JumpList = class
    interface ISupportInitialize

Public NotInheritable Class JumpList
Implements ISupportInitialize

Vererbung

Object

JumpList

Attribute

ContentPropertyAttribute SecurityCriticalAttribute

Implementiert

ISupportInitialize

Beispiele

Das folgende Beispiel zeigt eine Anwendung mit einer Sprungliste. Die Anwendung verfügt über drei Schaltflächen, mit denen Sie der aktuellen Sprungliste eine Aufgabe hinzufügen, den Inhalt der Sprungliste löschen und eine neue Sprungliste auf die Anwendung anwenden können.

Das folgende Beispiel zeigt, wie ein JumpList Markup deklariert wird. Die JumpList enthält zwei JumpTask Verknüpfungen und eine JumpPath. Das Anwenden der JumpPath Shell schlägt fehl, wenn die Anwendung nicht registriert ist, um die Dateinamenerweiterung .txt zu verarbeiten.

<Application x:Class="JumpListSample.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             StartupUri="MainWindow.xaml">
    <JumpList.JumpList>
        <JumpList ShowRecentCategory="True"
                  ShowFrequentCategory="True"
                  JumpItemsRejected="JumpList_JumpItemsRejected"
                  JumpItemsRemovedByUser="JumpList_JumpItemsRemovedByUser">
            <JumpTask Title="Notepad" 
                      Description="Open Notepad." 
                      ApplicationPath="C:\Windows\notepad.exe"
                      IconResourcePath="C:\Windows\notepad.exe"/>
            <JumpTask Title="Read Me" 
                      Description="Open readme.txt in Notepad." 
                      ApplicationPath="C:\Windows\notepad.exe"
                      IconResourcePath="C:\Windows\System32\imageres.dll"
                      IconResourceIndex="14"
                      WorkingDirectory="C:\Users\Public\Documents"
                      Arguments="readme.txt"/>
            <JumpPath Path="C:\Users\Public\Documents\readme.txt" />
        </JumpList>
    </JumpList.JumpList>
</Application>

Das folgende Beispiel zeigt die CodeBehind-Seite für App.xaml. Dieser Code behandelt die JumpItemsRejected Und-Ereignisse JumpItemsRemovedByUser .

using System.Text;
using System.Windows;
using System.Windows.Shell;

namespace JumpListSample
{
    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
    public partial class App : Application
    {
        private void JumpList_JumpItemsRejected(object sender, System.Windows.Shell.JumpItemsRejectedEventArgs e)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendFormat("{0} Jump Items Rejected:\n", e.RejectionReasons.Count);
            for (int i = 0; i < e.RejectionReasons.Count; ++i)
            {
                if (e.RejectedItems[i].GetType() == typeof(JumpPath))
                    sb.AppendFormat("Reason: {0}\tItem: {1}\n", e.RejectionReasons[i], ((JumpPath)e.RejectedItems[i]).Path);
                else
                    sb.AppendFormat("Reason: {0}\tItem: {1}\n", e.RejectionReasons[i], ((JumpTask)e.RejectedItems[i]).ApplicationPath);
            }

            MessageBox.Show(sb.ToString());
        }

        private void JumpList_JumpItemsRemovedByUser(object sender, System.Windows.Shell.JumpItemsRemovedEventArgs e)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendFormat("{0} Jump Items Removed by the user:\n", e.RemovedItems.Count);
            for (int i = 0; i < e.RemovedItems.Count; ++i)
            {
                sb.AppendFormat("{0}\n", e.RemovedItems[i]);
            }

            MessageBox.Show(sb.ToString());
        }
    }
}

Das folgende Beispiel zeigt das Markup zum Erstellen der Benutzeroberfläche der Anwendung.

<Window x:Class="JumpListSample.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Jump List Sample" Height="240" Width="500">
    <Window.Resources>
        <Style TargetType="Button">
            <Setter Property="Width" Value="200" />
            <Setter Property="Margin" Value="5" />
        </Style>
    </Window.Resources>
    <Grid>
        <StackPanel>
            <Button Content="Add Task to JumpList" Click="AddTask" />
            <Button Content="Clear Jump List" Click="ClearJumpList"/>
            <Button Content="Set New Jump List" Click="SetNewJumpList" />
        </StackPanel>
    </Grid>
</Window>

Das folgende Beispiel zeigt die CodeBehind-Seite für MainWindow.xaml. Dieser Code veranschaulicht, wie Sie einen JumpList prozeduralen Code ändern, löschen und erstellen. Für die neue Sprungliste wird die statische SetJumpList-Methode aufgerufen, um die JumpList der aktuellen Anwendung zuzuordnen und die JumpList auf die Windows Shell anzuwenden.

using System;
using System.IO;
using System.Windows;
using System.Windows.Shell;

namespace JumpListSample
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }
        private void AddTask(object sender, RoutedEventArgs e)
        {
            // Configure a new JumpTask.
            JumpTask jumpTask1 = new JumpTask();
            // Get the path to Calculator and set the JumpTask properties.
            jumpTask1.ApplicationPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.SystemX86), "calc.exe");
            jumpTask1.IconResourcePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.SystemX86), "calc.exe");
            jumpTask1.Title = "Calculator";
            jumpTask1.Description = "Open Calculator.";
            jumpTask1.CustomCategory = "User Added Tasks";
            // Get the JumpList from the application and update it.
            JumpList jumpList1 = JumpList.GetJumpList(App.Current);
            jumpList1.JumpItems.Add(jumpTask1);
            JumpList.AddToRecentCategory(jumpTask1);
            jumpList1.Apply();
        }
        private void ClearJumpList(object sender, RoutedEventArgs e)
        {
            JumpList jumpList1 = JumpList.GetJumpList(App.Current);
            jumpList1.JumpItems.Clear();
            jumpList1.Apply();
        }
        private void SetNewJumpList(object sender, RoutedEventArgs e)
        {
            //Configure a new JumpTask
            JumpTask jumpTask1 = new JumpTask();
            // Get the path to WordPad and set the JumpTask properties.
            jumpTask1.ApplicationPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "write.exe");
            jumpTask1.IconResourcePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "write.exe");
            jumpTask1.Title = "WordPad";
            jumpTask1.Description = "Open WordPad.";
            jumpTask1.CustomCategory = "Jump List 2";
            // Create and set the new JumpList.
            JumpList jumpList2 = new JumpList();
            jumpList2.JumpItems.Add(jumpTask1);
            JumpList.SetJumpList(App.Current, jumpList2);
        }
    }
}

Hinweise

Die Windows 7 Taskleiste bietet erweiterte Funktionen zum Starten von Programmen direkt über die Taskleistenschaltfläche mithilfe von Sprunglisten. Sprunglisten werden auch im Windows 7 Startmenü verwendet. Sie greifen auf eine Sprungliste zu, indem Sie mit der rechten Maustaste auf eine Taskleistenschaltfläche oder auf den Pfeil neben einem Programm im Startmenü klicken. Weitere Informationen zu Sprunglisten finden Sie im Abschnitt Taskbar abschnitt der Windows Benutzeroberflächeninteraktionsrichtlinien.

Die JumpList-Klasse stellt einen verwalteten Wrapper für die Funktion "Sprungliste" in der Taskleiste Windows 7 bereit und verwaltet die an die Windows Shell übergebenen Daten. Die funktionalität, die von der klasse JumpList verfügbar gemacht wird, ist in Versionen von Windows früher als Windows 7 nicht verfügbar. Anwendungen, die die Klasse JumpList verwenden, werden in anderen Versionen von Windows ausgeführt, die Sprungliste ist jedoch nicht verfügbar. Weitere Informationen zur Windows Shell und systemeigenen Sprunglisten-APIs finden Sie unter Taskbar Extensions.

Die folgende Abbildung zeigt die Sprungliste für Windows Media Player mit Elementen in den Kategorien Tasks und Frequent.

Windows Media Player Sprungliste

Konfigurieren einer Sprungliste

Sprunglisten können zwei Arten von Elementen enthalten, a JumpTask und a JumpPath. A JumpTask ist ein Link zu einem Programm und ein JumpPath Link zu einer Datei. Sie können Elemente in einer Sprungliste visuell trennen, indem Sie ein JumpTask Element erstellen, das nicht über ein Title und CustomCategory angegebenes Element verfügt. Diese leere JumpTask Wird als horizontale Linie in der Sprungliste angezeigt.

Sprungelemente werden in Kategorien in der JumpList. Standardmäßig wird eine JumpItem in der Kategorie "Aufgaben " angezeigt. Alternativ können Sie eine CustomCategory für die JumpItem.

Sie können angeben, ob die Standardkategorien "Zuletzt verwendet " und " Häufig " in der JumpList Kategorie angezeigt werden, indem Sie die ShowRecentCategory Einstellungen und ShowFrequentCategory Eigenschaften festlegen. Der Inhalt dieser Kategorien wird von der Windows Shell verwaltet. Da diese Kategorien möglicherweise einen Großteil derselben Daten enthalten, zeigen Sie in der Regel eine oder die andere in Ihrem JumpList, aber nicht beides an. Windows verwaltet automatisch zuletzt verwendete Elemente, wenn sie über ein allgemeines Dateidialogfeld geöffnet werden oder zum Öffnen einer Anwendung über die Dateitypzuordnung verwendet werden. Wenn über die Sprungliste auf ein Element zugegriffen wird, können Sie die Windows Shell benachrichtigen, um das Element zur Kategorie Recent hinzuzufügen, indem Sie die methode AddToRecentCategory aufrufen.

Anwenden einer Sprungliste auf die Windows Shell

Sie können nicht direkt auf die Sprungliste der Shell zugreifen oder deren Inhalt in der JumpList Klasse lesen. Stattdessen stellt die klasse JumpList eine Darstellung einer Sprungliste bereit, mit der Sie arbeiten können, und wenden Sie dann auf die Windows Shell an. In der Regel erstellen Sie eine JumpList App, und legen sie einmal fest, wenn die Anwendung zum ersten Mal ausgeführt wird. Sie können die JumpList Laufzeit jedoch ändern oder ersetzen.

Wenn Sie die eigenschaften JumpList festgelegt haben, müssen Sie die JumpList auf die Windows Shell anwenden, bevor der Inhalt in der Taskleisten-Sprungliste angezeigt wird. Dies erfolgt automatisch, wenn die JumpList erste Anfügen an eine Anwendung entweder in XAML oder in einem Aufruf der SetJumpList Methode erfolgt. Wenn Sie den Inhalt der JumpList zur Laufzeit ändern, müssen Sie die methode Apply aufrufen, um den aktuellen Inhalt auf die Windows Shell anzuwenden.

Festlegen einer Sprungliste in XAML

A JumpList wird nicht automatisch an ein Application Objekt angefügt. Sie fügen ein JumpList Objekt in XAML mithilfe der Syntax der angefügten Eigenschaft an ein Application Objekt an. Die JumpList Klasse implementiert die ISupportInitialize Schnittstelle zur Unterstützung der XAML-Deklaration einer .JumpList Wenn die JumpList in XAML deklariert und an die aktuelle Application angefügt ist, wird sie automatisch auf die Windows Shell angewendet, wenn die JumpList initialisiert wird.

Festlegen und Ändern einer Sprungliste im Code

Sie fügen ein JumpList Objekt in Code an, Application indem Sie die statische SetJumpList Methode aufrufen. Dies gilt auch für die JumpList auf die Windows Shell.

Um eine JumpList Laufzeit zu ändern, rufen Sie die GetJumpList Methode auf, um die JumpList aktuell angefügte Methode abzurufen Application. Nachdem Sie die Eigenschaften des JumpList geändert haben, müssen Sie die methode Apply aufrufen, um die Änderungen auf die Windows Shell anzuwenden.