Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

TaskbarItemInfo classe

.NET Framework (current version)
 

Date de publication : novembre 2016

Représente des informations sur l’affichage de la miniature de la barre des tâches.

Espace de noms:   System.Windows.Shell
Assembly:  PresentationFramework (dans PresentationFramework.dll)

System.Object
  System.Windows.Threading.DispatcherObject
    System.Windows.DependencyObject
      System.Windows.Freezable
        System.Windows.Shell.TaskbarItemInfo

public sealed class TaskbarItemInfo : Freezable

NomDescription
System_CAPS_pubmethodTaskbarItemInfo()

Initialise une nouvelle instance de la classe TaskbarItemInfo.

NomDescription
System_CAPS_pubpropertyCanFreeze

Obtient une valeur qui indique si l’objet peut être rendu non modifiable.(Hérité de Freezable.)

System_CAPS_pubpropertyDependencyObjectType

Obtient les DependencyObjectType qui encapsule le CLR type de cette instance. (Hérité de DependencyObject.)

System_CAPS_pubpropertyDescription

Obtient ou définit le texte de l’info-bulle des éléments de la barre des tâches.

System_CAPS_pubpropertyDispatcher

Obtient le Dispatcher cela DispatcherObject est associé.(Hérité de DispatcherObject.)

System_CAPS_pubpropertyIsFrozen

Obtient une valeur qui indique si l’objet est actuellement modifiable.(Hérité de Freezable.)

System_CAPS_pubpropertyIsSealed

Obtient une valeur qui indique si cette instance est actuellement sealed (en lecture seule).(Hérité de DependencyObject.)

System_CAPS_pubpropertyOverlay

Obtient ou définit l’image qui est affichée sur l’icône de programme dans le bouton de la barre des tâches.

System_CAPS_pubpropertyProgressState

Obtient ou définit une valeur qui indique comment l’indicateur de progression est affichée dans le bouton de la barre des tâches.

System_CAPS_pubpropertyProgressValue

Obtient ou définit une valeur qui indique le remplissage de l’indicateur de progression dans le bouton de la barre des tâches.

System_CAPS_pubpropertyThumbButtonInfos

Obtient ou définit la collection de ThumbButtonInfo les objets qui sont associés les Window.

System_CAPS_pubpropertyThumbnailClipMargin

Obtient ou définit une valeur qui spécifie la partie de la zone cliente de la fenêtre d’application qui est affichée dans la miniature de la barre des tâches.

NomDescription
System_CAPS_pubmethodCheckAccess()

Détermine si le thread appelant a accès à ce DispatcherObject.(Hérité de DispatcherObject.)

System_CAPS_pubmethodClearValue(DependencyProperty)

Efface la valeur locale d’une propriété. La propriété à effacer est spécifiée par un identificateur DependencyProperty.(Hérité de DependencyObject.)

System_CAPS_pubmethodClearValue(DependencyPropertyKey)

Efface la valeur locale d’une propriété en lecture seule. La propriété à effacer est spécifiée par DependencyPropertyKey.(Hérité de DependencyObject.)

System_CAPS_pubmethodClone()

Crée un clone modifiable de Freezable, en créant des copies complètes des valeurs de l’objet. Lors de la copie des propriétés de dépendance de l’objet, cette méthode copie les expressions (qui peuvent ne plus se résoudre), mais pas les animations ni leurs valeurs actuelles.(Hérité de Freezable.)

System_CAPS_pubmethodCloneCurrentValue()

Crée un clone modifiable (copie intégrale) de le Freezable à l’aide de ses valeurs actuelles.(Hérité de Freezable.)

System_CAPS_pubmethodCoerceValue(DependencyProperty)

Convertit la valeur de la propriété de dépendance spécifiée. Pour cela, on appelle toute fonction CoerceValueCallback spécifiée dans les métadonnées de propriété pour la propriété de dépendance telle qu’elle existe sur le DependencyObject appelant.(Hérité de DependencyObject.)

