ProcessWatchImpl/Scone/MainWindow.xaml.cs

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using Toast.IsolationLayer;
using properties = Toast.Scone.Properties;
using dbg = SeedCreate.CommonLibrary.DebugHelper;
using SeedCreate.Controls.ControlBase;

namespace Toast.Scone
{
        /// <summary>
        /// Window1.xaml の相互作用ロジック
        /// </summary>
        public sealed partial class MainWindow : Window
        {
                public static readonly RoutedCommand StartCommand =
                        new RoutedCommand("StartCommand", typeof(MainWindow));

                public static readonly RoutedCommand StopCommand =
                        new RoutedCommand("StopCommand", typeof(MainWindow));

                private Repeater repeater;

                private TextBoxChecker cheker;

                private bool startCommandCanExecute;
                private bool stopCommandCanExecute;

                public MainWindow()
                {
                        InitializeComponent();

                        repeater = new Repeater(Dispatcher);
                        repeater.ProgramStarted += new EventHandler<Toast.NicoNico.DetectProgramStartEventArgs>(repeater__ProgramStarted);


                        repeater.TwitterWriteFailed += new EventHandler<TwitterWriteFailedEventArgs>(repeater__TwitterWriteFailed);

                        cheker = new TextBoxChecker();
                        cheker.AddControl(smileId);
                        cheker.AddControl(password);
                        cheker.AddControl(userId);
                        cheker.AddControl(format);

                        CommandBinding bind = new CommandBinding(StartCommand, new ExecutedRoutedEventHandler(StartCommandExecute),
                                new CanExecuteRoutedEventHandler(CanExecuteStartCommand));

                        CommandBindings.Add(bind);

                        bind = new CommandBinding(StopCommand, new ExecutedRoutedEventHandler(StopCommandExecute),
                                new CanExecuteRoutedEventHandler(CanExecuteStopCommand));

                        CommandBindings.Add(bind);

                        password.Password = properties::Settings.Default.PassWord;
                        userId.EmbodimentText = properties::Settings.Default.UserId;
                        format.EmbodimentText = properties::Settings.Default.Format;

                        smileId.EmbodimentText = properties::Settings.Default.SmileID;

                        SmileIdValidationRule rule = new SmileIdValidationRule();

                        if (!rule.Validate(smileId.EmbodimentText, System.Threading.Thread.CurrentThread.CurrentCulture).IsValid)
                        {
                                smileId.IsInvalid = true;
                        }

                        startCommandCanExecute = false;
                        stopCommandCanExecute = false;
                }

                public static readonly RoutedEvent StartCommandCanExecuteStateChangingEvent
                        = EventManager.RegisterRoutedEvent("StartCommandCanExecuteStateChanging",
                         RoutingStrategy.Bubble, typeof(RoutedPropertyChangedEventHandler<bool>),
                         typeof(MainWindow));

                public event RoutedPropertyChangedEventHandler<bool> StartCommandCanExecuteStateChanging
                {
                        add
                        {
                                AddHandler(StartCommandCanExecuteStateChangingEvent, value);
                        }
                        remove
                        {
                                RemoveHandler(StartCommandCanExecuteStateChangingEvent, value);
                        }
                }

                private void OnStartCommandCanExecuteStateChanging(RoutedPropertyChangedEventArgs<bool> e)
                {
                        RaiseEvent(e);
                }


                public static readonly RoutedEvent StopCommandCanExecuteStateChangingEvent
                        = EventManager.RegisterRoutedEvent("StopCommandCanExecuteStateChainging",
                         RoutingStrategy.Bubble, typeof(RoutedPropertyChangedEventHandler<bool>),
                         typeof(MainWindow));

                public event RoutedPropertyChangedEventHandler<bool> StopCommandCanExecuteStateChanging
                {
                        add
                        {
                                AddHandler(StopCommandCanExecuteStateChangingEvent, value);
                        }
                        remove
                        {
                                RemoveHandler(StopCommandCanExecuteStateChangingEvent, value);
                        }
                }

                private void OnStopCommandCanExecuteStateChanging(RoutedPropertyChangedEventArgs<bool> e)
                {
                        RaiseEvent(e);
                }


                private void repeater__TwitterWriteFailed(object sender, TwitterWriteFailedEventArgs e)
                {
                        MessageBox.Show(properties::Resources.WriteFailedMessage, properties::Resources.WriteFailedCaption,
                                 MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK, MessageBoxOptions.DefaultDesktopOnly);

                        CommandBindings[0].Command.CanExecute(null);
                        userId.Focus();
                        //エラー直後に、なんかしたけりゃここにかく
                }


