Sean/WPFToolkit
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Init

Browse Source
This commit is contained in:
Sean Kessler
2024-02-23 07:03:56 -05:00
commit 4a3813687a
937 changed files with 113251 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

359
Src/Xceed.Wpf.Toolkit/BusyIndicator/Implementation/BusyIndicator.cs Normal file
View File

@@ -0,0 +1,359 @@
/*************************************************************************************
Extended WPF Toolkit
Copyright (C) 2007-2013 Xceed Software Inc.
This program is provided to you under the terms of the Microsoft Public
License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license
For more features, controls, and fast professional support,
pick up the Plus Edition at http://xceed.com/wpf_toolkit
Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
***********************************************************************************/
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Shapes;
using System.Windows.Threading;
namespace Xceed.Wpf.Toolkit
{
/// <summary>
/// A control to provide a visual indicator when an application is busy.
/// </summary>
[TemplateVisualState( Name = VisualStates.StateIdle, GroupName = VisualStates.GroupBusyStatus )]
[TemplateVisualState( Name = VisualStates.StateBusy, GroupName = VisualStates.GroupBusyStatus )]
[TemplateVisualState( Name = VisualStates.StateVisible, GroupName = VisualStates.GroupVisibility )]
[TemplateVisualState( Name = VisualStates.StateHidden, GroupName = VisualStates.GroupVisibility )]
[StyleTypedProperty( Property = "OverlayStyle", StyleTargetType = typeof( Rectangle ) )]
[StyleTypedProperty( Property = "ProgressBarStyle", StyleTargetType = typeof( ProgressBar ) )]
public class BusyIndicator : ContentControl
{
#region Private Members
/// <summary>
/// Timer used to delay the initial display and avoid flickering.
/// </summary>
private DispatcherTimer _displayAfterTimer = new DispatcherTimer();
#endregion //Private Members
#region Constructors
static BusyIndicator()
{
DefaultStyleKeyProperty.OverrideMetadata( typeof( BusyIndicator ), new FrameworkPropertyMetadata( typeof( BusyIndicator ) ) );
}
public BusyIndicator()
{
_displayAfterTimer.Tick += DisplayAfterTimerElapsed;
}
#endregion //Constructors
#region Base Class Overrides
/// <summary>
/// Overrides the OnApplyTemplate method.
/// </summary>
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
ChangeVisualState( false );
}
#endregion //Base Class Overrides
#region Properties
/// <summary>
/// Gets or sets a value indicating whether the BusyContent is visible.
/// </summary>
protected bool IsContentVisible
{
get;
set;
}
#endregion //Properties
#region Dependency Properties
#region IsBusy
/// <summary>
/// Identifies the IsBusy dependency property.
/// </summary>
public static readonly DependencyProperty IsBusyProperty = DependencyProperty.Register(
"IsBusy",
typeof( bool ),
typeof( BusyIndicator ),
new PropertyMetadata( false, new PropertyChangedCallback( OnIsBusyChanged ) ) );
/// <summary>
/// Gets or sets a value indicating whether the busy indicator should show.
/// </summary>
public bool IsBusy
{
get
{
return ( bool )GetValue( IsBusyProperty );
}
set
{
SetValue( IsBusyProperty, value );
}
}
/// <summary>
/// IsBusyProperty property changed handler.
/// </summary>
/// <param name="d">BusyIndicator that changed its IsBusy.</param>
/// <param name="e">Event arguments.</param>
private static void OnIsBusyChanged( DependencyObject d, DependencyPropertyChangedEventArgs e )
{
( ( BusyIndicator )d ).OnIsBusyChanged( e );
}
/// <summary>
/// IsBusyProperty property changed handler.
/// </summary>
/// <param name="e">Event arguments.</param>
protected virtual void OnIsBusyChanged( DependencyPropertyChangedEventArgs e )
{
if( IsBusy )
{
if( DisplayAfter.Equals( TimeSpan.Zero ) )
{
// Go visible now
IsContentVisible = true;
}
else
{
// Set a timer to go visible
_displayAfterTimer.Interval = DisplayAfter;
_displayAfterTimer.Start();
}
}
else
{
// No longer visible
_displayAfterTimer.Stop();
IsContentVisible = false;
if( this.FocusAfterBusy != null )
{
this.FocusAfterBusy.Dispatcher.BeginInvoke( DispatcherPriority.Input, new Action( () =>
{
this.FocusAfterBusy.Focus();
}
) );
}
}
ChangeVisualState( true );
}
#endregion //IsBusy
#region Busy Content
/// <summary>
/// Identifies the BusyContent dependency property.
/// </summary>
public static readonly DependencyProperty BusyContentProperty = DependencyProperty.Register(
"BusyContent",
typeof( object ),
typeof( BusyIndicator ),
new PropertyMetadata( null ) );
/// <summary>
/// Gets or sets a value indicating the busy content to display to the user.
/// </summary>
public object BusyContent
{
get
{
return ( object )GetValue( BusyContentProperty );
}
set
{
SetValue( BusyContentProperty, value );
}
}
#endregion //Busy Content
#region Busy Content Template
/// <summary>
/// Identifies the BusyTemplate dependency property.
/// </summary>
public static readonly DependencyProperty BusyContentTemplateProperty = DependencyProperty.Register(
"BusyContentTemplate",
typeof( DataTemplate ),
typeof( BusyIndicator ),
new PropertyMetadata( null ) );
/// <summary>
/// Gets or sets a value indicating the template to use for displaying the busy content to the user.
/// </summary>
public DataTemplate BusyContentTemplate
{
get
{
return ( DataTemplate )GetValue( BusyContentTemplateProperty );
}
set
{
SetValue( BusyContentTemplateProperty, value );
}
}
#endregion //Busy Content Template
#region Display After
/// <summary>
/// Identifies the DisplayAfter dependency property.
/// </summary>
public static readonly DependencyProperty DisplayAfterProperty = DependencyProperty.Register(
"DisplayAfter",
typeof( TimeSpan ),
typeof( BusyIndicator ),
new PropertyMetadata( TimeSpan.FromSeconds( 0.1 ) ) );
/// <summary>
/// Gets or sets a value indicating how long to delay before displaying the busy content.
/// </summary>
public TimeSpan DisplayAfter
{
get
{
return ( TimeSpan )GetValue( DisplayAfterProperty );
}
set
{
SetValue( DisplayAfterProperty, value );
}
}
#endregion //Display After
#region FocusAfterBusy
/// <summary>
/// Identifies the FocusAfterBusy dependency property.
/// </summary>
public static readonly DependencyProperty FocusAfterBusyProperty = DependencyProperty.Register(
"FocusAfterBusy",
typeof( Control ),
typeof( BusyIndicator ),
new PropertyMetadata( null ) );
/// <summary>
/// Gets or sets a Control that should get focus when the busy indicator disapears.
/// </summary>
public Control FocusAfterBusy
{
get
{
return ( Control )GetValue( FocusAfterBusyProperty );
}
set
{
SetValue( FocusAfterBusyProperty, value );
}
}
#endregion //FocusAfterBusy
#region Overlay Style
/// <summary>
/// Identifies the OverlayStyle dependency property.
/// </summary>
public static readonly DependencyProperty OverlayStyleProperty = DependencyProperty.Register(
"OverlayStyle",
typeof( Style ),
typeof( BusyIndicator ),
new PropertyMetadata( null ) );
/// <summary>
/// Gets or sets a value indicating the style to use for the overlay.
/// </summary>
public Style OverlayStyle
{
get
{
return ( Style )GetValue( OverlayStyleProperty );
}
set
{
SetValue( OverlayStyleProperty, value );
}
}
#endregion //Overlay Style
#region ProgressBar Style
/// <summary>
/// Identifies the ProgressBarStyle dependency property.
/// </summary>
public static readonly DependencyProperty ProgressBarStyleProperty = DependencyProperty.Register(
"ProgressBarStyle",
typeof( Style ),
typeof( BusyIndicator ),
new PropertyMetadata( null ) );
/// <summary>
/// Gets or sets a value indicating the style to use for the progress bar.
/// </summary>
public Style ProgressBarStyle
{
get
{
return ( Style )GetValue( ProgressBarStyleProperty );
}
set
{
SetValue( ProgressBarStyleProperty, value );
}
}
#endregion //ProgressBar Style
#endregion //Dependency Properties
#region Methods
/// <summary>
/// Handler for the DisplayAfterTimer.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event arguments.</param>
private void DisplayAfterTimerElapsed( object sender, EventArgs e )
{
_displayAfterTimer.Stop();
IsContentVisible = true;
ChangeVisualState( true );
}
/// <summary>
/// Changes the control's visual state(s).
/// </summary>
/// <param name="useTransitions">True if state transitions should be used.</param>
protected virtual void ChangeVisualState( bool useTransitions )
{
VisualStateManager.GoToState( this, IsBusy ? VisualStates.StateBusy : VisualStates.StateIdle, useTransitions );
VisualStateManager.GoToState( this, IsContentVisible ? VisualStates.StateVisible : VisualStates.StateHidden, useTransitions );
}
#endregion //Methods
}
}

41
Src/Xceed.Wpf.Toolkit/BusyIndicator/Implementation/Converters/ProgressBarWidthConverter.cs Normal file
View File

@@ -0,0 +1,41 @@
/*************************************************************************************
Extended WPF Toolkit
Copyright (C) 2007-2013 Xceed Software Inc.
This program is provided to you under the terms of the Microsoft Public
License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license
For more features, controls, and fast professional support,
pick up the Plus Edition at http://xceed.com/wpf_toolkit
Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
***********************************************************************************/
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Windows.Data;
namespace Xceed.Wpf.Toolkit.Converters
{
public class ProgressBarWidthConverter : IMultiValueConverter
{
public object Convert( object[] values, Type targetType, object parameter, CultureInfo culture )
{
var contentWidth = ( double )values[ 0 ];
var parentMinWidth = ( double )values[ 1 ];
return Math.Max( contentWidth, parentMinWidth );
}
public object[] ConvertBack( object value, Type[] targetTypes, object parameter, CultureInfo culture )
{
throw new NotImplementedException();
}
}
}

51
Src/Xceed.Wpf.Toolkit/BusyIndicator/Implementation/VisualStates.BusyIndicator.cs Normal file
View File

@@ -0,0 +1,51 @@
/*************************************************************************************
Extended WPF Toolkit
Copyright (C) 2007-2013 Xceed Software Inc.
This program is provided to you under the terms of the Microsoft Public
License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license
For more features, controls, and fast professional support,
pick up the Plus Edition at http://xceed.com/wpf_toolkit
Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
***********************************************************************************/
namespace Xceed.Wpf.Toolkit
{
internal static partial class VisualStates
{
/// <summary>
/// Busyness group name.
/// </summary>
public const string GroupBusyStatus = "BusyStatusStates";
/// <summary>
/// Busy state for BusyIndicator.
/// </summary>
public const string StateBusy = "Busy";
/// <summary>
/// Idle state for BusyIndicator.
/// </summary>
public const string StateIdle = "Idle";
/// <summary>
/// BusyDisplay group.
/// </summary>
public const string GroupVisibility = "VisibilityStates";
/// <summary>
/// Visible state name for BusyIndicator.
/// </summary>
public const string StateVisible = "Visible";
/// <summary>
/// Hidden state name for BusyIndicator.
/// </summary>
public const string StateHidden = "Hidden";
}
}