private static MessageIcon GetMessageIcon(MessageBoxImage image)
        {
            MessageIcon icon;
            switch (image)
            {
                case MessageBoxImage.Exclamation:
                    icon = MessageIcon.Warning;
                    break;

                case MessageBoxImage.Asterisk:
                    icon = MessageIcon.Information;
                    break;

                case MessageBoxImage.Hand:
                    icon = MessageIcon.Error;
                    break;

                case MessageBoxImage.Question:
                    icon = MessageIcon.Question;
                    break;

                default:
                    icon = MessageIcon.None;
                    break;
            }
            return icon;
        }

 public AlertDialogBackend()
 {
     this.buttons = MessageBoxButton.OKCancel;
     this.icon = MessageBoxImage.None;
     this.options = MessageBoxOptions.None;
     this.defaultResult = MessageBoxResult.Cancel;
 }

 /// <summary>
 /// コンストラクタ
 /// </summary>
 /// <param name="MsgType">メッセージボックスに表示するアイコンの種類</param>
 /// <param name="ContinueFlg">処理を継続できるかのフラグ(true:可能、false:不可)</param>
 /// <param name="MsgCd">メッセージコード</param>
 /// <param name="AddMsg">追加メッセージ</param>
 public MessageEventArgs(MessageBoxImage MsgType, bool ContinueFlg, string MsgCd, params object[] AddMsg)
 {
     this.MsgType = MsgType;
     this.ContinueFlg = ContinueFlg;
     this.MsgCd = MsgCd;
     this.AddMsg = AddMsg;
 }

 /// <summary>
 /// コンストラクタ
 /// </summary>
 /// <param name="ErrorCd">メッセージコード</param>
 /// <param name="DialogType">ダイアログの種類</param>
 public DialogErrorEntity(MessageBoxImage DialogType, bool ContinueFlg, string ErrorCd, params string[] AddMessage)
 {
     this.ErrorCd = ErrorCd;
     this.ContinueFlg = ContinueFlg;
     this.DialogType = DialogType;
     this.AddMessage = AddMessage;
 }

 public static void ShowAsync(string text, MessageBoxButton button = MessageBoxButton.OK,
     MessageBoxImage image = MessageBoxImage.Information, MessageBoxResult defaultButton = MessageBoxResult.OK)
 {
     new Thread(
         new ThreadStart(delegate { MessageBox.Show(text, Resources.AppName, button, image, defaultButton); }))
         .Start();
 }

        public static MessageBoxResult Show(
            Action<Window> setOwner,
            CultureInfo culture,
            string messageBoxText,
            string caption,
            WPFMessageBoxButton button,
            MessageBoxImage icon,
            MessageBoxResult defaultResult,
            MessageBoxOptions options)
        {
            if ((options & MessageBoxOptions.DefaultDesktopOnly) == MessageBoxOptions.DefaultDesktopOnly)
            {
                throw new NotImplementedException();
            }

            if ((options & MessageBoxOptions.ServiceNotification) == MessageBoxOptions.ServiceNotification)
            {
                throw new NotImplementedException();
            }
            //LocalizeDictionary.Instance.Culture = CultureInfo.GetCultureInfo("de");
            _messageBoxWindow = new WPFMessageBoxWindow();

            setOwner(_messageBoxWindow);

            PlayMessageBeep(icon);
            //FrameworkElement.LanguageProperty.OverrideMetadata(typeof(FrameworkElement), new FrameworkPropertyMetadata(
            //            XmlLanguage.GetLanguage(culture.IetfLanguageTag)));
            _messageBoxWindow._viewModel = new MessageBoxViewModel(_messageBoxWindow, culture, caption, messageBoxText, button, icon, defaultResult, options);
            _messageBoxWindow.DataContext = _messageBoxWindow._viewModel;
            _messageBoxWindow.ShowDialog();
            return _messageBoxWindow._viewModel.Result;
        }

        public static MessageBoxResult Show(Window parent, string msg, string title, MessageBoxButton btns, MessageBoxImage icon)
        {
            // Create a callback delegate
            _hookProcDelegate = new Win32.WindowsHookProc(HookCallback);

            // Remember the title & message that we'll look for.
            // The hook sees *all* windows, so we need to make sure we operate on the right one.
            _msg = msg;
            _title = title;

            // Set the hook.
            // Suppress "GetCurrentThreadId() is deprecated" warning.
            // It's documented that Thread.ManagedThreadId doesn't work with SetWindowsHookEx()
            #pragma warning disable 0618
            _hHook = Win32.SetWindowsHookEx(Win32.WH_CBT, _hookProcDelegate, IntPtr.Zero, AppDomain.GetCurrentThreadId());
            #pragma warning restore 0618

            // Pop a standard MessageBox. The hook will center it.
             MessageBoxResult rslt;
             if (parent == null)
                 rslt = MessageBox.Show(msg, title, btns, icon);
             else
                 rslt = MessageBox.Show(parent, msg, title, btns, icon);

            // Release hook, clean up (may have already occurred)
            Unhook();

            return rslt;
        }

 public static void popup(string message, MessageBoxImage mbi)
 {
     mainWindow.Dispatcher.Invoke(mainWindow.DelShowOkMsg, message, mbi);
     mainWindow.Dispatcher.BeginInvoke(mainWindow.DelWriteLog, message);
     Trace.WriteLine(message);
     Trace.Flush();
 }

		private static void PlayMessageBeep(MessageBoxImage icon)
		{
			switch (icon)
			{
				//case MessageBoxImage.Hand:
				//case MessageBoxImage.Stop:
				case MessageBoxImage.Error:
					SystemSounds.Hand.Play();
					break;

				//case MessageBoxImage.Exclamation:
				case MessageBoxImage.Warning:
					SystemSounds.Exclamation.Play();
					break;

				case MessageBoxImage.Question:
					SystemSounds.Question.Play();
					break;

				//case MessageBoxImage.Asterisk:
				case MessageBoxImage.Information:
					SystemSounds.Asterisk.Play();
					break;

				default:
					SystemSounds.Beep.Play();
					break;
			}
		}

        public Task<MessageBoxResult> ShowAsync(string message, string title, MessageBoxButton buttons, MessageBoxImage image)
        {
            var tcs = new TaskCompletionSource<MessageBoxResult>();

            _dispatcherService.CurrentDispatcher.BeginInvoke(new Action(() =>
            {
                MessageBoxResult result;
                Window activeWindow = null;
                for (var i = 0; i < Application.Current.Windows.Count; i++)
                {
                    var win = Application.Current.Windows[i];
                    if ((win != null) && (win.IsActive))
                    {
                        activeWindow = win;
                        break;
                    }
                }

                if (activeWindow != null)
                {
                    result = MessageBox.Show(activeWindow, message, title, buttons, image);
                }
                else
                {
                    result = MessageBox.Show(message, title, buttons, image);
                }

                tcs.SetResult(result);
            }));


            return tcs.Task;
        }

 public MessageBoxMessage(string text, string caption, MessageBoxImage image)
 {
     this.Text = text;
     this.Caption = caption;
     this.Button = MessageBoxButton.OK;
     this.Image = image;
 }

 ///////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////////////////
 /// <summary>
 /// Displays a customized message box in front of the specified window.
 /// </summary>
 /// <param name="owner">Owner window of the message box.</param>
 /// <param name="messageBoxText">Text to display.</param>
 /// <param name="caption">Title bar caption to display.</param>
 /// <param name="button">A value that specifies which button or buttons to display.</param>
 /// <param name="icon">Icon to display.</param>
 /// <returns>Button value which message box is clicked by the user.</returns>
 public static MessageBoxExButtonType Show(Window owner, string messageBoxText, string caption,
                                           MessageBoxButtons button, MessageBoxImage icon)
 {
     bool checkBoxState = false; // NOTE: ignored
     MessageBoxEx msbBox = new MessageBoxEx();
     return msbBox._Show(owner, messageBoxText, caption, button, icon, null, ref checkBoxState);
 }

        private static MessageBoxResult DisplayMessage(string message, MessageBoxImage image, MessageBoxButton button, Window owner)
        {
            var dialogOwner = owner;
            var result = MessageBoxResult.None;

            if (dialogOwner != null)
            {
                if (dialogOwner.Dispatcher != null)
                {
                    dialogOwner.Dispatcher.adoptAsync(() =>
                    {
                        result = MessageBox.Show(dialogOwner, message, "MeTL", button, image);
                    });
                } else
                {
                    Application.Current.Dispatcher.adoptAsync(() =>
                    {
                        result = MessageBox.Show(dialogOwner, message, "MeTL", button, image);
                    });

                }
            }
            else
            {
                // calling from non-ui thread
                if (Application.Current != null && Application.Current.Dispatcher != null)
                    Application.Current.Dispatcher.adoptAsync(() =>
                    {
                        dialogOwner = GetMainWindow();
                        result = MessageBox.Show(dialogOwner, message, "MeTL", button, image);
                    });
            }

            return result;
        }

        public static MessageBoxResult Show(
            Action<Window> setOwner,
            string messageBoxText, 
            string caption, 
            MessageBoxButton button, 
            MessageBoxImage icon, 
            MessageBoxResult defaultResult, 
            MessageBoxOptions options)
        {
            if ((options & MessageBoxOptions.DefaultDesktopOnly) == MessageBoxOptions.DefaultDesktopOnly)
            {
                throw new NotImplementedException();
            }

            if ((options & MessageBoxOptions.ServiceNotification) == MessageBoxOptions.ServiceNotification)
            {
                throw new NotImplementedException();
            }

            _messageBoxWindow = new WpfMessageBoxWindow();

            setOwner(_messageBoxWindow);

            PlayMessageBeep(icon);

            _messageBoxWindow._viewModel = new MessageBoxViewModel(_messageBoxWindow, caption, messageBoxText, button, icon, defaultResult, options);
            _messageBoxWindow.DataContext = _messageBoxWindow._viewModel;
            _messageBoxWindow.ShowDialog();
            return _messageBoxWindow._viewModel.Result;
        }

 public MoqPopup(string headerText, string discriptionText, MessageBoxImage imageType, MessageBoxButton buttons)
 {
     Header = headerText;
     Description = discriptionText;
     ImageType = imageType;
     Buttons = buttons;
 }

 public static MessageBoxResult Show(string messageBoxText, string caption, MessageBoxButton button, MessageBoxImage icon, MessageBoxResult defaultResult)
 {
     if (_provider != null)
         return _provider.Show(messageBoxText, caption, button, icon, defaultResult);
     else
         return MessageBox.Show(messageBoxText, caption, button, icon, defaultResult);
 }

 public static MessageBoxResult MyMessageBox(string p_strMessage, MessageBoxButton p_objButtons,MessageBoxImage p_objImage = MessageBoxImage.Question)
 {
     return MessageBox.Show(p_strMessage, APP_NAME,
                            p_objButtons,
                            p_objImage,
                            MessageBoxResult.OK);
 }

 public static ImageSource MessageBoxImageToImageSource(MessageBoxImage image)
 {
     Icon icon;
     switch (image)
     {
         case MessageBoxImage.None:
             icon = null;
             break;
         case MessageBoxImage.Error: // also MessageBoxImage.Hand ans MessageBoxImage.Stop:
             icon = SystemIcons.Hand;
             break;
         case MessageBoxImage.Question:
             icon = SystemIcons.Question;
             break;
         case MessageBoxImage.Warning: // also MessageBoxImage.Exclamation
             icon = SystemIcons.Exclamation;
             break;
         case MessageBoxImage.Information: //case MessageBoxImage.Asterisk
             icon = SystemIcons.Asterisk;
             break;
         default:
             icon = SystemIcons.Application;
             break;
     }
     return (icon == null) ? null : Imaging.CreateBitmapSourceFromHIcon(icon.Handle, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
 }

        /// <summary>
        /// Shows MessageBox dialog with specified buttons texts
        /// </summary>
        /// <param name="message">Message to display</param>
        /// <param name="title">Title to display</param>
        /// <param name="buttons">Optonal buttons definiton</param>
        /// <param name="icon">Optional icon definition</param>
        /// <param name="buttonsTexts">Optional buttons texts</param>
        /// <returns></returns>
        public static MessageBoxResult ShowDialog(
            string message,
            string title,
            MessageBoxButton buttons = MessageBoxButton.OK,
            MessageBoxImage icon = MessageBoxImage.Information,
            Dictionary<Buttons, string> buttonsTexts = null)
        {
            try
            {
                // Register buttons texts
                if (buttonsTexts != null)
                {
                    foreach (Buttons button in buttonsTexts.Keys)
                    {
                        // Set given text to a proper buttons
                        switch (button)
                        {
                            case Buttons.OK:
                                MessageBoxManager.OK = buttonsTexts[button];
                                break;

                            case Buttons.YES:
                                MessageBoxManager.Yes = buttonsTexts[button];
                                break;

                            case Buttons.NO:
                                MessageBoxManager.No = buttonsTexts[button];
                                break;

                            case Buttons.CANCEL:
                                MessageBoxManager.Cancel = buttonsTexts[button];
                                break;
                        }
                    }

                    // Register buttons
                    MessageBoxManager.Register();
                }

                MessageBoxResult result =
                    System.Windows.MessageBox.Show(message, title, buttons, icon);

                return result;
            }
            catch (Exception ex)
            {
                Karafa.Errors.KarafaLogger.LogError(ex);

                return default(MessageBoxResult);
            }
            finally
            {
                if (buttonsTexts != null)
                {
                    // Unregister buttons
                    MessageBoxManager.Unregister();
                }
            }
        }

 public Warning(string text, string title, MessageBoxButton button, MessageBoxImage image)
 {
     messageTitle = title;
     messageText = text;
     messageImage = image;
     messageButton = button;
     result = MessageBox.Show(messageText, messageTitle, messageButton, messageImage);
 }