894 lines
31 KiB
C#
894 lines
31 KiB
C#
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Globalization;
|
|
using System.Media;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Input;
|
|
using System.Windows.Interop;
|
|
using System.Windows.Media;
|
|
using System.Windows.Media.Imaging;
|
|
|
|
using MpvNet.Help;
|
|
|
|
namespace MpvNet.Windows.WPF.MsgBox;
|
|
|
|
public partial class MessageBoxEx : Window, INotifyPropertyChanged
|
|
{
|
|
#region INotifyPropertyChanged
|
|
|
|
private bool isModified = false;
|
|
|
|
public bool IsModified {
|
|
get { return isModified; }
|
|
set {
|
|
if (value != isModified)
|
|
{
|
|
isModified = true;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
public event PropertyChangedEventHandler? PropertyChanged;
|
|
|
|
protected void NotifyPropertyChanged([CallerMemberName] string propertyName = "")
|
|
{
|
|
if (PropertyChanged != null)
|
|
{
|
|
PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
|
|
|
|
if (propertyName != "IsModified")
|
|
IsModified = true;
|
|
}
|
|
}
|
|
|
|
#endregion INotifyPropertyChanged
|
|
|
|
#region fields
|
|
|
|
private string? message;
|
|
private string? messageTitle;
|
|
private MessageBoxButton? buttons;
|
|
private MessageBoxResult messageResult;
|
|
private MessageBoxButtonEx? buttonsEx;
|
|
private MessageBoxResultEx messageResultEx;
|
|
private ImageSource? messageIcon;
|
|
private MessageBoxImage msgBoxImage;
|
|
private double buttonWidth = 0d;
|
|
private bool expanded = false;
|
|
private bool isDefaultOK;
|
|
private bool isDefaultCancel;
|
|
private bool isDefaultYes;
|
|
private bool isDefaultNo;
|
|
private bool isDefaultAbort;
|
|
private bool isDefaultRetry;
|
|
private bool isDefaultIgnore;
|
|
|
|
private bool usingExButtons = false;
|
|
|
|
#endregion fields
|
|
|
|
#region properties
|
|
|
|
public string Message {
|
|
get { return message; }
|
|
set {
|
|
if (value != message)
|
|
{
|
|
message = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
public string MessageTitle {
|
|
get { return messageTitle; }
|
|
set {
|
|
if (value != messageTitle)
|
|
{
|
|
messageTitle = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
public MessageBoxResult MessageResult { get { return this.messageResult; } set { this.messageResult = value; } }
|
|
public MessageBoxResultEx MessageResultEx { get { return this.messageResultEx; } set { this.messageResultEx = value; } }
|
|
|
|
public MessageBoxButton? Buttons {
|
|
get { return buttons; }
|
|
set {
|
|
if (value != buttons)
|
|
{
|
|
buttons = value;
|
|
NotifyPropertyChanged();
|
|
NotifyPropertyChanged("ShowOk");
|
|
NotifyPropertyChanged("ShowCancel");
|
|
NotifyPropertyChanged("ShowYes");
|
|
NotifyPropertyChanged("ShowNo");
|
|
}
|
|
}
|
|
}
|
|
public MessageBoxButtonEx? ButtonsEx {
|
|
get { return buttonsEx; }
|
|
set {
|
|
if (value != buttonsEx)
|
|
{
|
|
buttonsEx = value;
|
|
NotifyPropertyChanged();
|
|
NotifyPropertyChanged("ShowOk");
|
|
NotifyPropertyChanged("ShowCancel");
|
|
NotifyPropertyChanged("ShowYes");
|
|
NotifyPropertyChanged("ShowNo");
|
|
NotifyPropertyChanged("ShowAbort");
|
|
NotifyPropertyChanged("ShowRetry");
|
|
NotifyPropertyChanged("ShowIgnore");
|
|
}
|
|
}
|
|
}
|
|
|
|
public Visibility ShowOk => (!usingExButtons && Buttons == MessageBoxButton.OK ||
|
|
!usingExButtons && Buttons == MessageBoxButton.OKCancel ||
|
|
usingExButtons && ButtonsEx == MessageBoxButtonEx.OK ||
|
|
usingExButtons && ButtonsEx == MessageBoxButtonEx.OKCancel) ? Visibility.Visible : Visibility.Collapsed;
|
|
|
|
public Visibility ShowCancel => (!usingExButtons && Buttons == MessageBoxButton.OKCancel ||
|
|
!usingExButtons && Buttons == MessageBoxButton.YesNoCancel ||
|
|
usingExButtons && ButtonsEx == MessageBoxButtonEx.OKCancel ||
|
|
usingExButtons && ButtonsEx == MessageBoxButtonEx.YesNoCancel ||
|
|
usingExButtons && ButtonsEx == MessageBoxButtonEx.RetryCancel) ? Visibility.Visible : Visibility.Collapsed;
|
|
|
|
public Visibility ShowYes => (!usingExButtons && Buttons == MessageBoxButton.YesNo ||
|
|
!usingExButtons && Buttons == MessageBoxButton.YesNoCancel ||
|
|
usingExButtons && ButtonsEx == MessageBoxButtonEx.YesNo ||
|
|
usingExButtons && ButtonsEx == MessageBoxButtonEx.YesNoCancel) ? Visibility.Visible : Visibility.Collapsed;
|
|
|
|
public Visibility ShowNo => (!usingExButtons && Buttons == MessageBoxButton.YesNo ||
|
|
!usingExButtons && Buttons == MessageBoxButton.YesNoCancel ||
|
|
usingExButtons && ButtonsEx == MessageBoxButtonEx.YesNo ||
|
|
usingExButtons && ButtonsEx == MessageBoxButtonEx.YesNoCancel) ? Visibility.Visible : Visibility.Collapsed;
|
|
|
|
public Visibility ShowRetry => (usingExButtons && ButtonsEx == MessageBoxButtonEx.AbortRetryIgnore ||
|
|
usingExButtons && ButtonsEx == MessageBoxButtonEx.RetryCancel) ? Visibility.Visible : Visibility.Collapsed;
|
|
|
|
public Visibility ShowAbort => (usingExButtons && ButtonsEx == MessageBoxButtonEx.AbortRetryIgnore)
|
|
? Visibility.Visible
|
|
: Visibility.Collapsed;
|
|
|
|
public Visibility ShowIgnore => (usingExButtons && ButtonsEx == MessageBoxButtonEx.AbortRetryIgnore)
|
|
? Visibility.Visible
|
|
: Visibility.Collapsed;
|
|
|
|
public Visibility ShowIcon => (MessageIcon != null) ? Visibility.Visible : Visibility.Collapsed;
|
|
|
|
public ImageSource? MessageIcon {
|
|
get => messageIcon;
|
|
set {
|
|
if (value != messageIcon)
|
|
{
|
|
messageIcon = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
public double ButtonWidth {
|
|
get => buttonWidth;
|
|
set {
|
|
if (value != buttonWidth)
|
|
{
|
|
buttonWidth = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool Expanded {
|
|
get => expanded;
|
|
set {
|
|
if (value != expanded)
|
|
{
|
|
expanded = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool IsDefaultOK {
|
|
get => isDefaultOK;
|
|
set {
|
|
if (value != isDefaultOK)
|
|
{
|
|
isDefaultOK = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool IsDefaultCancel {
|
|
get => isDefaultCancel;
|
|
set {
|
|
if (value != isDefaultCancel)
|
|
{
|
|
isDefaultCancel = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool IsDefaultYes {
|
|
get => isDefaultYes;
|
|
set {
|
|
if (value != isDefaultYes)
|
|
{
|
|
isDefaultYes = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool IsDefaultNo {
|
|
get => isDefaultNo;
|
|
set {
|
|
if (value != isDefaultNo)
|
|
{
|
|
isDefaultNo = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool IsDefaultAbort {
|
|
get => isDefaultAbort;
|
|
set {
|
|
if (value != isDefaultAbort)
|
|
{
|
|
isDefaultAbort = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool IsDefaultRetry {
|
|
get => isDefaultRetry;
|
|
set {
|
|
if (value != isDefaultRetry)
|
|
{ isDefaultRetry = value; NotifyPropertyChanged(); }
|
|
}
|
|
}
|
|
|
|
public bool IsDefaultIgnore {
|
|
get => isDefaultIgnore;
|
|
set {
|
|
if (value != isDefaultIgnore)
|
|
{
|
|
isDefaultIgnore = value;
|
|
NotifyPropertyChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#endregion properties
|
|
|
|
#region constructors
|
|
|
|
private MessageBoxEx()
|
|
{
|
|
InitializeComponent();
|
|
DataContext = this;
|
|
LargestButtonWidth();
|
|
}
|
|
|
|
public MessageBoxEx(string msg, string title, MessageBoxButton buttons = MessageBoxButton.OK,
|
|
MessageBoxImage image = MessageBoxImage.None)
|
|
{
|
|
InitializeComponent();
|
|
DataContext = this;
|
|
Init(msg, title, buttons, image);
|
|
}
|
|
|
|
public MessageBoxEx(string msg, string title, MessageBoxButtonEx buttons = MessageBoxButtonEx.OK,
|
|
MessageBoxImage image = MessageBoxImage.None)
|
|
{
|
|
InitializeComponent();
|
|
DataContext = this;
|
|
Init(msg, title, buttons, image);
|
|
}
|
|
|
|
#endregion constructors
|
|
|
|
#region non-static methods
|
|
|
|
protected virtual void Init(string msg, string title, MessageBoxButton buttons, MessageBoxImage image)
|
|
{
|
|
InitTop(msg, title);
|
|
usingExButtons = false;
|
|
ButtonsEx = null;
|
|
Buttons = buttons;
|
|
SetButtonTemplates();
|
|
InitBottom(image);
|
|
FindDefaultButton(staticButtonDefault);
|
|
}
|
|
|
|
protected virtual void Init(string msg, string title, MessageBoxButtonEx buttons, MessageBoxImage image)
|
|
{
|
|
InitTop(msg, title);
|
|
usingExButtons = true;
|
|
Buttons = null;
|
|
ButtonsEx = buttons;
|
|
SetButtonTemplates();
|
|
InitBottom(image);
|
|
FindDefaultButtonEx(staticButtonDefault);
|
|
}
|
|
|
|
void InitTop(string msg, string title)
|
|
{
|
|
// determine whether or not to show the details pane and checkbox
|
|
ShowDetailsBtn = (string.IsNullOrEmpty(DetailsText)) ? Visibility.Collapsed : Visibility.Visible;
|
|
ShowCheckBox = (CheckBoxData == null) ? Visibility.Collapsed : Visibility.Visible;
|
|
|
|
// Well, the binding for family/size don't appear to be working, so I have to set them
|
|
// manually. Weird...
|
|
FontFamily = MsgFontFamily;
|
|
FontSize = MsgFontSize;
|
|
LargestButtonWidth();
|
|
|
|
// configure the form based on specified criteria
|
|
Message = msg;
|
|
MessageTitle = (string.IsNullOrEmpty(title.Trim())) ? "Application Message" : title;
|
|
|
|
// url (if specified)
|
|
if (Url != null)
|
|
{
|
|
tbUrl.Text = (string.IsNullOrEmpty(UrlDisplayName)) ? Url.ToString() : UrlDisplayName;
|
|
tbUrl.ToolTip = new ToolTip() { Content = Url.ToString() };
|
|
}
|
|
}
|
|
|
|
void InitBottom(MessageBoxImage image)
|
|
{
|
|
MessageBackground = (MessageBackground == null) ? new SolidColorBrush(Colors.White) : MessageBackground;
|
|
MessageForeground = (MessageForeground == null) ? new SolidColorBrush(Colors.Black) : MessageForeground;
|
|
ButtonBackground = (ButtonBackground == null) ? new SolidColorBrush(ColorFromString("#cdcdcd")) : ButtonBackground;
|
|
|
|
MessageIcon = null;
|
|
|
|
msgBoxImage = image;
|
|
|
|
if (DelegateObj != null)
|
|
{
|
|
Style style = (Style)(FindResource("ImageOpacityChanger"));
|
|
|
|
if (style != null)
|
|
{
|
|
imgMsgBoxIcon.Style = style;
|
|
|
|
if (!string.IsNullOrEmpty(DelegateToolTip))
|
|
{
|
|
System.Windows.Controls.ToolTip tooltip = new System.Windows.Controls.ToolTip() { Content = DelegateToolTip };
|
|
// for some reason, Image elements can't do tooltips, so I assign the tootip
|
|
// to the parent grid. This seems to work fine.
|
|
imgGrid.ToolTip = tooltip;
|
|
}
|
|
}
|
|
}
|
|
|
|
// multiple images have the same ordinal value, and are indicated in the comments below.
|
|
// WTF Microsoft?
|
|
switch ((int)image)
|
|
{
|
|
case 16: // MessageBoxImage.Error, MessageBoxImage.Stop, MessageBox.Image.Hand
|
|
{
|
|
MessageIcon = GetIcon(SystemIcons.Error);
|
|
|
|
if (!isSilent)
|
|
SystemSounds.Hand.Play();
|
|
}
|
|
break;
|
|
|
|
case 64: // MessageBoxImage.Information, MessageBoxImage.Asterisk
|
|
{
|
|
MessageIcon = GetIcon(SystemIcons.Information);
|
|
|
|
if (!isSilent)
|
|
SystemSounds.Asterisk.Play();
|
|
}
|
|
break;
|
|
|
|
case 32: // MessageBoxImage.Question
|
|
{
|
|
MessageIcon = GetIcon(SystemIcons.Question);
|
|
|
|
if (!isSilent)
|
|
SystemSounds.Question.Play();
|
|
}
|
|
break;
|
|
|
|
case 48: // MessageBoxImage.Warning, MessageBoxImage.Exclamation
|
|
{
|
|
MessageIcon = GetIcon(SystemIcons.Warning);
|
|
|
|
if (!isSilent)
|
|
SystemSounds.Exclamation.Play();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
MessageIcon = null;
|
|
break;
|
|
}
|
|
}
|
|
|
|
public ImageSource GetIcon(Icon icon)
|
|
{
|
|
BitmapSource image = Imaging.CreateBitmapSourceFromHIcon(
|
|
icon.Handle, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
|
|
return image;
|
|
}
|
|
|
|
protected virtual void CenterInScreen()
|
|
{
|
|
double width = ActualWidth;
|
|
double height = ActualHeight;
|
|
Left = (SystemParameters.WorkArea.Width - width) / 2 + SystemParameters.WorkArea.Left;
|
|
Top = (SystemParameters.WorkArea.Height - height) / 2 + SystemParameters.WorkArea.Top;
|
|
}
|
|
|
|
protected void LargestButtonWidth()
|
|
{
|
|
Typeface typeface = new Typeface(FontFamily, FontStyle, FontWeight, FontStretch);
|
|
|
|
StackPanel panel = (StackPanel)stackButtons.Child;
|
|
double width = 0;
|
|
string largestName = string.Empty;
|
|
foreach (System.Windows.Controls.Button button in panel.Children)
|
|
{
|
|
// Using the FormattedText object
|
|
// will strip whitespace before measuring the text, so we convert spaces to double
|
|
// hyphens to compensate (I like to pad button Content with a leading and trailing
|
|
// space) so that the button is wide enough to present a more padded appearance.
|
|
FormattedText formattedText = new FormattedText(
|
|
(button.Name == "btnDetails") ? "--Details--" : ((string)(button.Content)).Replace(" ", "--"),
|
|
CultureInfo.CurrentUICulture,
|
|
System.Windows.FlowDirection.LeftToRight,
|
|
typeface,
|
|
FontSize = FontSize,
|
|
System.Windows.Media.Brushes.Black,
|
|
VisualTreeHelper.GetDpi(this).PixelsPerDip);
|
|
|
|
if (width < formattedText.Width)
|
|
largestName = button.Name;
|
|
|
|
width = Math.Max(width, formattedText.Width);
|
|
}
|
|
ButtonWidth = Math.Ceiling(width/*width + polyArrow.Width+polyArrow.Margin.Right+Margin.Left*/);
|
|
}
|
|
|
|
void SetButtonTemplates()
|
|
{
|
|
// set the button template (if specified)
|
|
if (!string.IsNullOrEmpty(ButtonTemplateName))
|
|
{
|
|
bool foundResource = true;
|
|
|
|
try
|
|
{
|
|
FindResource(ButtonTemplateName);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
foundResource = false;
|
|
}
|
|
|
|
if (foundResource)
|
|
{
|
|
btnOK.SetResourceReference(Control.TemplateProperty, ButtonTemplateName);
|
|
btnYes.SetResourceReference(Control.TemplateProperty, ButtonTemplateName);
|
|
btnNo.SetResourceReference(Control.TemplateProperty, ButtonTemplateName);
|
|
btnCancel.SetResourceReference(Control.TemplateProperty, ButtonTemplateName);
|
|
btnAbort.SetResourceReference(Control.TemplateProperty, ButtonTemplateName);
|
|
btnRetry.SetResourceReference(Control.TemplateProperty, ButtonTemplateName);
|
|
btnIgnore.SetResourceReference(Control.TemplateProperty, ButtonTemplateName);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FindDefaultButtonEx(MessageBoxButtonDefault buttonDefault)
|
|
{
|
|
// determine default button
|
|
IsDefaultOK = false;
|
|
IsDefaultCancel = false;
|
|
IsDefaultYes = false;
|
|
IsDefaultNo = false;
|
|
IsDefaultAbort = false;
|
|
IsDefaultRetry = false;
|
|
IsDefaultIgnore = false;
|
|
|
|
if (buttonDefault != MessageBoxButtonDefault.None)
|
|
{
|
|
switch (ButtonsEx)
|
|
{
|
|
case MessageBoxButtonEx.OK:
|
|
IsDefaultOK = true;
|
|
break;
|
|
case MessageBoxButtonEx.OKCancel:
|
|
{
|
|
switch (buttonDefault)
|
|
{
|
|
case MessageBoxButtonDefault.Button1:
|
|
case MessageBoxButtonDefault.OK:
|
|
case MessageBoxButtonDefault.MostPositive:
|
|
IsDefaultOK = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Button2:
|
|
case MessageBoxButtonDefault.Cancel:
|
|
case MessageBoxButtonDefault.LeastPositive:
|
|
IsDefaultCancel = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Forms:
|
|
default:
|
|
IsDefaultOK = true;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case MessageBoxButtonEx.YesNoCancel:
|
|
{
|
|
switch (buttonDefault)
|
|
{
|
|
case MessageBoxButtonDefault.Button1:
|
|
case MessageBoxButtonDefault.Yes:
|
|
break;
|
|
case MessageBoxButtonDefault.MostPositive:
|
|
IsDefaultYes = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Button2:
|
|
case MessageBoxButtonDefault.No:
|
|
IsDefaultNo = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Button3:
|
|
case MessageBoxButtonDefault.Cancel:
|
|
case MessageBoxButtonDefault.LeastPositive:
|
|
IsDefaultCancel = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Forms:
|
|
default:
|
|
IsDefaultYes = true;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case MessageBoxButtonEx.YesNo:
|
|
{
|
|
switch (buttonDefault)
|
|
{
|
|
case MessageBoxButtonDefault.Button1:
|
|
case MessageBoxButtonDefault.Yes:
|
|
case MessageBoxButtonDefault.MostPositive:
|
|
IsDefaultYes = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Button2:
|
|
case MessageBoxButtonDefault.No:
|
|
case MessageBoxButtonDefault.LeastPositive:
|
|
IsDefaultNo = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Forms:
|
|
default:
|
|
IsDefaultYes = true;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case MessageBoxButtonEx.RetryCancel:
|
|
{
|
|
switch (buttonDefault)
|
|
{
|
|
case MessageBoxButtonDefault.Button1:
|
|
case MessageBoxButtonDefault.Retry:
|
|
case MessageBoxButtonDefault.MostPositive:
|
|
IsDefaultRetry = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Button2:
|
|
case MessageBoxButtonDefault.Cancel:
|
|
case MessageBoxButtonDefault.LeastPositive:
|
|
IsDefaultCancel = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Forms:
|
|
default:
|
|
IsDefaultRetry = true;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case MessageBoxButtonEx.AbortRetryIgnore:
|
|
{
|
|
switch (buttonDefault)
|
|
{
|
|
case MessageBoxButtonDefault.Button1:
|
|
case MessageBoxButtonDefault.Abort:
|
|
case MessageBoxButtonDefault.LeastPositive:
|
|
IsDefaultAbort = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Button2:
|
|
case MessageBoxButtonDefault.Retry:
|
|
IsDefaultRetry = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Button3:
|
|
case MessageBoxButtonDefault.Ignore:
|
|
case MessageBoxButtonDefault.MostPositive:
|
|
IsDefaultIgnore = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Forms:
|
|
default:
|
|
IsDefaultAbort = true;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void FindDefaultButton(MessageBoxButtonDefault buttonDefault)
|
|
{
|
|
// determine default button
|
|
IsDefaultOK = false;
|
|
IsDefaultCancel = false;
|
|
IsDefaultYes = false;
|
|
IsDefaultNo = false;
|
|
IsDefaultAbort = false;
|
|
IsDefaultRetry = false;
|
|
IsDefaultIgnore = false;
|
|
|
|
if (buttonDefault != MessageBoxButtonDefault.None)
|
|
{
|
|
switch (Buttons)
|
|
{
|
|
case MessageBoxButton.OK:
|
|
IsDefaultOK = true;
|
|
break;
|
|
case MessageBoxButton.OKCancel:
|
|
{
|
|
switch (buttonDefault)
|
|
{
|
|
case MessageBoxButtonDefault.Button1:
|
|
case MessageBoxButtonDefault.OK:
|
|
case MessageBoxButtonDefault.MostPositive:
|
|
IsDefaultOK = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Button2:
|
|
case MessageBoxButtonDefault.Cancel:
|
|
case MessageBoxButtonDefault.LeastPositive:
|
|
IsDefaultCancel = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Forms:
|
|
default:
|
|
IsDefaultOK = true;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case MessageBoxButton.YesNoCancel:
|
|
{
|
|
switch (buttonDefault)
|
|
{
|
|
case MessageBoxButtonDefault.Button1:
|
|
case MessageBoxButtonDefault.Yes:
|
|
break;
|
|
case MessageBoxButtonDefault.MostPositive:
|
|
IsDefaultYes = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Button2:
|
|
case MessageBoxButtonDefault.No:
|
|
IsDefaultNo = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Button3:
|
|
case MessageBoxButtonDefault.Cancel:
|
|
case MessageBoxButtonDefault.LeastPositive:
|
|
IsDefaultCancel = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Forms:
|
|
default:
|
|
IsDefaultYes = true;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case MessageBoxButton.YesNo:
|
|
{
|
|
switch (buttonDefault)
|
|
{
|
|
case MessageBoxButtonDefault.Button1:
|
|
case MessageBoxButtonDefault.Yes:
|
|
case MessageBoxButtonDefault.MostPositive:
|
|
IsDefaultYes = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Button2:
|
|
case MessageBoxButtonDefault.No:
|
|
case MessageBoxButtonDefault.LeastPositive:
|
|
IsDefaultNo = true;
|
|
break;
|
|
case MessageBoxButtonDefault.Forms:
|
|
default:
|
|
IsDefaultYes = true;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion non-static methods
|
|
|
|
#region event handlers
|
|
|
|
#region buttons
|
|
|
|
/// <summary>
|
|
/// Handle the click event for the OK button
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void BtnOK_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
this.MessageResult = MessageBoxResult.OK;
|
|
this.MessageResultEx = MessageBoxResultEx.OK;
|
|
this.DialogResult = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle the click event for the Yes button
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void BtnYes_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
this.MessageResult = MessageBoxResult.Yes;
|
|
this.MessageResultEx = MessageBoxResultEx.Yes;
|
|
this.DialogResult = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle the click event for the No button
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void BtnNo_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
this.MessageResult = MessageBoxResult.No;
|
|
this.MessageResultEx = MessageBoxResultEx.No;
|
|
this.DialogResult = true;
|
|
}
|
|
|
|
void BtnAbort_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
this.MessageResult = MessageBoxResult.None;
|
|
this.MessageResultEx = MessageBoxResultEx.Abort;
|
|
this.DialogResult = true;
|
|
}
|
|
|
|
void BtnRetry_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
this.MessageResult = MessageBoxResult.None;
|
|
this.MessageResultEx = MessageBoxResultEx.Retry;
|
|
this.DialogResult = true;
|
|
}
|
|
|
|
void BtnIgnore_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
this.MessageResult = MessageBoxResult.None;
|
|
this.MessageResultEx = MessageBoxResultEx.Ignore;
|
|
this.DialogResult = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle the click event for the Cancel button
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void BtnCancel_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
this.MessageResult = MessageBoxResult.Cancel;
|
|
this.MessageResultEx = MessageBoxResultEx.Cancel;
|
|
this.DialogResult = true;
|
|
}
|
|
|
|
#endregion buttons
|
|
|
|
void NotifiableWindow_SizeChanged(object sender, SizeChangedEventArgs e) => CenterInScreen();
|
|
|
|
void Window_Loaded(object sender, RoutedEventArgs e)
|
|
{
|
|
imgMsgBoxIcon.ToolTip = (msgBoxImage == MessageBoxImage.Error) ? MsgBoxIconToolTip : null;
|
|
}
|
|
|
|
void Window_Closing(object sender, CancelEventArgs e)
|
|
{
|
|
DetailsText = null;
|
|
CheckBoxData = null;
|
|
staticButtonDefault = MessageBoxButtonDefault.Forms;
|
|
|
|
if (MessageResult == MessageBoxResult.None)
|
|
{
|
|
if (usingExButtons)
|
|
{
|
|
switch (ButtonsEx)
|
|
{
|
|
case MessageBoxButtonEx.OK:
|
|
MessageResultEx = MessageBoxResultEx.OK;
|
|
break;
|
|
case MessageBoxButtonEx.YesNoCancel:
|
|
case MessageBoxButtonEx.OKCancel:
|
|
case MessageBoxButtonEx.RetryCancel:
|
|
case MessageBoxButtonEx.AbortRetryIgnore:
|
|
MessageResultEx = MessageBoxResultEx.Cancel;
|
|
break;
|
|
case MessageBoxButtonEx.YesNo:
|
|
MessageResultEx = MessageBoxResultEx.No;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (Buttons)
|
|
{
|
|
case MessageBoxButton.OK:
|
|
MessageResult = MessageBoxResult.OK;
|
|
break;
|
|
case MessageBoxButton.YesNoCancel:
|
|
case MessageBoxButton.OKCancel:
|
|
MessageResult = MessageBoxResult.Cancel;
|
|
break;
|
|
case MessageBoxButton.YesNo:
|
|
MessageResult = MessageBoxResult.No;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ImgMsgBoxIcon_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
|
|
{
|
|
if (DelegateObj != null && msgBoxImage == MessageBoxImage.Error && Buttons == MessageBoxButton.OK)
|
|
{
|
|
DelegateObj.PerformAction(Message);
|
|
|
|
if (ExitAfterErrorAction)
|
|
{
|
|
MessageResult = MessageBoxResult.None;
|
|
DialogResult = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void TbUrl_MouseLeftButtonUp(object sender, MouseButtonEventArgs e) => ProcessHelp.ShellExecute(Url?.ToString());
|
|
|
|
[DllImport("user32.dll")]
|
|
private static extern IntPtr GetSystemMenu(IntPtr hWnd, bool bRevert);
|
|
|
|
[DllImport("user32.dll")]
|
|
private static extern bool EnableMenuItem(IntPtr hMenu, uint uIDEnableItem, uint uEnable);
|
|
|
|
private const uint MF_BYCOMMAND = 0x00000000;
|
|
private const uint MF_GRAYED = 0x00000001;
|
|
private const uint SC_CLOSE = 0xF060;
|
|
|
|
void Window_SourceInitialized(object sender, EventArgs e)
|
|
{
|
|
if (!enableCloseButton)
|
|
{
|
|
var hWnd = new WindowInteropHelper(this);
|
|
var sysMenu = GetSystemMenu(hWnd.Handle, false);
|
|
EnableMenuItem(sysMenu, SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
|
|
}
|
|
}
|
|
|
|
#endregion event handlers
|
|
}
|