System_CAPS_pubmethodEquals(Object)

Détermine si un DependencyObject est équivalente à l’actuel DependencyObject.(Hérité de DependencyObject.)

System_CAPS_pubmethodFreeze()

Rend l’objet actif non modifiable et attribue à sa propriété IsFrozen la valeur true.(Hérité de Freezable.)

System_CAPS_pubmethodGetAsFrozen()

Crée une copie figée de le Freezable, à l’aide des valeurs de propriétés (non animées) de base. Étant donné que la copie est figée, les sous-objets figés sont copiées par référence.(Hérité de Freezable.)

System_CAPS_pubmethodGetCurrentValueAsFrozen()

Crée une copie figée de le Freezable à l’aide des valeurs de propriété actuelles. Étant donné que la copie est figée, les sous-objets figés sont copiées par référence.(Hérité de Freezable.)

System_CAPS_pubmethodGetHashCode()

Obtient un code de hachage pour ce DependencyObject.(Hérité de DependencyObject.)

System_CAPS_pubmethodGetLocalValueEnumerator()

Crée un énumérateur spécialisé pour déterminer quelles propriétés de dépendance ont des valeurs définies localement sur ce DependencyObject.(Hérité de DependencyObject.)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodGetValue(DependencyProperty)

Retourne la valeur effective actuelle d’une propriété de dépendance sur cette instance d’un DependencyObject.(Hérité de DependencyObject.)

System_CAPS_pubmethodInvalidateProperty(DependencyProperty)

Réévalue la valeur effective de la propriété de dépendance spécifiée(Hérité de DependencyObject.)

System_CAPS_pubmethodReadLocalValue(DependencyProperty)

Retourne la valeur locale d’une propriété de dépendance, si elle existe.(Hérité de DependencyObject.)

System_CAPS_pubmethodSetCurrentValue(DependencyProperty, Object)

Définit la valeur d’une propriété de dépendance sans modifier sa valeur source.(Hérité de DependencyObject.)

System_CAPS_pubmethodSetValue(DependencyProperty, Object)

Définit la valeur locale d’une propriété de dépendance, spécifiée par son identificateur de propriété de dépendance.(Hérité de DependencyObject.)

System_CAPS_pubmethodSetValue(DependencyPropertyKey, Object)

Définit la valeur locale d’une propriété de dépendance en lecture seule, spécifiée par l’identificateur DependencyPropertyKey de la propriété de dépendance.(Hérité de DependencyObject.)

System_CAPS_protmethodShouldSerializeProperty(DependencyProperty)

Retourne une valeur qui indique si les processus de sérialisation doivent sérialiser la valeur de la propriété de dépendance fournie.(Hérité de DependencyObject.)

System_CAPS_pubmethodToString()

Retourne une chaîne qui représente l'objet actuel.(Hérité de Object.)

System_CAPS_pubmethodVerifyAccess()

Impose que le thread appelant a accès à ce DispatcherObject.(Hérité de DispatcherObject.)

NomDescription
System_CAPS_pubfieldSystem_CAPS_staticDescriptionProperty

Identifie la propriété de dépendance Description.

System_CAPS_pubfieldSystem_CAPS_staticOverlayProperty

Identifie la propriété de dépendance Overlay.

System_CAPS_pubfieldSystem_CAPS_staticProgressStateProperty

Identifie la propriété de dépendance ProgressState.

System_CAPS_pubfieldSystem_CAPS_staticProgressValueProperty

Identifie la propriété de dépendance ProgressValue.

System_CAPS_pubfieldSystem_CAPS_staticThumbButtonInfosProperty

Identifie le ThumbButtonInfos propriété de dépendance.

System_CAPS_pubfieldSystem_CAPS_staticThumbnailClipMarginProperty

Identifie le ThumbnailClipMargin propriété de dépendance.

NomDescription
System_CAPS_pubeventChanged

Se produit lorsque le Freezable ou un objet qu’il contient est modifié.(Hérité de Freezable.)

