// hardcodet.net NotifyIcon for WPF
// Copyright (c) 2009 - 2013 Philipp Sumi
// Contact and Information: http://www.hardcodet.net
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the Code Project Open License (CPOL);
// either version 1.0 of the License, or (at your option) any later
// version.
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
//
// THIS COPYRIGHT NOTICE MAY NOT BE REMOVED FROM THIS FILE
using System;
using System.ComponentModel;
using System.Drawing;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media;
using Hardcodet.Wpf.TaskbarNotification.Interop;
namespace Hardcodet.Wpf.TaskbarNotification
{
///
/// Contains declarations of WPF dependency properties
/// and events.
///
partial class TaskbarIcon
{
///
/// Category name that is set on designer properties.
///
public const string CategoryName = "NotifyIcon";
//POPUP CONTROLS
#region TrayPopupResolved
///
/// TrayPopupResolved Read-Only Dependency Property
///
private static readonly DependencyPropertyKey TrayPopupResolvedPropertyKey
= DependencyProperty.RegisterReadOnly(nameof(TrayPopupResolved), typeof (Popup), typeof (TaskbarIcon),
new FrameworkPropertyMetadata(null));
///
/// A read-only dependency property that returns the
/// that is being displayed in the taskbar area based on a user action.
///
public static readonly DependencyProperty TrayPopupResolvedProperty
= TrayPopupResolvedPropertyKey.DependencyProperty;
///
/// Gets the TrayPopupResolved property. Returns
/// a which is either the
/// control itself or a
/// control that contains the
/// .
///
[Category(CategoryName)]
public Popup TrayPopupResolved
{
get { return (Popup) GetValue(TrayPopupResolvedProperty); }
}
///
/// Provides a secure method for setting the TrayPopupResolved property.
/// This dependency property indicates ....
///
/// The new value for the property.
protected void SetTrayPopupResolved(Popup value)
{
SetValue(TrayPopupResolvedPropertyKey, value);
}
#endregion
#region TrayToolTipResolved
///
/// TrayToolTipResolved Read-Only Dependency Property
///
private static readonly DependencyPropertyKey TrayToolTipResolvedPropertyKey
= DependencyProperty.RegisterReadOnly(nameof(TrayToolTipResolved), typeof (ToolTip), typeof (TaskbarIcon),
new FrameworkPropertyMetadata(null));
///
/// A read-only dependency property that returns the
/// that is being displayed.
///
public static readonly DependencyProperty TrayToolTipResolvedProperty
= TrayToolTipResolvedPropertyKey.DependencyProperty;
///
/// Gets the TrayToolTipResolved property. Returns
/// a control that was created
/// in order to display either
/// or .
///
[Category(CategoryName)]
[Browsable(true)]
[Bindable(true)]
public ToolTip TrayToolTipResolved
{
get { return (ToolTip) GetValue(TrayToolTipResolvedProperty); }
}
///
/// Provides a secure method for setting the
/// property.
///
/// The new value for the property.
protected void SetTrayToolTipResolved(ToolTip value)
{
SetValue(TrayToolTipResolvedPropertyKey, value);
}
#endregion
#region CustomBalloon
///
/// CustomBalloon Read-Only Dependency Property
///
private static readonly DependencyPropertyKey CustomBalloonPropertyKey
= DependencyProperty.RegisterReadOnly(nameof(CustomBalloon), typeof (Popup), typeof (TaskbarIcon),
new FrameworkPropertyMetadata(null));
///
/// Maintains a currently displayed custom balloon.
///
public static readonly DependencyProperty CustomBalloonProperty
= CustomBalloonPropertyKey.DependencyProperty;
///
/// A custom popup that is being displayed in the tray area in order
/// to display messages to the user.
///
public Popup CustomBalloon
{
get { return (Popup) GetValue(CustomBalloonProperty); }
}
///
/// Provides a secure method for setting the property.
///
/// The new value for the property.
protected void SetCustomBalloon(Popup value)
{
SetValue(CustomBalloonPropertyKey, value);
}
#endregion
//DEPENDENCY PROPERTIES
#region Icon property / IconSource dependency property
private Icon icon;
///
/// Gets or sets the icon to be displayed. This is not a
/// dependency property - if you want to assign the property
/// through XAML, please use the
/// dependency property.
///
[Browsable(false)]
public Icon Icon
{
get { return icon; }
set
{
icon = value;
iconData.IconHandle = value == null ? IntPtr.Zero : icon.Handle;
Util.WriteIconData(ref iconData, NotifyCommand.Modify, IconDataMembers.Icon);
}
}
///
/// Resolves an image source and updates the property accordingly.
///
public static readonly DependencyProperty IconSourceProperty =
DependencyProperty.Register(nameof(IconSource),
typeof (ImageSource),
typeof (TaskbarIcon),
new FrameworkPropertyMetadata(null, IconSourcePropertyChanged));
///
/// A property wrapper for the
/// dependency property:
/// Resolves an image source and updates the property accordingly.
///
[Category(CategoryName)]
[Description("Sets the displayed taskbar icon.")]
public ImageSource IconSource
{
get { return (ImageSource) GetValue(IconSourceProperty); }
set { SetValue(IconSourceProperty, value); }
}
///
/// A static callback listener which is being invoked if the
/// dependency property has
/// been changed. Invokes the
/// instance method of the changed instance.
///
/// The currently processed owner of the property.
/// Provides information about the updated property.
private static void IconSourcePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
TaskbarIcon owner = (TaskbarIcon) d;
owner.OnIconSourcePropertyChanged(e);
}
///
/// Handles changes of the dependency property. As
/// WPF internally uses the dependency property system and bypasses the
/// property wrapper, updates of the property's value
/// should be handled here.
///
/// Provides information about the updated property.
private void OnIconSourcePropertyChanged(DependencyPropertyChangedEventArgs e)
{
ImageSource newValue = (ImageSource) e.NewValue;
//resolving the ImageSource at design time is unlikely to work
if (!Util.IsDesignMode) Icon = newValue.ToIcon();
}
#endregion
#region ToolTipText dependency property
///
/// A tooltip text that is being displayed if no custom
/// was set or if custom tooltips are not supported.
///
public static readonly DependencyProperty ToolTipTextProperty =
DependencyProperty.Register(nameof(ToolTipText),
typeof (string),
typeof (TaskbarIcon),
new FrameworkPropertyMetadata(string.Empty, ToolTipTextPropertyChanged));
///
/// A property wrapper for the
/// dependency property:
/// A tooltip text that is being displayed if no custom
/// was set or if custom tooltips are not supported.
///
[Category(CategoryName)]
[Description("Alternative to a fully blown ToolTip, which is only displayed on Vista and above.")]
public string ToolTipText
{
get { return (string) GetValue(ToolTipTextProperty); }
set { SetValue(ToolTipTextProperty, value); }
}
///
/// A static callback listener which is being invoked if the
/// dependency property has
/// been changed. Invokes the
/// instance method of the changed instance.
///
/// The currently processed owner of the property.
/// Provides information about the updated property.
private static void ToolTipTextPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
TaskbarIcon owner = (TaskbarIcon) d;
owner.OnToolTipTextPropertyChanged(e);
}
///
/// Handles changes of the dependency property. As
/// WPF internally uses the dependency property system and bypasses the
/// property wrapper, updates of the property's value
/// should be handled here.
///
/// Provides information about the updated property.
private void OnToolTipTextPropertyChanged(DependencyPropertyChangedEventArgs e)
{
//do not touch tooltips if we have a custom tooltip element
if (TrayToolTip == null)
{
ToolTip currentToolTip = TrayToolTipResolved;
if (currentToolTip == null)
{
//if we don't have a wrapper tooltip for the tooltip text, create it now
CreateCustomToolTip();
}
else
{
//if we have a wrapper tooltip that shows the old tooltip text, just update content
currentToolTip.Content = e.NewValue;
}
}
WriteToolTipSettings();
}
#endregion
#region TrayToolTip dependency property
///
/// A custom UI element that is displayed as a tooltip if the user hovers over the taskbar icon.
/// Works only with Vista and above. Accordingly, you should make sure that
/// the property is set as well.
///
public static readonly DependencyProperty TrayToolTipProperty =
DependencyProperty.Register(nameof(TrayToolTip),
typeof (UIElement),
typeof (TaskbarIcon),
new FrameworkPropertyMetadata(null, TrayToolTipPropertyChanged));
///
/// A property wrapper for the
/// dependency property:
/// A custom UI element that is displayed as a tooltip if the user hovers over the taskbar icon.
/// Works only with Vista and above. Accordingly, you should make sure that
/// the property is set as well.
///
[Category(CategoryName)]
[Description("Custom UI element that is displayed as a tooltip. Only on Vista and above")]
public UIElement TrayToolTip
{
get { return (UIElement) GetValue(TrayToolTipProperty); }
set { SetValue(TrayToolTipProperty, value); }
}
///
/// A static callback listener which is being invoked if the
/// dependency property has
/// been changed. Invokes the
/// instance method of the changed instance.
///
/// The currently processed owner of the property.
/// Provides information about the updated property.
private static void TrayToolTipPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
TaskbarIcon owner = (TaskbarIcon) d;
owner.OnTrayToolTipPropertyChanged(e);
}
///
/// Handles changes of the dependency property. As
/// WPF internally uses the dependency property system and bypasses the
/// property wrapper, updates of the property's value
/// should be handled here.
///
/// Provides information about the updated property.
private void OnTrayToolTipPropertyChanged(DependencyPropertyChangedEventArgs e)
{
//recreate tooltip control
CreateCustomToolTip();
if (e.OldValue != null)
{
//remove the taskbar icon reference from the previously used element
SetParentTaskbarIcon((DependencyObject) e.OldValue, null);
}
if (e.NewValue != null)
{
//set this taskbar icon as a reference to the new tooltip element
SetParentTaskbarIcon((DependencyObject) e.NewValue, this);
}
//update tooltip settings - needed to make sure a string is set, even
//if the ToolTipText property is not set. Otherwise, the event that
//triggers tooltip display is never fired.
WriteToolTipSettings();
}
#endregion
#region TrayPopup dependency property
///
/// A control that is displayed as a popup when the taskbar icon is clicked.
///
public static readonly DependencyProperty TrayPopupProperty =
DependencyProperty.Register(nameof(TrayPopup),
typeof (UIElement),
typeof (TaskbarIcon),
new FrameworkPropertyMetadata(null, TrayPopupPropertyChanged));
///
/// A property wrapper for the
/// dependency property:
/// A control that is displayed as a popup when the taskbar icon is clicked.
///
[Category(CategoryName)]
[Description("Displayed as a Popup if the user clicks on the taskbar icon.")]
public UIElement TrayPopup
{
get { return (UIElement) GetValue(TrayPopupProperty); }
set { SetValue(TrayPopupProperty, value); }
}
///
/// A static callback listener which is being invoked if the
/// dependency property has
/// been changed. Invokes the
/// instance method of the changed instance.
///
/// The currently processed owner of the property.
/// Provides information about the updated property.
private static void TrayPopupPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
TaskbarIcon owner = (TaskbarIcon) d;
owner.OnTrayPopupPropertyChanged(e);
}
///
/// Handles changes of the dependency property. As
/// WPF internally uses the dependency property system and bypasses the
/// property wrapper, updates of the property's value
/// should be handled here.
///
/// Provides information about the updated property.
private void OnTrayPopupPropertyChanged(DependencyPropertyChangedEventArgs e)
{
if (e.OldValue != null)
{
//remove the taskbar icon reference from the previously used element
SetParentTaskbarIcon((DependencyObject) e.OldValue, null);
}
if (e.NewValue != null)
{
//set this taskbar icon as a reference to the new tooltip element
SetParentTaskbarIcon((DependencyObject) e.NewValue, this);
}
//create a pop
CreatePopup();
}
#endregion
#region MenuActivation dependency property
///
/// Defines what mouse events display the context menu.
/// Defaults to .
///
public static readonly DependencyProperty MenuActivationProperty =
DependencyProperty.Register(nameof(MenuActivation),
typeof (PopupActivationMode),
typeof (TaskbarIcon),
new FrameworkPropertyMetadata(PopupActivationMode.RightClick));
///
/// A property wrapper for the
/// dependency property:
/// Defines what mouse events display the context menu.
/// Defaults to .
///
[Category(CategoryName)]
[Description("Defines what mouse events display the context menu.")]
public PopupActivationMode MenuActivation
{
get { return (PopupActivationMode) GetValue(MenuActivationProperty); }
set { SetValue(MenuActivationProperty, value); }
}
#endregion
#region PopupActivation dependency property
///
/// Defines what mouse events trigger the .
/// Default is .
///
public static readonly DependencyProperty PopupActivationProperty =
DependencyProperty.Register(nameof(PopupActivation),
typeof (PopupActivationMode),
typeof (TaskbarIcon),
new FrameworkPropertyMetadata(PopupActivationMode.LeftClick));
///
/// A property wrapper for the
/// dependency property:
/// Defines what mouse events trigger the .
/// Default is .
///
[Category(CategoryName)]
[Description("Defines what mouse events display the TaskbarIconPopup.")]
public PopupActivationMode PopupActivation
{
get { return (PopupActivationMode) GetValue(PopupActivationProperty); }
set { SetValue(PopupActivationProperty, value); }
}
#endregion
#region Visibility dependency property override
///
/// A static callback listener which is being invoked if the
/// dependency property has
/// been changed. Invokes the
/// instance method of the changed instance.
///
/// The currently processed owner of the property.
/// Provides information about the updated property.
private static void VisibilityPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
TaskbarIcon owner = (TaskbarIcon) d;
owner.OnVisibilityPropertyChanged(e);
}
///
/// Handles changes of the dependency property. As
/// WPF internally uses the dependency property system and bypasses the
/// property wrapper, updates of the property's value
/// should be handled here.
///
/// Provides information about the updated property.
private void OnVisibilityPropertyChanged(DependencyPropertyChangedEventArgs e)
{
Visibility newValue = (Visibility) e.NewValue;
//update
if (newValue == Visibility.Visible)
{
CreateTaskbarIcon();
}
else
{
RemoveTaskbarIcon();
}
}
#endregion
#region DataContext dependency property override / target update
///
/// Updates the of a given
/// . This method only updates target elements
/// that do not already have a data context of their own, and either assigns
/// the of the NotifyIcon, or the
/// NotifyIcon itself, if no data context was assigned at all.
///
private void UpdateDataContext(FrameworkElement target, object oldDataContextValue, object newDataContextValue)
{
//if there is no target or it's data context is determined through a binding
//of its own, keep it
if (target == null || target.IsDataContextDataBound()) return;
//if the target's data context is the NotifyIcon's old DataContext or the NotifyIcon itself,
//update it
if (ReferenceEquals(this, target.DataContext) || Equals(oldDataContextValue, target.DataContext))
{
//assign own data context, if available. If there is no data
//context at all, assign NotifyIcon itself.
target.DataContext = newDataContextValue ?? this;
}
}
///
/// A static callback listener which is being invoked if the
/// dependency property has
/// been changed. Invokes the
/// instance method of the changed instance.
///
/// The currently processed owner of the property.
/// Provides information about the updated property.
private static void DataContextPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
TaskbarIcon owner = (TaskbarIcon) d;
owner.OnDataContextPropertyChanged(e);
}
///
/// Handles changes of the dependency property. As
/// WPF internally uses the dependency property system and bypasses the
/// property wrapper, updates of the property's value
/// should be handled here.
///
/// Provides information about the updated property.
private void OnDataContextPropertyChanged(DependencyPropertyChangedEventArgs e)
{
object newValue = e.NewValue;
object oldValue = e.OldValue;
//replace custom data context for ToolTips, Popup, and
//ContextMenu
UpdateDataContext(TrayPopupResolved, oldValue, newValue);
UpdateDataContext(TrayToolTipResolved, oldValue, newValue);
UpdateDataContext(ContextMenu, oldValue, newValue);
}
#endregion
#region ContextMenu dependency property override
///
/// A static callback listener which is being invoked if the
/// dependency property has
/// been changed. Invokes the
/// instance method of the changed instance.
///
/// The currently processed owner of the property.
/// Provides information about the updated property.
private static void ContextMenuPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
TaskbarIcon owner = (TaskbarIcon) d;
owner.OnContextMenuPropertyChanged(e);
}
///
/// Releases the old and updates the new property
/// in order to reflect both the NotifyIcon's
/// property and have the assigned.
///
/// Provides information about the updated property.
private void OnContextMenuPropertyChanged(DependencyPropertyChangedEventArgs e)
{
if (e.OldValue != null)
{
//remove the taskbar icon reference from the previously used element
SetParentTaskbarIcon((DependencyObject) e.OldValue, null);
}
if (e.NewValue != null)
{
//set this taskbar icon as a reference to the new tooltip element
SetParentTaskbarIcon((DependencyObject) e.NewValue, this);
}
UpdateDataContext((ContextMenu) e.NewValue, null, DataContext);
}
#endregion
#region DoubleClickCommand dependency property
///
/// Associates a command that is being executed if the tray icon is being
/// double clicked.
///
public static readonly DependencyProperty DoubleClickCommandProperty =
DependencyProperty.Register(nameof(DoubleClickCommand),
typeof (ICommand),
typeof (TaskbarIcon),
new FrameworkPropertyMetadata(null));
///
/// A property wrapper for the
/// dependency property:
/// Associates a command that is being executed if the tray icon is being
/// double clicked.
///
[Category(CategoryName)]
[Description("A command that is being executed if the tray icon is being double-clicked.")]
public ICommand DoubleClickCommand
{
get { return (ICommand) GetValue(DoubleClickCommandProperty); }
set { SetValue(DoubleClickCommandProperty, value); }
}
#endregion
#region DoubleClickCommandParameter dependency property
///
/// Command parameter for the .
///
public static readonly DependencyProperty DoubleClickCommandParameterProperty =
DependencyProperty.Register(nameof(DoubleClickCommandParameter),
typeof (object),
typeof (TaskbarIcon),
new FrameworkPropertyMetadata(null));
///
/// A property wrapper for the
/// dependency property:
/// Command parameter for the .
///
[Category(CategoryName)]
[Description("Parameter to submit to the DoubleClickCommand when the user double clicks on the NotifyIcon.")]
public object DoubleClickCommandParameter
{
get { return GetValue(DoubleClickCommandParameterProperty); }
set { SetValue(DoubleClickCommandParameterProperty, value); }
}
#endregion
#region DoubleClickCommandTarget dependency property
///
/// The target of the command that is fired if the notify icon is double clicked.
///
public static readonly DependencyProperty DoubleClickCommandTargetProperty =
DependencyProperty.Register(nameof(DoubleClickCommandTarget),
typeof (IInputElement),
typeof (TaskbarIcon),
new FrameworkPropertyMetadata(null));
///
/// A property wrapper for the
/// dependency property:
/// The target of the command that is fired if the notify icon is double clicked.
///
[Category(CategoryName)]
[Description("The target of the command that is fired if the notify icon is double clicked.")]
public IInputElement DoubleClickCommandTarget
{
get { return (IInputElement) GetValue(DoubleClickCommandTargetProperty); }
set { SetValue(DoubleClickCommandTargetProperty, value); }
}
#endregion
#region LeftClickCommand dependency property
///
/// Associates a command that is being executed if the tray icon is being
/// double clicked.
///
public static readonly DependencyProperty LeftClickCommandProperty =
DependencyProperty.Register(nameof(LeftClickCommand),
typeof (ICommand),
typeof (TaskbarIcon),
new FrameworkPropertyMetadata(null));
///
/// A property wrapper for the
/// dependency property:
/// Associates a command that is being executed if the tray icon is being
/// left-clicked.
///
[Category(CategoryName)]
[Description("A command that is being executed if the tray icon is being left-clicked.")]
public ICommand LeftClickCommand
{
get { return (ICommand) GetValue(LeftClickCommandProperty); }
set { SetValue(LeftClickCommandProperty, value); }
}
#endregion
#region LeftClickCommandParameter dependency property
///
/// Command parameter for the .
///
public static readonly DependencyProperty LeftClickCommandParameterProperty =
DependencyProperty.Register(nameof(LeftClickCommandParameter),
typeof (object),
typeof (TaskbarIcon),
new FrameworkPropertyMetadata(null));
///
/// A property wrapper for the
/// dependency property:
/// Command parameter for the .
///
[Category(CategoryName)]
[Description("The target of the command that is fired if the notify icon is clicked with the left mouse button."
)]
public object LeftClickCommandParameter
{
get { return GetValue(LeftClickCommandParameterProperty); }
set { SetValue(LeftClickCommandParameterProperty, value); }
}
#endregion
#region LeftClickCommandTarget dependency property
///
/// The target of the command that is fired if the notify icon is clicked.
///
public static readonly DependencyProperty LeftClickCommandTargetProperty =
DependencyProperty.Register(nameof(LeftClickCommandTarget),
typeof (IInputElement),
typeof (TaskbarIcon),
new FrameworkPropertyMetadata(null));
///
/// A property wrapper for the
/// dependency property:
/// The target of the command that is fired if the notify icon is clicked.
///
[Category(CategoryName)]
[Description("The target of the command that is fired if the notify icon is clicked with the left mouse button."
)]
public IInputElement LeftClickCommandTarget
{
get { return (IInputElement) GetValue(LeftClickCommandTargetProperty); }
set { SetValue(LeftClickCommandTargetProperty, value); }
}
#endregion
#region NoLeftClickDelay dependency property
///
/// Set to true to make left clicks work without delay.
///
public static readonly DependencyProperty NoLeftClickDelayProperty =
DependencyProperty.Register(nameof(NoLeftClickDelay),
typeof(bool),
typeof(TaskbarIcon),
new FrameworkPropertyMetadata(false));
///
/// A property wrapper for the
/// dependency property:
/// Set to true to make left clicks work without delay.
///
[Category(CategoryName)]
[Description("Set to true to make left clicks work without delay.")]
public bool NoLeftClickDelay
{
get { return (bool)GetValue(NoLeftClickDelayProperty); }
set { SetValue(NoLeftClickDelayProperty, value); }
}
#endregion
//EVENTS
#region TrayLeftMouseDown
///
/// TrayLeftMouseDown Routed Event
///
public static readonly RoutedEvent TrayLeftMouseDownEvent = EventManager.RegisterRoutedEvent(
"TrayLeftMouseDown",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Occurs when the user presses the left mouse button.
///
[Category(CategoryName)]
public event RoutedEventHandler TrayLeftMouseDown
{
add { AddHandler(TrayLeftMouseDownEvent, value); }
remove { RemoveHandler(TrayLeftMouseDownEvent, value); }
}
///
/// A helper method to raise the TrayLeftMouseDown event.
///
protected RoutedEventArgs RaiseTrayLeftMouseDownEvent()
{
RoutedEventArgs args = RaiseTrayLeftMouseDownEvent(this);
return args;
}
///
/// A static helper method to raise the TrayLeftMouseDown event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaiseTrayLeftMouseDownEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(TrayLeftMouseDownEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
#region TrayRightMouseDown
///
/// TrayRightMouseDown Routed Event
///
public static readonly RoutedEvent TrayRightMouseDownEvent =
EventManager.RegisterRoutedEvent("TrayRightMouseDown",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Occurs when the presses the right mouse button.
///
public event RoutedEventHandler TrayRightMouseDown
{
add { AddHandler(TrayRightMouseDownEvent, value); }
remove { RemoveHandler(TrayRightMouseDownEvent, value); }
}
///
/// A helper method to raise the TrayRightMouseDown event.
///
protected RoutedEventArgs RaiseTrayRightMouseDownEvent()
{
return RaiseTrayRightMouseDownEvent(this);
}
///
/// A static helper method to raise the TrayRightMouseDown event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaiseTrayRightMouseDownEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(TrayRightMouseDownEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
#region TrayMiddleMouseDown
///
/// TrayMiddleMouseDown Routed Event
///
public static readonly RoutedEvent TrayMiddleMouseDownEvent =
EventManager.RegisterRoutedEvent("TrayMiddleMouseDown",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Occurs when the user presses the middle mouse button.
///
public event RoutedEventHandler TrayMiddleMouseDown
{
add { AddHandler(TrayMiddleMouseDownEvent, value); }
remove { RemoveHandler(TrayMiddleMouseDownEvent, value); }
}
///
/// A helper method to raise the TrayMiddleMouseDown event.
///
protected RoutedEventArgs RaiseTrayMiddleMouseDownEvent()
{
return RaiseTrayMiddleMouseDownEvent(this);
}
///
/// A static helper method to raise the TrayMiddleMouseDown event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaiseTrayMiddleMouseDownEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(TrayMiddleMouseDownEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
#region TrayLeftMouseUp
///
/// TrayLeftMouseUp Routed Event
///
public static readonly RoutedEvent TrayLeftMouseUpEvent = EventManager.RegisterRoutedEvent("TrayLeftMouseUp",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Occurs when the user releases the left mouse button.
///
public event RoutedEventHandler TrayLeftMouseUp
{
add { AddHandler(TrayLeftMouseUpEvent, value); }
remove { RemoveHandler(TrayLeftMouseUpEvent, value); }
}
///
/// A helper method to raise the TrayLeftMouseUp event.
///
protected RoutedEventArgs RaiseTrayLeftMouseUpEvent()
{
return RaiseTrayLeftMouseUpEvent(this);
}
///
/// A static helper method to raise the TrayLeftMouseUp event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaiseTrayLeftMouseUpEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(TrayLeftMouseUpEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
#region TrayRightMouseUp
///
/// TrayRightMouseUp Routed Event
///
public static readonly RoutedEvent TrayRightMouseUpEvent = EventManager.RegisterRoutedEvent("TrayRightMouseUp",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Occurs when the user releases the right mouse button.
///
public event RoutedEventHandler TrayRightMouseUp
{
add { AddHandler(TrayRightMouseUpEvent, value); }
remove { RemoveHandler(TrayRightMouseUpEvent, value); }
}
///
/// A helper method to raise the TrayRightMouseUp event.
///
protected RoutedEventArgs RaiseTrayRightMouseUpEvent()
{
return RaiseTrayRightMouseUpEvent(this);
}
///
/// A static helper method to raise the TrayRightMouseUp event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaiseTrayRightMouseUpEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(TrayRightMouseUpEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
#region TrayMiddleMouseUp
///
/// TrayMiddleMouseUp Routed Event
///
public static readonly RoutedEvent TrayMiddleMouseUpEvent = EventManager.RegisterRoutedEvent(
"TrayMiddleMouseUp",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Occurs when the user releases the middle mouse button.
///
public event RoutedEventHandler TrayMiddleMouseUp
{
add { AddHandler(TrayMiddleMouseUpEvent, value); }
remove { RemoveHandler(TrayMiddleMouseUpEvent, value); }
}
///
/// A helper method to raise the TrayMiddleMouseUp event.
///
protected RoutedEventArgs RaiseTrayMiddleMouseUpEvent()
{
return RaiseTrayMiddleMouseUpEvent(this);
}
///
/// A static helper method to raise the TrayMiddleMouseUp event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaiseTrayMiddleMouseUpEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(TrayMiddleMouseUpEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
#region TrayMouseDoubleClick
///
/// TrayMouseDoubleClick Routed Event
///
public static readonly RoutedEvent TrayMouseDoubleClickEvent =
EventManager.RegisterRoutedEvent("TrayMouseDoubleClick",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Occurs when the user double-clicks the taskbar icon.
///
public event RoutedEventHandler TrayMouseDoubleClick
{
add { AddHandler(TrayMouseDoubleClickEvent, value); }
remove { RemoveHandler(TrayMouseDoubleClickEvent, value); }
}
///
/// A helper method to raise the TrayMouseDoubleClick event.
///
protected RoutedEventArgs RaiseTrayMouseDoubleClickEvent()
{
RoutedEventArgs args = RaiseTrayMouseDoubleClickEvent(this);
DoubleClickCommand.ExecuteIfEnabled(DoubleClickCommandParameter, DoubleClickCommandTarget ?? this);
return args;
}
///
/// A static helper method to raise the TrayMouseDoubleClick event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaiseTrayMouseDoubleClickEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(TrayMouseDoubleClickEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
#region TrayMouseMove
///
/// TrayMouseMove Routed Event
///
public static readonly RoutedEvent TrayMouseMoveEvent = EventManager.RegisterRoutedEvent("TrayMouseMove",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Occurs when the user moves the mouse over the taskbar icon.
///
public event RoutedEventHandler TrayMouseMove
{
add { AddHandler(TrayMouseMoveEvent, value); }
remove { RemoveHandler(TrayMouseMoveEvent, value); }
}
///
/// A helper method to raise the TrayMouseMove event.
///
protected RoutedEventArgs RaiseTrayMouseMoveEvent()
{
return RaiseTrayMouseMoveEvent(this);
}
///
/// A static helper method to raise the TrayMouseMove event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaiseTrayMouseMoveEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(TrayMouseMoveEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
#region TrayBalloonTipShown
///
/// TrayBalloonTipShown Routed Event
///
public static readonly RoutedEvent TrayBalloonTipShownEvent =
EventManager.RegisterRoutedEvent("TrayBalloonTipShown",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Occurs when a balloon ToolTip is displayed.
///
public event RoutedEventHandler TrayBalloonTipShown
{
add { AddHandler(TrayBalloonTipShownEvent, value); }
remove { RemoveHandler(TrayBalloonTipShownEvent, value); }
}
///
/// A helper method to raise the TrayBalloonTipShown event.
///
protected RoutedEventArgs RaiseTrayBalloonTipShownEvent()
{
return RaiseTrayBalloonTipShownEvent(this);
}
///
/// A static helper method to raise the TrayBalloonTipShown event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaiseTrayBalloonTipShownEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(TrayBalloonTipShownEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
#region TrayBalloonTipClosed
///
/// TrayBalloonTipClosed Routed Event
///
public static readonly RoutedEvent TrayBalloonTipClosedEvent =
EventManager.RegisterRoutedEvent("TrayBalloonTipClosed",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Occurs when a balloon ToolTip was closed.
///
public event RoutedEventHandler TrayBalloonTipClosed
{
add { AddHandler(TrayBalloonTipClosedEvent, value); }
remove { RemoveHandler(TrayBalloonTipClosedEvent, value); }
}
///
/// A helper method to raise the TrayBalloonTipClosed event.
///
protected RoutedEventArgs RaiseTrayBalloonTipClosedEvent()
{
return RaiseTrayBalloonTipClosedEvent(this);
}
///
/// A static helper method to raise the TrayBalloonTipClosed event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaiseTrayBalloonTipClosedEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(TrayBalloonTipClosedEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
#region TrayBalloonTipClicked
///
/// TrayBalloonTipClicked Routed Event
///
public static readonly RoutedEvent TrayBalloonTipClickedEvent =
EventManager.RegisterRoutedEvent("TrayBalloonTipClicked",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Occurs when the user clicks on a balloon ToolTip.
///
public event RoutedEventHandler TrayBalloonTipClicked
{
add { AddHandler(TrayBalloonTipClickedEvent, value); }
remove { RemoveHandler(TrayBalloonTipClickedEvent, value); }
}
///
/// A helper method to raise the TrayBalloonTipClicked event.
///
protected RoutedEventArgs RaiseTrayBalloonTipClickedEvent()
{
return RaiseTrayBalloonTipClickedEvent(this);
}
///
/// A static helper method to raise the TrayBalloonTipClicked event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaiseTrayBalloonTipClickedEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(TrayBalloonTipClickedEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
#region TrayContextMenuOpen (and PreviewTrayContextMenuOpen)
///
/// TrayContextMenuOpen Routed Event
///
public static readonly RoutedEvent TrayContextMenuOpenEvent =
EventManager.RegisterRoutedEvent("TrayContextMenuOpen",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Bubbled event that occurs when the context menu of the taskbar icon is being displayed.
///
public event RoutedEventHandler TrayContextMenuOpen
{
add { AddHandler(TrayContextMenuOpenEvent, value); }
remove { RemoveHandler(TrayContextMenuOpenEvent, value); }
}
///
/// A helper method to raise the TrayContextMenuOpen event.
///
protected RoutedEventArgs RaiseTrayContextMenuOpenEvent()
{
return RaiseTrayContextMenuOpenEvent(this);
}
///
/// A static helper method to raise the TrayContextMenuOpen event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaiseTrayContextMenuOpenEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(TrayContextMenuOpenEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
///
/// PreviewTrayContextMenuOpen Routed Event
///
public static readonly RoutedEvent PreviewTrayContextMenuOpenEvent =
EventManager.RegisterRoutedEvent("PreviewTrayContextMenuOpen",
RoutingStrategy.Tunnel, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Tunneled event that occurs when the context menu of the taskbar icon is being displayed.
///
public event RoutedEventHandler PreviewTrayContextMenuOpen
{
add { AddHandler(PreviewTrayContextMenuOpenEvent, value); }
remove { RemoveHandler(PreviewTrayContextMenuOpenEvent, value); }
}
///
/// A helper method to raise the PreviewTrayContextMenuOpen event.
///
protected RoutedEventArgs RaisePreviewTrayContextMenuOpenEvent()
{
return RaisePreviewTrayContextMenuOpenEvent(this);
}
///
/// A static helper method to raise the PreviewTrayContextMenuOpen event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaisePreviewTrayContextMenuOpenEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(PreviewTrayContextMenuOpenEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
#region TrayPopupOpen (and PreviewTrayPopupOpen)
///
/// TrayPopupOpen Routed Event
///
public static readonly RoutedEvent TrayPopupOpenEvent = EventManager.RegisterRoutedEvent("TrayPopupOpen",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Bubbled event that occurs when the custom popup is being opened.
///
public event RoutedEventHandler TrayPopupOpen
{
add { AddHandler(TrayPopupOpenEvent, value); }
remove { RemoveHandler(TrayPopupOpenEvent, value); }
}
///
/// A helper method to raise the TrayPopupOpen event.
///
protected RoutedEventArgs RaiseTrayPopupOpenEvent()
{
return RaiseTrayPopupOpenEvent(this);
}
///
/// A static helper method to raise the TrayPopupOpen event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaiseTrayPopupOpenEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(TrayPopupOpenEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
///
/// PreviewTrayPopupOpen Routed Event
///
public static readonly RoutedEvent PreviewTrayPopupOpenEvent =
EventManager.RegisterRoutedEvent("PreviewTrayPopupOpen",
RoutingStrategy.Tunnel, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Tunneled event that occurs when the custom popup is being opened.
///
public event RoutedEventHandler PreviewTrayPopupOpen
{
add { AddHandler(PreviewTrayPopupOpenEvent, value); }
remove { RemoveHandler(PreviewTrayPopupOpenEvent, value); }
}
///
/// A helper method to raise the PreviewTrayPopupOpen event.
///
protected RoutedEventArgs RaisePreviewTrayPopupOpenEvent()
{
return RaisePreviewTrayPopupOpenEvent(this);
}
///
/// A static helper method to raise the PreviewTrayPopupOpen event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaisePreviewTrayPopupOpenEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(PreviewTrayPopupOpenEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
#region TrayToolTipOpen (and PreviewTrayToolTipOpen)
///
/// TrayToolTipOpen Routed Event
///
public static readonly RoutedEvent TrayToolTipOpenEvent = EventManager.RegisterRoutedEvent("TrayToolTipOpen",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Bubbled event that occurs when the custom ToolTip is being displayed.
///
public event RoutedEventHandler TrayToolTipOpen
{
add { AddHandler(TrayToolTipOpenEvent, value); }
remove { RemoveHandler(TrayToolTipOpenEvent, value); }
}
///
/// A helper method to raise the TrayToolTipOpen event.
///
protected RoutedEventArgs RaiseTrayToolTipOpenEvent()
{
return RaiseTrayToolTipOpenEvent(this);
}
///
/// A static helper method to raise the TrayToolTipOpen event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaiseTrayToolTipOpenEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(TrayToolTipOpenEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
///
/// PreviewTrayToolTipOpen Routed Event
///
public static readonly RoutedEvent PreviewTrayToolTipOpenEvent =
EventManager.RegisterRoutedEvent("PreviewTrayToolTipOpen",
RoutingStrategy.Tunnel, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Tunneled event that occurs when the custom ToolTip is being displayed.
///
public event RoutedEventHandler PreviewTrayToolTipOpen
{
add { AddHandler(PreviewTrayToolTipOpenEvent, value); }
remove { RemoveHandler(PreviewTrayToolTipOpenEvent, value); }
}
///
/// A helper method to raise the PreviewTrayToolTipOpen event.
///
protected RoutedEventArgs RaisePreviewTrayToolTipOpenEvent()
{
return RaisePreviewTrayToolTipOpenEvent(this);
}
///
/// A static helper method to raise the PreviewTrayToolTipOpen event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaisePreviewTrayToolTipOpenEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(PreviewTrayToolTipOpenEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
#region TrayToolTipClose (and PreviewTrayToolTipClose)
///
/// TrayToolTipClose Routed Event
///
public static readonly RoutedEvent TrayToolTipCloseEvent = EventManager.RegisterRoutedEvent("TrayToolTipClose",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Bubbled event that occurs when a custom tooltip is being closed.
///
public event RoutedEventHandler TrayToolTipClose
{
add { AddHandler(TrayToolTipCloseEvent, value); }
remove { RemoveHandler(TrayToolTipCloseEvent, value); }
}
///
/// A helper method to raise the TrayToolTipClose event.
///
protected RoutedEventArgs RaiseTrayToolTipCloseEvent()
{
return RaiseTrayToolTipCloseEvent(this);
}
///
/// A static helper method to raise the TrayToolTipClose event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaiseTrayToolTipCloseEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(TrayToolTipCloseEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
///
/// PreviewTrayToolTipClose Routed Event
///
public static readonly RoutedEvent PreviewTrayToolTipCloseEvent =
EventManager.RegisterRoutedEvent("PreviewTrayToolTipClose",
RoutingStrategy.Tunnel, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Tunneled event that occurs when a custom tooltip is being closed.
///
public event RoutedEventHandler PreviewTrayToolTipClose
{
add { AddHandler(PreviewTrayToolTipCloseEvent, value); }
remove { RemoveHandler(PreviewTrayToolTipCloseEvent, value); }
}
///
/// A helper method to raise the PreviewTrayToolTipClose event.
///
protected RoutedEventArgs RaisePreviewTrayToolTipCloseEvent()
{
return RaisePreviewTrayToolTipCloseEvent(this);
}
///
/// A static helper method to raise the PreviewTrayToolTipClose event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaisePreviewTrayToolTipCloseEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(PreviewTrayToolTipCloseEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
//ATTACHED EVENTS
#region PopupOpened
///
/// PopupOpened Attached Routed Event
///
public static readonly RoutedEvent PopupOpenedEvent = EventManager.RegisterRoutedEvent("PopupOpened",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Adds a handler for the PopupOpened attached event
///
/// UIElement or ContentElement that listens to the event
/// Event handler to be added
public static void AddPopupOpenedHandler(DependencyObject element, RoutedEventHandler handler)
{
RoutedEventHelper.AddHandler(element, PopupOpenedEvent, handler);
}
///
/// Removes a handler for the PopupOpened attached event
///
/// UIElement or ContentElement that listens to the event
/// Event handler to be removed
public static void RemovePopupOpenedHandler(DependencyObject element, RoutedEventHandler handler)
{
RoutedEventHelper.RemoveHandler(element, PopupOpenedEvent, handler);
}
///
/// A static helper method to raise the PopupOpened event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaisePopupOpenedEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(PopupOpenedEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
#region ToolTipOpened
///
/// ToolTipOpened Attached Routed Event
///
public static readonly RoutedEvent ToolTipOpenedEvent = EventManager.RegisterRoutedEvent("ToolTipOpened",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Adds a handler for the ToolTipOpened attached event
///
/// UIElement or ContentElement that listens to the event
/// Event handler to be added
public static void AddToolTipOpenedHandler(DependencyObject element, RoutedEventHandler handler)
{
RoutedEventHelper.AddHandler(element, ToolTipOpenedEvent, handler);
}
///
/// Removes a handler for the ToolTipOpened attached event
///
/// UIElement or ContentElement that listens to the event
/// Event handler to be removed
public static void RemoveToolTipOpenedHandler(DependencyObject element, RoutedEventHandler handler)
{
RoutedEventHelper.RemoveHandler(element, ToolTipOpenedEvent, handler);
}
///
/// A static helper method to raise the ToolTipOpened event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaiseToolTipOpenedEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(ToolTipOpenedEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
#region ToolTipClose
///
/// ToolTipClose Attached Routed Event
///
public static readonly RoutedEvent ToolTipCloseEvent = EventManager.RegisterRoutedEvent("ToolTipClose",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Adds a handler for the ToolTipClose attached event
///
/// UIElement or ContentElement that listens to the event
/// Event handler to be added
public static void AddToolTipCloseHandler(DependencyObject element, RoutedEventHandler handler)
{
RoutedEventHelper.AddHandler(element, ToolTipCloseEvent, handler);
}
///
/// Removes a handler for the ToolTipClose attached event
///
/// UIElement or ContentElement that listens to the event
/// Event handler to be removed
public static void RemoveToolTipCloseHandler(DependencyObject element, RoutedEventHandler handler)
{
RoutedEventHelper.RemoveHandler(element, ToolTipCloseEvent, handler);
}
///
/// A static helper method to raise the ToolTipClose event on a target element.
///
/// UIElement or ContentElement on which to raise the event
internal static RoutedEventArgs RaiseToolTipCloseEvent(DependencyObject target)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(ToolTipCloseEvent);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
#region BalloonShowing
///
/// BalloonShowing Attached Routed Event
///
public static readonly RoutedEvent BalloonShowingEvent = EventManager.RegisterRoutedEvent("BalloonShowing",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Adds a handler for the BalloonShowing attached event
///
/// UIElement or ContentElement that listens to the event
/// Event handler to be added
public static void AddBalloonShowingHandler(DependencyObject element, RoutedEventHandler handler)
{
RoutedEventHelper.AddHandler(element, BalloonShowingEvent, handler);
}
///
/// Removes a handler for the BalloonShowing attached event
///
/// UIElement or ContentElement that listens to the event
/// Event handler to be removed
public static void RemoveBalloonShowingHandler(DependencyObject element, RoutedEventHandler handler)
{
RoutedEventHelper.RemoveHandler(element, BalloonShowingEvent, handler);
}
///
/// A static helper method to raise the BalloonShowing event on a target element.
///
/// UIElement or ContentElement on which to raise the event
/// The instance that manages the balloon.
internal static RoutedEventArgs RaiseBalloonShowingEvent(DependencyObject target, TaskbarIcon source)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(BalloonShowingEvent, source);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
#region BalloonClosing
///
/// BalloonClosing Attached Routed Event
///
public static readonly RoutedEvent BalloonClosingEvent = EventManager.RegisterRoutedEvent("BalloonClosing",
RoutingStrategy.Bubble, typeof (RoutedEventHandler), typeof (TaskbarIcon));
///
/// Adds a handler for the BalloonClosing attached event
///
/// UIElement or ContentElement that listens to the event
/// Event handler to be added
public static void AddBalloonClosingHandler(DependencyObject element, RoutedEventHandler handler)
{
RoutedEventHelper.AddHandler(element, BalloonClosingEvent, handler);
}
///
/// Removes a handler for the BalloonClosing attached event
///
/// UIElement or ContentElement that listens to the event
/// Event handler to be removed
public static void RemoveBalloonClosingHandler(DependencyObject element, RoutedEventHandler handler)
{
RoutedEventHelper.RemoveHandler(element, BalloonClosingEvent, handler);
}
///
/// A static helper method to raise the BalloonClosing event on a target element.
///
/// UIElement or ContentElement on which to raise the event
/// The instance that manages the balloon.
internal static RoutedEventArgs RaiseBalloonClosingEvent(DependencyObject target, TaskbarIcon source)
{
if (target == null) return null;
RoutedEventArgs args = new RoutedEventArgs(BalloonClosingEvent, source);
RoutedEventHelper.RaiseEvent(target, args);
return args;
}
#endregion
//ATTACHED PROPERTIES
#region ParentTaskbarIcon
///
/// An attached property that is assigned to displayed UI elements (balloons, tooltips, context menus), and
/// that can be used to bind to this control. The attached property is being derived, so binding is
/// quite straightforward:
///
///
///
///
public static readonly DependencyProperty ParentTaskbarIconProperty =
DependencyProperty.RegisterAttached("ParentTaskbarIcon", typeof (TaskbarIcon), typeof (TaskbarIcon),
new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));
///
/// Gets the ParentTaskbarIcon property. This dependency property
/// indicates ....
///
public static TaskbarIcon GetParentTaskbarIcon(DependencyObject d)
{
return (TaskbarIcon) d.GetValue(ParentTaskbarIconProperty);
}
///
/// Sets the ParentTaskbarIcon property. This dependency property
/// indicates ....
///
public static void SetParentTaskbarIcon(DependencyObject d, TaskbarIcon value)
{
d.SetValue(ParentTaskbarIconProperty, value);
}
#endregion
//BASE CLASS PROPERTY OVERRIDES
///
/// Registers properties.
///
static TaskbarIcon()
{
//register change listener for the Visibility property
var md = new PropertyMetadata(Visibility.Visible, VisibilityPropertyChanged);
VisibilityProperty.OverrideMetadata(typeof (TaskbarIcon), md);
//register change listener for the DataContext property
md = new FrameworkPropertyMetadata(DataContextPropertyChanged);
DataContextProperty.OverrideMetadata(typeof (TaskbarIcon), md);
//register change listener for the ContextMenu property
md = new FrameworkPropertyMetadata(ContextMenuPropertyChanged);
ContextMenuProperty.OverrideMetadata(typeof (TaskbarIcon), md);
}
}
}