TaskbarItemInfo Sınıf

Tanım

public ref class TaskbarItemInfo sealed : System::Windows::Freezable

public sealed class TaskbarItemInfo : System.Windows.Freezable

type TaskbarItemInfo = class
    inherit Freezable

Public NotInheritable Class TaskbarItemInfo
Inherits Freezable

Devralma

Object

DispatcherObject

DependencyObject

Freezable

TaskbarItemInfo

Örnekler

Aşağıdaki örnekte, işaretleme içinde öğesinin TaskbarItemInfo nasıl oluşturulacağı gösterilmektedir. , TaskbarItemInfo görev çubuğu öğesinden Yürüt ve Durdur komutlarına erişim sağlayan bir nesne koleksiyonu ThumbButtonInfo içerir.

<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>

Aşağıdaki işaretleme ve kod, önceki örneği tam bağlamında gösterir. Uygulama, 0 ile 100 arasında saymak için bir BackgroundWorker kullanır ve ilerleme durumunu kullanıcı arabiriminde görüntüler. Görev görev çubuğu önizlemesinden başlatılabilir ve durdurulabilir. İlerleme durumu görev çubuğu düğmesinde görüntülenir.

<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);
                    }
                }
            }
        }
    }   
}

' MainWindow.xaml.vb
Imports System.ComponentModel
Imports System.Windows.Shell

Class MainWindow
    Private _backgroundWorker As New BackgroundWorker

    Public Sub New()
        InitializeComponent()

        ' Set up the BackgroundWorker
        Me._backgroundWorker.WorkerReportsProgress = True
        Me._backgroundWorker.WorkerSupportsCancellation = True
        AddHandler Me._backgroundWorker.DoWork, AddressOf bw_DoWork
        AddHandler Me._backgroundWorker.ProgressChanged, AddressOf bw_ProgressChanged
        AddHandler Me._backgroundWorker.RunWorkerCompleted, AddressOf bw_RunWorkerCompleted
    End Sub

    Private Sub StartCommand_CanExecute(ByVal sender As System.Object, ByVal e As System.Windows.Input.CanExecuteRoutedEventArgs)
        e.CanExecute = True
        e.Handled = True
    End Sub

    Private Sub StartCommand_Executed(ByVal sender As System.Object, ByVal e As System.Windows.Input.ExecutedRoutedEventArgs)
        If Me._backgroundWorker.IsBusy = False Then
            Me._backgroundWorker.RunWorkerAsync()
            ' When the task is started, change the ProgressState and Overlay
            ' of the taskbar item to indicate an active task.
            Me.taskBarItemInfo1.ProgressState = Shell.TaskbarItemProgressState.Normal
            Me.taskBarItemInfo1.Overlay = Me.FindResource("PlayImage")
        End If
        e.Handled = True
    End Sub

    Private Sub StopCommand_CanExecute(ByVal sender As System.Object, ByVal e As System.Windows.Input.CanExecuteRoutedEventArgs)
        e.CanExecute = Me._backgroundWorker.WorkerSupportsCancellation
        e.Handled = True
    End Sub

    Private Sub StopCommand_Executed(ByVal sender As System.Object, ByVal e As System.Windows.Input.ExecutedRoutedEventArgs)
        Me._backgroundWorker.CancelAsync()
        e.Handled = True
    End Sub

    Private Sub bw_RunWorkerCompleted(ByVal sender As Object, ByVal e As RunWorkerCompletedEventArgs)
        ' When the task ends, change the ProgressState and Overlay
        ' of the taskbar item to indicate a stopped task.
        If e.Cancelled = True Then
            ' The task was stopped by the user. Show the progress indicator
            ' in the paused state.
            Me.taskBarItemInfo1.ProgressState = TaskbarItemProgressState.Paused
        ElseIf e.Error IsNot Nothing Then
            ' The task ended with an error. Show the progress indicator
            ' in the error state.
            Me.taskBarItemInfo1.ProgressState = TaskbarItemProgressState.Error
        Else
            ' The task completed normally. Remove the progress indicator.
            Me.taskBarItemInfo1.ProgressState = TaskbarItemProgressState.None
            ' In all cases, show the 'Stopped' overlay.
            Me.taskBarItemInfo1.Overlay = Me.FindResource("StopImage")
        End If
    End Sub

    Private Sub bw_ProgressChanged(ByVal sender As Object, ByVal e As ProgressChangedEventArgs)
        Me.tbCount.Text = e.ProgressPercentage.ToString()
        ' Update the value of the task bar progress indicator.
        Me.taskBarItemInfo1.ProgressValue = e.ProgressPercentage / 100
    End Sub

    Private Sub bw_DoWork(ByVal sender As Object, ByVal e As DoWorkEventArgs)
        Dim _worker As BackgroundWorker = CType(sender, BackgroundWorker)
        If _worker IsNot Nothing Then
            For i As Integer = 1 To 100 Step 1
                If _worker.CancellationPending = True Then
                    e.Cancel = True
                    Return
                Else
                    System.Threading.Thread.Sleep(25)
                    _worker.ReportProgress(i)
                End If
            Next
        End If
    End Sub
End Class

Açıklamalar

sınıfı, TaskbarItemInfo Windows 7 görev çubuğu işlevselliği için yönetilen sarmalayıcı sağlar. Windows kabuğu ve yerel görev çubuğu API'leri hakkında daha fazla bilgi için bkz . Görev Çubuğu Uzantıları. TaskbarItemInfobir üzerinde Windowbağımlılık özelliği olarak Window.TaskbarItemInfo kullanıma sunulur.

Windows 7 görev çubuğu, kullanıcıya durumu iletmek ve pencere simge durumuna küçültülmüş veya gizlendiğinde ortak görevleri kullanıma sunmak için görev çubuğu öğesini kullanmanıza olanak tanıyan gelişmiş işlevsellik sağlar. Sınıfı tarafından TaskbarItemInfo kullanıma sunulan işlevsellik, Windows 7'den önceki Windows sürümlerinde kullanılamaz. sınıfını TaskbarItemInfo kullanan uygulamalar windows'un önceki sürümlerinde çalışmaya devam edebilir; ancak bu görev çubuğu geliştirmeleri önceki sürümlerde kullanılamaz.

Windows 7'de, kullanıcının ayarlarına bağlı olarak bazı görev çubuğu işlevleri kullanılamayabilir. Örneğin, Windows Aero devre dışı bırakılırsa veya uygulama yükseltilmiş izinlerle başlatılırsa görev çubuğu işlevselliği kullanılamaz. Uygulamanız, Windows 7'deki gelişmiş görev çubuğu işlevselliğine bağlı olmayan kullanıcıyla etkileşime geçmek için başka yollar sağlamalıdır.

Görev çubuğunun en sağındaki bildirim alanındaki program simgeleri genellikle bir kullanıcıya uygulama durumunu iletmek için kullanılır. Varsayılan olarak, Windows 7 görev çubuğu bildirim alanındaki program simgelerini gizler. Ancak, bir mesajlaşma uygulamasındaki çevrimiçi durum gibi durumu iletmek için görev çubuğu düğmesine görüntü eklemek için özelliğini ayarlayabilirsiniz Overlay . Katman görüntüsü, kullanıcıların bildirim alanında program simgesini göremeseler bile uygulama durumunu görmelerini sağlar. Ve ProgressValue özelliklerini ayarlayarak görev çubuğu düğmesinde çalışan görevlerin ilerleme durumunu ProgressState da görüntüleyebilirsiniz.

Windows 7 görev çubuğu, fare işaretçisini görev çubuğu düğmesinin üzerine taşıdığınızda uygulamanın küçük resmini görüntüler. Varsayılan olarak uygulama penceresinin tamamı gösterilir. özelliğini ayarlayarak ThumbnailClipMargin küçük resimde görüntülenecek pencerenin belirli bir bölümünü belirtebilirsiniz. Görev çubuğu küçük resminin üzerindeki bir araç ipucunda görüntülenecek bir de belirtebilirsiniz Description . Araç ipucu, kullanıcı ayarları nedeniyle küçük resim görünemediğinde bile görüntülenir.

Uygulama penceresine geçmeden ortak görevlere erişim sağlamak için görev çubuğu küçük resmine düğmeler ekleyebilirsiniz. Örneğin, Windows Media Player, uygulama simge durumuna küçültildiğinde görev çubuğu küçük resminden medya kayıttan yürütmeyi denetlemenize olanak sağlayan Yürüt, Duraklat, İlet ve Geri düğmeleri sağlar. Görev çubuğu küçük resmindeki düğmeler nesnelerle ThumbButtonInfo temsil edilir ve koleksiyonda ThumbButtonInfos yer alır.

Aşağıdaki çizimde Windows 7 görev çubuğunun gelişmiş özellikleri gösterilmektedir.

Windows Görev Çubuğu Gelişmiş Özellikleri

Oluşturucular

Alanlar

Özellikler

Yöntemler

Ekinlikler

Şunlara uygulanır