La TaskbarItemInfo classe fournit un wrapper managé pour Windows 7 les fonctionnalités de la barre des tâches. Pour plus d’informations sur le shell Windows et les API de barre des tâches natives, consultez Taskbar Extensions. TaskbarItemInfo est exposé comme le Window.TaskbarItemInfo propriété de dépendance sur un Window.

Le Windows 7 la barre des tâches fournit des fonctionnalités améliorées qui vous permet d’utiliser les éléments de la barre des tâches pour communiquer l’état à un utilisateur et exposer les tâches courantes lorsque la fenêtre est réduite ou masquée. La fonctionnalité exposée par la TaskbarItemInfo classe n’est pas disponible dans les versions de Windows antérieures à Windows 7. Les applications qui utilisent la TaskbarItemInfo classe peut toujours s’exécuter dans les versions antérieures de Windows ; Toutefois, ces améliorations de la barre des tâches ne sont pas disponibles dans les versions antérieures. 

Dans Windows 7, certaines fonctionnalités de la barre des tâches peuvent être indisponible, en fonction des paramètres de l’utilisateur. Par exemple, les fonctionnalités de la barre des tâches ne sont pas disponible si Windows Aero est désactivé ou si l’application est démarrée avec des autorisations élevées. Votre application doit fournir autres moyens d’interagir avec l’utilisateur qui ne dépendent pas de la fonctionnalité de barre des tâches améliorée dans Windows 7.

Icônes de programme dans la zone de notification, qui est à l’extrême droite de la barre des tâches, sont généralement utilisés pour communiquer l’état de l’application à un utilisateur. Par défaut, le Windows 7 la barre des tâches masque les icônes de programme dans la zone de notification. Toutefois, vous pouvez définir le Overlay propriété pour ajouter une image au bouton de barre des tâches pour communiquer l’état, telles que l’état en ligne dans une application de messagerie. L’image de superposition permet aux utilisateurs de voir l’état de l’application, même si elles ne peuvent pas voir l’icône de programme dans la zone de notification. Vous pouvez également afficher la progression de l’exécution des tâches dans le bouton de la barre des tâches en définissant le ProgressState et ProgressValue Propriétés.

Le Windows 7 la barre des tâches affiche une miniature de l’application lorsque vous déplacez le pointeur de la souris sur le bouton de la barre des tâches. Par défaut, la fenêtre de l’application entière est affichée. Vous pouvez spécifier une partie spécifique de la fenêtre à afficher dans la miniature en définissant le ThumbnailClipMargin propriété. Vous pouvez également spécifier un Description qui s’affiche dans une info-bulle au-dessus de la miniature de la barre des tâches. L’info-bulle s’affiche même lorsque la miniature ne sont pas visibles en raison des paramètres de l’utilisateur. 

Vous pouvez ajouter des boutons à la miniature de la barre des tâches pour fournir l’accès aux tâches courantes sans basculer vers la fenêtre d’application. Par exemple, le lecteur Windows Media fournit la lecture, Pause, vers l’avant, et les boutons qui vous permettent de contrôlent la lecture depuis la miniature de la barre des tâches lorsque l’application est réduite. Boutons dans la miniature de la barre des tâches sont représentées par ThumbButtonInfo objets et sont contenues dans le ThumbButtonInfos collection.

L’illustration suivante montre les fonctionnalités améliorées de la Windows 7 la barre des tâches.

Exemple d'informations d'élément de barre des tâches

Fonctionnalités améliorées de la barre des tâches Windows

L’exemple suivant montre comment créer un TaskbarItemInfo dans le balisage. La TaskbarItemInfo contient une collection de ThumbButtonInfo objets qui fournissent l’accès aux commandes de lecture et d’arrêt de l’élément de la barre des tâches.