                private void repeater__ProgramStarted(object sender, Toast.NicoNico.DetectProgramStartEventArgs e)
                {
                        mainStatus.Text = string.Format(properties::Resources.WriteSuccessFormat, e.TargetProgram.Title);
                }

                private bool CheckStartInterlock()
                {

                        bool State = false;

                        if (repeater.IsRunning)
                        {
                                State = false;
                        }
                        else
                        {
                                Control ret = cheker.Check();

                                if (ret == null)
                                {
                                        State = true;
                                }
                                else if (ret is BiStateTextBox)
                                {
                                        WriteState((BiStateTextBox)ret);
                                        State = false;
                                }
                                else if (ret is PasswordBox)
                                {
                                        WriteState((PasswordBox)ret);
                                        State = false;
                                }
                                else
                                {
                                        throw new SeedCreate.InconsistencyException("Unexpected control type");
                                }
                        }

                        return State;
                }


                private bool CheckStopInterlock()
                {
                        bool State = false;

                        if (repeater.IsRunning)
                        {
                                State = true;
                        }
                        else
                        {
                                State = false;
                        }

                        return State;

                }

                private void WriteState(PasswordBox passwordBox)
                {
                        WriteState(properties::Resources.EmptyPassword);
                }

                private void WriteState(BiStateTextBox biStateTextBox)
                {
                        if (biStateTextBox.IsEmpty)
                        {
                                WriteState(string.Format(properties::Resources.EmptyStateMessageFormat, biStateTextBox.Name));
                        }

                        if (biStateTextBox.IsInvalid)
                        {
                                WriteState(string.Format(properties::Resources.InvalidStateMessageFormat, biStateTextBox.Name));
                        }
                }


                private void WriteState(string message)
                {
                        mainStatus.Text = message;
                }


                private void StartCommandExecute(object sender, ExecutedRoutedEventArgs e)
                {
                        repeater.Start(uint.Parse(smileId.EmbodimentText),
                                userId.EmbodimentText,
                                password.Password,
                                format.EmbodimentText);
                        //CheckStopInterlock();

                        WriteState(properties::Resources.Start);
                }

                private void CanExecuteStartCommand(object sender, CanExecuteRoutedEventArgs e)
                {
                        e.CanExecute=CheckStartInterlock();

                        if (e.CanExecute != startCommandCanExecute)
                        {
                                OnStartCommandCanExecuteStateChanging(new RoutedPropertyChangedEventArgs<bool>(startCommandCanExecute, e.CanExecute,
                                        StartCommandCanExecuteStateChangingEvent));
                                startCommandCanExecute = e.CanExecute;

                                dbg.TinyDebugWriter.WriteLine("StartChanged:{0}", e.CanExecute);
                        }
                }

                private void StopCommandExecute(object sender, ExecutedRoutedEventArgs e)
                {
                        repeater.Stop();
                        //CheckStopInterlock();

                        WriteState(properties::Resources.ApplicationName);
                }

                private void CanExecuteStopCommand(object sender, CanExecuteRoutedEventArgs e)
                {
                        e.CanExecute = CheckStopInterlock();

                        if (e.CanExecute != stopCommandCanExecute)
                        {
                                OnStopCommandCanExecuteStateChanging(new RoutedPropertyChangedEventArgs<bool>(stopCommandCanExecute, e.CanExecute,
                                        StopCommandCanExecuteStateChangingEvent));
                                stopCommandCanExecute = e.CanExecute;

                                dbg.TinyDebugWriter.WriteLine("StopChanged:{0}", e.CanExecute);
                        }
                }

                private void Format_EmbodimentTextChanged(object sender, EmbodimentTextChangedEventArgs e)
                {
                        properties::Settings.Default.Format =
                                e.Current == null ? string.Empty : format.EmbodimentText;

                        properties::Settings.Default.Save();
                }

                private void SmileId_EmbodimentTextChanged(object sender, EmbodimentTextChangedEventArgs e)
                {

                        if (!smileId.IsInvalid)
                        {
                                properties::Settings.Default.SmileID =
                                        e.Current == null ? string.Empty : smileId.EmbodimentText;

                                properties::Settings.Default.Save();
                        }
                }

                private void UserId_EmbodimentTextChanged(object sender, EmbodimentTextChangedEventArgs e)
                {
                        properties::Settings.Default.UserId =
                                e.Current == null ? string.Empty : userId.EmbodimentText;

                        properties::Settings.Default.Save();
                }

                private void PassWord_LostFocus(object sender, RoutedEventArgs e)
                {

                        properties::Settings.Default.PassWord =
                                password.Password == null ? string.Empty : password.Password;

                        properties::Settings.Default.Save();
                }
        }
}