ProcessWatchImpl/Scone/EventSurrogater.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using Toast.IsolationLayer;
using Toast.NicoNico;
using SeedCreate.CommonLibrary;

namespace Toast.Scone
{
        public sealed class EventSurrogater : Control
        {
                private EventHandler detectWatchProcessStart;
                private EventHandler detectWatchProcessTerminated;
                private EventHandler<DetectProgramStartEventArgs> programStarted;
                private EventHandler<ReceieverStatusChangedEventArgs> receieverStatusChanged;
                private EventHandler<TwitterWriteFailedEventArgs> twitterWriteFaild;


                public EventSurrogater()
                {
                        detectWatchProcessStart 
                                = new EventHandler((sender, e) => OnWatchingProcessStarted(new RoutedEventArgs(WatchingProcessStartedEvent)));

                        detectWatchProcessTerminated
                                = new EventHandler((sender, e) => OnWachingProcessTerminated(new RoutedEventArgs(WathingProcessTerminatedEvent)));

                        programStarted
                                = new EventHandler<DetectProgramStartEventArgs>((sender, e) =>
                                        OnProgramStarted(new MonoFieldRoutedEventArgs<LiveProgram>(e.TargetProgram, ProgramStartedEvent)));

                        receieverStatusChanged
                                = new EventHandler<ReceieverStatusChangedEventArgs>((sender, e) =>
                                        OnRecieverStatusChanged(new RoutedPropertyChangedEventArgs<ReceieverStatus>(e.Recent, e.Current, ReceieverStatusChangedEvent)));

                        twitterWriteFaild
                                = new EventHandler<TwitterWriteFailedEventArgs>((sender, e) =>
                                        OnTwitterWriteFailed(new MonoFieldRoutedEventArgs<Pair<Exception, string>>(new Pair<Exception, string>(e.CauseException, e.Message),
                                                TwitterWriteFailedEvent)));


                }

                public static readonly DependencyProperty TargetProperty
                        = DependencyProperty.Register("Target", typeof(Toast.IsolationLayer.Repeater),
                        typeof(EventSurrogater));

                public Repeater Target
                {
                        get
                        {
                                return (Repeater)GetValue(TargetProperty);
                        }
                        set
                        {
                                if (value == null)
                                {
                                        throw new NullReferenceException("Target is null referenced");
                                }

                                if (!object.ReferenceEquals(Target,value))
                                {
                                        Target.DetectWatchProcessStarted -= detectWatchProcessStart;
                                        Target.DetectWatchProcessTerminated -= detectWatchProcessTerminated;
                                        Target.ProgramStarted -= programStarted;
                                        Target.ReceieverStatusChanged -= receieverStatusChanged;
                                        Target.TwitterWriteFailed -= twitterWriteFaild;
                                }

                                value.DetectWatchProcessStarted += detectWatchProcessStart;
                                value.DetectWatchProcessTerminated += detectWatchProcessTerminated;
                                value.ProgramStarted += programStarted;
                                value.ReceieverStatusChanged += receieverStatusChanged;
                                value.TwitterWriteFailed += twitterWriteFaild;

                                SetValue(TargetProperty, value);
                        }
                }


                public static readonly RoutedEvent WatchingProcessStartedEvent
                        = EventManager.RegisterRoutedEvent("WatchingProcessStarted", RoutingStrategy.Bubble, typeof(RoutedEventHandler),
                        typeof(EventSurrogater));

                public event RoutedEventHandler WatchingProcessStarted
                {
                        add
                        {
                                AddHandler(WatchingProcessStartedEvent, value);
                        }
                        remove
                        {
                                RemoveHandler(WatchingProcessStartedEvent, value);
                        }
                }


                private void OnWatchingProcessStarted(RoutedEventArgs e)
                {
                        RaiseEvent(e);
                }


                public static readonly RoutedEvent WathingProcessTerminatedEvent =
                        EventManager.RegisterRoutedEvent("WatchingProcessTerminated", RoutingStrategy.Bubble,
                        typeof(RoutedEventHandler), typeof(EventSurrogater));

                public event RoutedEventHandler WatchingProcessTerminated
                {
                        add
                        {
                                AddHandler(WathingProcessTerminatedEvent, value);
                        }
                        remove
                        {
                                RemoveHandler(WathingProcessTerminatedEvent, value);
                        }
                }


                private void OnWachingProcessTerminated(RoutedEventArgs e)
                {
                        RaiseEvent(e);
                }


                public static readonly RoutedEvent ProgramStartedEvent
                        = EventManager.RegisterRoutedEvent("ProgramStarted", RoutingStrategy.Bubble,
                        typeof(MonoFieldRoutedEventHandler<LiveProgram>), typeof(EventSurrogater));

                public event MonoFieldRoutedEventHandler<LiveProgram> ProgramStarted
                {
                        add
                        {
                                AddHandler(ProgramStartedEvent, value);
                        }
                        remove
                        {
                                RemoveHandler(ProgramStartedEvent, value);
                        }
                }

                private void OnProgramStarted(MonoFieldRoutedEventArgs<LiveProgram> e)
                {
                        RaiseEvent(e);
                }


                public static readonly RoutedEvent ReceieverStatusChangedEvent=
                        EventManager.RegisterRoutedEvent("ReceiverStatusChanged", RoutingStrategy.Bubble,
                        typeof(RoutedPropertyChangedEventHandler<ReceieverStatus>),typeof(EventSurrogater));

                public event RoutedPropertyChangedEventHandler<ReceieverStatus> ReceieverStatusChanged
                {
                        add
                        {
                                AddHandler(ReceieverStatusChangedEvent, value);
                        }
                        remove
                        {
                                RemoveHandler(ReceieverStatusChangedEvent, value);
                        }
                }

                private void OnRecieverStatusChanged(RoutedPropertyChangedEventArgs<ReceieverStatus> e)
                {
                        RaiseEvent(e);
                }

                public static readonly RoutedEvent TwitterWriteFailedEvent=
                        EventManager.RegisterRoutedEvent("TwitterWriteFailed", RoutingStrategy.Bubble,
                        typeof(MonoFieldRoutedEventArgs<SeedCreate.CommonLibrary.Pair<System.Net.WebException,string>>),
                        typeof(EventSurrogater));

                public event MonoFieldRoutedEventHandler<SeedCreate.CommonLibrary.Pair<Exception, string>> TwitterWriteFailed
                {
                        add
                        {
                                AddHandler(TwitterWriteFailedEvent, value);
                        }
                        remove
                        {
                                RemoveHandler(TwitterWriteFailedEvent, value);
                        }
                }

                private void OnTwitterWriteFailed(MonoFieldRoutedEventArgs<Pair<Exception, string>> e)
                {
                        RaiseEvent(e);
                }


        }
}