<Window.TaskbarItemInfo>
    <TaskbarItemInfo x:Name="taskBarItemInfo1" 
                     Overlay="{StaticResource ResourceKey=StopImage}"
                     ThumbnailClipMargin="80,0,80,140"
                     Description="Taskbar Item Info Sample">
        <TaskbarItemInfo.ThumbButtonInfos>
            <ThumbButtonInfoCollection>
                <ThumbButtonInfo
                    DismissWhenClicked="False"
                    Command="MediaCommands.Play"
                    CommandTarget="{Binding ElementName=btnPlay}"
                    Description="Play"
                    ImageSource="{StaticResource ResourceKey=PlayImage}"/>
                <ThumbButtonInfo
                    DismissWhenClicked="True"
                    Command="MediaCommands.Stop"
                    CommandTarget="{Binding ElementName=btnStop}"
                    Description="Stop"
                    ImageSource="{StaticResource ResourceKey=StopImage}"/>
            </ThumbButtonInfoCollection>
        </TaskbarItemInfo.ThumbButtonInfos>
    </TaskbarItemInfo>
</Window.TaskbarItemInfo>

Le balisage et le code suivant montre l’exemple précédent dans son contexte complet. L’application utilise un BackgroundWorker à compter de 0 à 100 et affiche sa progression dans l’interface utilisateur. La tâche peut être démarrée et arrêtée à partir de l’aperçu de la barre des tâches. La progression est affichée dans le bouton de la barre des tâches.

<Window x:Class="Shell_TaskbarItemSample.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="300" Width="300">
    <Window.Resources>
        <DrawingImage x:Key="PlayImage">
            <DrawingImage.Drawing>
                <DrawingGroup>
                    <DrawingGroup.Children>
                        <GeometryDrawing Brush="Green" Geometry="F1 M 50,25L 0,0L 0,50L 50,25 Z "/>
                    </DrawingGroup.Children>
                </DrawingGroup>
            </DrawingImage.Drawing>
        </DrawingImage>
        <DrawingImage x:Key="StopImage">
            <DrawingImage.Drawing>
                <DrawingGroup>
                    <DrawingGroup.Children>
                        <GeometryDrawing Brush="Gray" Geometry="F1 M 0,0L 50,0L 50,50L 0,50L 0,0 Z "/>
                    </DrawingGroup.Children>
                </DrawingGroup>
            </DrawingImage.Drawing>
        </DrawingImage>
    </Window.Resources>
    <Window.CommandBindings>
        <CommandBinding Command="MediaCommands.Play"
                  Executed="StartCommand_Executed"
                  CanExecute="StartCommand_CanExecute"/>
        <CommandBinding Command="MediaCommands.Stop"
                  Executed="StopCommand_Executed"
                  CanExecute="StopCommand_CanExecute"/>
    </Window.CommandBindings>
    <Window.TaskbarItemInfo>
        <TaskbarItemInfo x:Name="taskBarItemInfo1" 
                         Overlay="{StaticResource ResourceKey=StopImage}"
                         ThumbnailClipMargin="80,0,80,140"
                         Description="Taskbar Item Info Sample">
            <TaskbarItemInfo.ThumbButtonInfos>
                <ThumbButtonInfoCollection>
                    <ThumbButtonInfo
                        DismissWhenClicked="False"
                        Command="MediaCommands.Play"
                        CommandTarget="{Binding ElementName=btnPlay}"
                        Description="Play"
                        ImageSource="{StaticResource ResourceKey=PlayImage}"/>
                    <ThumbButtonInfo
                        DismissWhenClicked="True"
                        Command="MediaCommands.Stop"
                        CommandTarget="{Binding ElementName=btnStop}"
                        Description="Stop"
                        ImageSource="{StaticResource ResourceKey=StopImage}"/>
                </ThumbButtonInfoCollection>
            </TaskbarItemInfo.ThumbButtonInfos>
        </TaskbarItemInfo>
    </Window.TaskbarItemInfo>

    <Grid>
        <StackPanel>
            <TextBlock x:Name="tbCount" FontSize="72" HorizontalAlignment="Center"/>
            <StackPanel Orientation="Horizontal">
                <Button x:Name="btnPlay" Content="Play" Command="MediaCommands.Play" />
                <Button x:Name="btnStop" Content="Stop" Command="MediaCommands.Stop" />
            </StackPanel>    
        </StackPanel>
    </Grid>
</Window>
// MainWindow.xaml.cs
using System.ComponentModel;
using System.Windows;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Shell;

namespace Shell_TaskbarItemSample
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        private BackgroundWorker _backgroundWorker = new BackgroundWorker();

        public MainWindow()
        {
            InitializeComponent();

            // Set up the BackgroundWorker.
            this._backgroundWorker.WorkerReportsProgress = true;
            this._backgroundWorker.WorkerSupportsCancellation = true;
            this._backgroundWorker.DoWork += new DoWorkEventHandler(bw_DoWork);
            this._backgroundWorker.ProgressChanged += new ProgressChangedEventHandler(bw_ProgressChanged);
            this._backgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);
        }

        private void StartCommand_CanExecute(object sender, CanExecuteRoutedEventArgs e)
        {
            e.CanExecute = true;
            e.Handled = true;
        }

        private void StartCommand_Executed(object sender, ExecutedRoutedEventArgs e)
        {
            if (this._backgroundWorker.IsBusy == false)
            {
                this._backgroundWorker.RunWorkerAsync();
                // When the task is started, change the ProgressState and Overlay
                // of the taskbar item to indicate an active task.
                this.taskBarItemInfo1.ProgressState = TaskbarItemProgressState.Normal;
                this.taskBarItemInfo1.Overlay = (DrawingImage)this.FindResource("PlayImage");
            }
            e.Handled = true;
        }

        private void StopCommand_CanExecute(object sender, CanExecuteRoutedEventArgs e)
        {
            e.CanExecute = this._backgroundWorker.WorkerSupportsCancellation;
            e.Handled = true;
        }

        private void StopCommand_Executed(object sender, ExecutedRoutedEventArgs e)
        {
            this._backgroundWorker.CancelAsync();
            e.Handled = true;
        }

        void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            // When the task ends, change the ProgressState and Overlay
            // of the taskbar item to indicate a stopped task.
            if (e.Cancelled == true)
            {
                // The task was stopped by the user. Show the progress indicator
                // in the paused state.
                this.taskBarItemInfo1.ProgressState = TaskbarItemProgressState.Paused;
            }
            else if (e.Error != null)
            {
                // The task ended with an error. Show the progress indicator
                // in the error state.
                this.taskBarItemInfo1.ProgressState = TaskbarItemProgressState.Error;
            }
            else
            {
                // The task completed normally. Remove the progress indicator.
                this.taskBarItemInfo1.ProgressState = TaskbarItemProgressState.None;
            }
            // In all cases, show the 'Stopped' overlay.
            this.taskBarItemInfo1.Overlay = (DrawingImage)this.FindResource("StopImage");
        }

        void bw_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            this.tbCount.Text = e.ProgressPercentage.ToString();
            // Update the value of the task bar progress indicator.
            this.taskBarItemInfo1.ProgressValue = (double)e.ProgressPercentage / 100;
        }

        void bw_DoWork(object sender, DoWorkEventArgs e)
        {        
            BackgroundWorker _worker = sender as BackgroundWorker;
            if (_worker != null)
            {
                for (int i = 1; i <= 100; i++)
                {
                    if (_worker.CancellationPending == true)
                    {
                        e.Cancel = true;
                        break;
                    }
                    else
                    {
                        System.Threading.Thread.Sleep(25);
                        _worker.ReportProgress(i);
                    }
                }
            }
        }

    }   
}

.NET Framework
Disponible depuis 4.0

Tous les membres statiques publics ( Shared en Visual Basic) de ce type sont thread-safe. Les membres d’instance n’ont pas la garantie d’être thread-safe.

Retour au début
Afficher: