ProcessWatchImpl/Scone/BiStateTextBox.cs

using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Media;
using debug = SeedCreate.CommonLibrary.DebugHelper;

namespace Toast.Scone
{


        public 
#if !DEBUG 
                abstract 
#endif
                class BiStateTextBox : TextBox
        {
                static BiStateTextBox()
                {
//                      DefaultStyleKeyProperty.OverrideMetadata(typeof(UserIdBoxBase), new FrameworkPropertyMetadata(typeof(UserIdBoxBase)));
                }

                private BindingExpression expression_;


#if DEBUG
                public
#else
                protected 
#endif
                        BiStateTextBox()
                {
                        this.expression_ = null;
                        base.Loaded += new RoutedEventHandler(BiStateTextBox_Loaded);
                }

                void BiStateTextBox_Loaded(object sender, RoutedEventArgs e)
                {
                        bool Recent = this.IsEmpty;

                        this.IsEmpty = false;
                        expression_ = this.GetBindingExpression(TextProperty);
                        this.IsEmpty = Recent;
                }

                #region Dependency Event

                public static readonly RoutedEvent EmbodimentTextChangedEvent =
                        EventManager.RegisterRoutedEvent("EmbodimentTextChanged", 
                        RoutingStrategy.Bubble, typeof(EmbodimentTextChangedEventHandler), typeof(BiStateTextBox));

                public event EmbodimentTextChangedEventHandler EmbodimentTextChanged
                {
                        add
                        {
                                AddHandler(EmbodimentTextChangedEvent, value);
                        }
                        remove
                        {
                                RemoveHandler(EmbodimentTextChangedEvent, value);
                        }
                }

                public static readonly RoutedEvent IsInvalidChangedEvent =
                        EventManager.RegisterRoutedEvent("IsInvalidChanged", RoutingStrategy.Bubble, typeof(BooleanPropertyChangedEventHandler),
                        typeof(BiStateTextBox));


                public event BooleanPropertyChangedEventHandler IsInvalidChanged
                {
                        add
                        {
                                AddHandler(IsInvalidChangedEvent, value);
                        }
                        remove
                        {
                                RemoveHandler(IsInvalidChangedEvent, value);
                        }
                }

                public static readonly RoutedEvent IsEmptyChangedEvent=
                        EventManager.RegisterRoutedEvent("IsEmptyChanged", RoutingStrategy.Bubble,
                        typeof(BooleanPropertyChangedEventHandler),
                        typeof(BiStateTextBox));

                public event BooleanPropertyChangedEventHandler IsEmptyChanged
                {
                        add
                        {
                                AddHandler(IsEmptyChangedEvent, value);
                        }
                        remove
                        {
                                RemoveHandler(IsEmptyChangedEvent, value);
                        }
                }


                #endregion

                #region Dependency properties


                #region EmbodimentText property

                public static readonly DependencyProperty EmbodimentTextProperty
                        = DependencyProperty.Register("EmbodimentText", typeof(string), typeof(BiStateTextBox));

                public string EmbodimentText
                {
                        get
                        {
                                return (string)GetValue(EmbodimentTextProperty);
                        }
                        set
                        {
                                string Recent = EmbodimentText;
                                SetValue(EmbodimentTextProperty, value == null ? string.Empty : value);

                                EmbodimentTextChangedEventArgs e = new EmbodimentTextChangedEventArgs(EmbodimentTextChangedEvent, Recent, value);

                                if (value != null && value.Length != 0)
                                {
                                        IsEmpty = false;
                                }
                                else
                                {
                                        IsEmpty = true;
                                }
                        }
                }

                #endregion

                #region EmptyExpressionProperty
                public static readonly DependencyProperty EmptyExpressionProperty =
        DependencyProperty.Register("EmptyExpression", typeof(string), typeof(BiStateTextBox));

                public string EmptyExpression
                {
                        get
                        {
                                return (string)GetValue(EmptyExpressionProperty);
                        }
                        set
                        {
                                SetValue(EmptyExpressionProperty, value);
                        }
                }

                #endregion


                #region EmptyForeground property

                public static readonly DependencyProperty EmptyForegroundProperty =
                        DependencyProperty.Register("EmptyForeground", typeof(Brush), typeof(BiStateTextBox));

                public Brush EmptyForeground
                {
                        get
                        {
                                return (Brush)GetValue(EmptyForegroundProperty);
                        }
                        set
                        {
                                SetValue(EmptyForegroundProperty, value);
                        }
                }


                #endregion

                #region IsInvalid property

                public static readonly DependencyProperty IsInvalidProperty
                        = DependencyProperty.Register("IsInvalid", typeof(bool), typeof(BiStateTextBox));

                public bool IsInvalid
                {
                        get
                        {
                                return (bool)GetValue(IsInvalidProperty);
                        }
                        set
                        {
                                bool Inspection = value != IsInvalid;

                                SetValue(IsInvalidProperty, value);

                                if (Inspection)
                                {
                                        BooleanPropertyChangedEventArgs e = new BooleanPropertyChangedEventArgs(IsInvalidChangedEvent, value);
                                        OnIsInvalidChanged(e);
                                }
                        }
                }
                #endregion

                #region InvalidStateBackground property
                public static readonly DependencyProperty InvalidStateBackgroundProperty
                        = DependencyProperty.Register("InvalidStateBackground", typeof(Brush), typeof(BiStateTextBox));

                public Brush InvalidStateBackground
                {
                        get
                        {
                                return (Brush)GetValue(InvalidStateBackgroundProperty);
                        }
                        set
                        {
                                SetValue(InvalidStateBackgroundProperty, value);
                        }
                }


                #endregion

                #region IsEmpty property
                public static readonly DependencyProperty IsEmptyProperty
                        = DependencyProperty.Register("IsEmpty", typeof(bool), typeof(BiStateTextBox),
                        new UIPropertyMetadata(true));

                public bool IsEmpty
                {
                        get
                        {
                                return (bool)GetValue(IsEmptyProperty);
                        }
#if !DEBUG
                        private
#endif
                        set
                        {
                                bool Inspection = value != IsEmpty;
                                SetValue(IsEmptyProperty, value);

                                if (Inspection)
                                {
                                        OnIsEmptyChanged(new BooleanPropertyChangedEventArgs(IsEmptyChangedEvent, value));
                                }
                        }
                }

                public void CheckEmpty()
                {
                        if (EmbodimentText.Length == 0)
                        {
                                IsEmpty = true;
                        }
                        else
                        {
                                IsEmpty = false;
                        }
                }

                #endregion
                #endregion

                protected override void OnGotFocus(RoutedEventArgs e)
                {
                        this.IsEmpty = false;
                        base.OnGotFocus(e);
                }

                protected override void OnLostFocus(RoutedEventArgs e)
                {
                        string Recent = this.EmbodimentText;

                        this.expression_.UpdateSource();

                        if (EmbodimentText != Recent)
                        {
                                OnEmbodimentTextChangedChanged(new EmbodimentTextChangedEventArgs(EmbodimentTextChangedEvent, EmbodimentText, Text));
                        }

                        this.IsInvalid = this.expression_.HasError;

                        if (Text.Length == 0)
                        {
                                this.IsEmpty = true;
                        }
                        else
                        {
                                this.IsEmpty = false;
                        }

                        base.OnLostFocus(e);
                }

                protected virtual void OnEmbodimentTextChangedChanged(EmbodimentTextChangedEventArgs e)
                {
                        debug.TinyDebugWriter.WriteLine("Id is Changed\n\tRecent:{0}\n\tCurrent:{1}", e.Recent, e.Current);
                        RaiseEvent(e);
                }

                protected virtual void OnIsInvalidChanged(BooleanPropertyChangedEventArgs e)
                {
                        debug.TinyDebugWriter.WriteLine("IsInvalid is changed:{0}", e.Current);
                        RaiseEvent(e);
                }

                protected virtual void OnIsEmptyChanged(BooleanPropertyChangedEventArgs e)
                {
                        debug::TinyDebugWriter.WriteLine("IsEmpty is Changed:{0}", e.Current);
                        RaiseEvent(e);
                }

        }
}