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 sie im Markup deklarieren JumpList . Enthält JumpList zwei JumpTask Links und einen JumpPath. Das Anwenden von JumpPath auf die Shell schlägt fehl, wenn die Anwendung nicht für die Verarbeitung der .txt Dateinamenerweiterung registriert ist.

<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 Ereignisse und 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, das zum Erstellen der Benutzeroberfläche der Anwendung verwendet wird.

<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 in prozeduralem Code ändern JumpList , löschen und erstellen. Für die neue Sprungliste wird die statische SetJumpList Methode aufgerufen, um der JumpList aktuellen Anwendung zuzuordnen und auf JumpList 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 Startmenü von Windows 7 verwendet. Sie greifen auf eine Sprungliste zu, indem Sie mit der rechten Maustaste auf eine Taskleistenschaltfläche klicken oder im Startmenü auf den Pfeil neben einem Programm klicken. Weitere Informationen zu Sprunglisten finden Sie im Abschnitt Taskleiste der Richtlinien für die Interaktion mit der Windows-Benutzeroberfläche.

Die JumpList -Klasse stellt einen verwalteten Wrapper für die Jump List-Funktionalität in der Windows 7-Taskleiste bereit und verwaltet die an die Windows-Shell übergebenen Daten. Die von der JumpList -Klasse verfügbar gemachte Funktionalität ist in Windows-Versionen vor Windows 7 nicht verfügbar. Anwendungen, die die JumpList -Klasse verwenden, werden in anderen Versionen von Windows ausgeführt, aber die Sprungliste ist nicht verfügbar. Weitere Informationen zur Windows-Shell und nativen Sprunglisten-APIs finden Sie unter Taskleistenerweiterungen.

Die folgende Abbildung zeigt die Sprungliste für Windows Media Player mit Elementen in den Kategorien Aufgaben und Häufig .

Windows Media Player-Sprungliste

Konfigurieren einer Sprungliste

Sprunglisten können zwei Arten von Elementen enthalten: und JumpTask .JumpPath Ein JumpTask ist ein Link zu einem Programm und ein JumpPath ist ein Link zu einer Datei. Sie können Elemente in einer Sprungliste visuell trennen, indem Sie ein JumpTask erstellen, das nicht über und CustomCategoryTitle angegeben ist. Diese leere JumpTask wird als horizontale Linie in der Sprungliste angezeigt.

Sprungelemente werden in Kategorien JumpListin platziert. Standardmäßig wird in der Kategorie Aufgaben ein JumpItem angezeigt. Alternativ können Sie für CustomCategory angeben JumpItem.

Sie können angeben, ob die Standardkategorien Zuletzt verwendet und Häufig im JumpList angezeigt werden, indem Sie die ShowRecentCategory Eigenschaften und ShowFrequentCategory festlegen. Der Inhalt dieser Kategorien wird von der Windows-Shell verwaltet. Da diese Kategorien einen Großteil der gleichen Daten enthalten können, zeigen Sie in der Regel die eine oder die andere in Ihrer JumpListan, aber nicht beide. Zuletzt verwendete Elemente werden von Windows automatisch verwaltet, wenn sie über ein allgemeines Dateidialogfeld geöffnet 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 der Kategorie Zuletzt verwendet hinzuzufügen, indem Sie die AddToRecentCategory -Methode aufrufen.

Anwenden einer Sprungliste auf die Windows-Shell

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

Wenn Sie die JumpList Eigenschaften festgelegt haben, müssen Sie die auf die Windows-Shell anwenden, bevor der JumpList Inhalt in der Taskleiste Sprungliste angezeigt wird. Dies erfolgt automatisch, wenn zuerst JumpList an eine Anwendung angefügt wird, entweder in XAML oder in einem Aufruf der SetJumpList -Methode. Wenn Sie den Inhalt von JumpList zur Laufzeit ändern, müssen Sie die -Methode aufrufen, um den Apply aktuellen Inhalt auf die Windows-Shell anzuwenden.

Festlegen einer Sprungliste in XAML

Ein JumpList wird nicht automatisch an ein Application Objekt angefügt. Sie fügen an JumpList ein Application Objekt in XAML an, indem Sie die Syntax der angefügten Eigenschaft verwenden. Die JumpList -Klasse implementiert die -Schnittstelle, um die ISupportInitialize XAML-Deklaration eines JumpListzu unterstützen. Wenn in JumpList XAML deklariert und an den aktuellen Applicationangefügt wird, wird es automatisch auf die Windows-Shell angewendet, wenn der JumpList initialisiert wird.

Festlegen und Ändern einer Sprungliste im Code

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

Um ein JumpList zur Laufzeit zu ändern, rufen Sie die GetJumpList -Methode auf, um die abzurufen, die JumpList derzeit an eine Applicationangefügt ist. Nachdem Sie die Eigenschaften von JumpListgeändert haben, müssen Sie die Apply -Methode aufrufen, um die Änderungen auf die Windows-Shell anzuwenden.

Konstruktoren

Eigenschaften

Methoden

Ereignisse

Gilt für: