using System;
using System.ComponentModel.Composition;
using System.Threading;
using System.Timers;
using System.Windows;
using System.Windows.Media;
using System.Windows.Threading;
using MefBasic;
using MefBasic.Commans;
using MefBasic.Extensions;
using Microsoft.Practices.Composite.Events;
using Timer = System.Timers.Timer;
namespace MediaAssistant.Controls.WaitScreen
{
[Export]
public class WaitScreenPresenter : APresenter<SmallWaitScreenView>
{
public static readonly DependencyProperty MessageProperty = DependencyProperty.Register(
"Message",
typeof (string),
typeof (WaitScreenPresenter));
private readonly Dispatcher _dispatcher;
private readonly Timer _hideTimer;
private bool _isLoaded;
private bool _isShown;
private Window _waitScreenWindow;
[ImportingConstructor]
public WaitScreenPresenter(SmallWaitScreenView view)
: base(view)
{
if (Application.Current != null)
{
_dispatcher = Application.Current.Dispatcher;
}
_hideTimer = new Timer();
_hideTimer.Elapsed += HideTimerElapsed;
_hideTimer.Interval = 300;
_hideTimer.Enabled = false;
Enabled = true;
(view).Loaded += WaitScreenPresenterLoaded;
}
[Import]
public IEventAggregator EventAggreagtor { get; set; }
public Visibility ProgressBarVisibility
{
get { return (Visibility)GetValue(ProgressBarVisibilityProperty); }
set { SetValue(ProgressBarVisibilityProperty, value); }
}
public static readonly DependencyProperty ProgressBarVisibilityProperty =
DependencyProperty.Register("ProgressBarVisibility", typeof(Visibility), typeof(WaitScreenPresenter), new UIPropertyMetadata(Visibility.Collapsed));
public int Maximum
{
get { return (int)GetValue(MaximumProperty); }
set { SetValue(MaximumProperty, value); }
}
public static readonly DependencyProperty MaximumProperty =
DependencyProperty.Register("Maximum", typeof(int), typeof(WaitScreenPresenter), new UIPropertyMetadata(0));
public int Minimum
{
get { return (int)GetValue(MinimumProperty); }
set { SetValue(MinimumProperty, value); }
}
public static readonly DependencyProperty MinimumProperty =
DependencyProperty.Register("Minimum", typeof(int), typeof(WaitScreenPresenter), new UIPropertyMetadata(0));
public int Value
{
get { return (int)GetValue(ValueProperty); }
set { SetValue(ValueProperty, value); }
}
public static readonly DependencyProperty ValueProperty =
DependencyProperty.Register("Value", typeof(int), typeof(WaitScreenPresenter), new UIPropertyMetadata(0));
protected Window WaitScreenWindow
{
get
{
if (_waitScreenWindow == null)
{
if ((View).Parent != null)
{
((Window) (View).Parent).Content = null;
}
_waitScreenWindow = new Window
{
AllowsTransparency = true,
Content = View,
WindowStyle = WindowStyle.None,
ShowInTaskbar = false,
Background = new SolidColorBrush(Colors.Transparent),
Padding = new Thickness(0),
Margin = new Thickness(0),
WindowState = WindowState.Normal,
WindowStartupLocation = WindowStartupLocation.CenterOwner,
SizeToContent = SizeToContent.WidthAndHeight,
};
}
return _waitScreenWindow;
}
}
public bool Enabled { get; set; }
public string Message
{
get { return (string) GetValue(MessageProperty); }
set { SetValue(MessageProperty, value); }
}
public bool DisableParent { get; set; }
public object Initiator { get; set; }
private void WaitScreenPresenterLoaded(object sender, RoutedEventArgs e)
{
_isLoaded = true;
}
public void HideNow()
{
HideWaitScreenHandler();
}
private void HideTimerElapsed(object sender, ElapsedEventArgs e)
{
_hideTimer.Stop();
if (_dispatcher != null)
_dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(HideWaitScreenHandler));
}
private void HideWaitScreenHandler()
{
if ((View).Parent != null)
{
((Window) (View).Parent).Content = null;
}
_isShown = false;
WaitScreenWindow.Close();
if (DisableParent && Application.Current != null)
{
if (Application.Current.MainWindow != null)
{
PublishShellDisabledChanged(false);
Application.Current.MainWindow.Focus();
}
}
_waitScreenWindow = null;
}
public bool Show()
{
ProgressBarVisibility = Visibility.Collapsed;
return Show("Please Wait...", true);
}
public bool Show(string message)
{
ProgressBarVisibility = Visibility.Collapsed;
return Show(message, true);
}
public bool Show(int minimum, int maximum, int value)
{
Minimum = minimum;
Maximum = maximum;
Value = value;
ProgressBarVisibility = Visibility.Visible;
return Show(GetProgressMessage(), true);
}
public bool Show(int value)
{
Value = value;
ProgressBarVisibility = Visibility.Visible;
return Show(GetProgressMessage(), true);
}
private string GetProgressMessage()
{
return string.Format("{0} of {1}",Value,Maximum-Minimum);
}
private void ShowWaitScreenHandler()
{
if (_isShown)
{
_hideTimer.Stop();
return;
}
_isShown = true;
if (Application.Current.MainWindow is IMainWindow)
WaitScreenWindow.Owner = Application.Current.MainWindow;
WaitScreenWindow.Show();
if (DisableParent)
PublishShellDisabledChanged(true);
}
private void PublishShellDisabledChanged(bool disabled)
{
EventAggreagtor.GetEvent<BaseEvent<ShellDisabledChangedEventArgs>>().Publish(new ShellDisabledChangedEventArgs {Sender = this,Disabled = disabled});
}
public bool Hide()
{
if (_isShown == false)
return false;
if (Initiator != null)
return false;
_hideTimer.Start();
return true;
}
public bool Show(string message, bool disableParent)
{
Message = message;
if (_isShown)
return false;
DisableParent = disableParent;
if (Enabled && _dispatcher != null)
{
_dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(ShowWaitScreenHandler));
Block(true);
}
return true;
}
private void Block(bool loaded)
{
if (Application.Current == null)
return;
while (true)
{
Application.Current.DoEvents();
Thread.Sleep(5);
if (_isLoaded != loaded)
continue;
break;
}
}
public bool Show(object initiator)
{
if (_isShown)
return false;
if (Initiator == null)
{
Initiator = initiator;
return Show();
}
return false;
}
public bool Hide(object initiator)
{
if (Initiator != null && Initiator.Equals(initiator))
{
Initiator = null;
return Hide();
}
return false;
}
}
}