public ImageSequence()
 {
     DefaultStyleKey = typeof(ImageSequence);
     imageHeight = 1600;
     Loaded += new System.Windows.RoutedEventHandler(ImageSequence_Loaded);
     SizeChanged += new SizeChangedEventHandler(ImageSequence_SizeChanged);
 }

        public CircleVisual(GMapMarker m, Brush background)
        {
            Marker = m;
             Marker.ZIndex = 100;

             Popup.AllowsTransparency = true;
             Popup.PlacementTarget = this;
             Popup.Placement = PlacementMode.Mouse;
             Popup.Child.Opacity = 0.777;

             SizeChanged += new SizeChangedEventHandler(CircleVisual_SizeChanged);
             MouseEnter += new System.Windows.Input.MouseEventHandler(CircleVisual_MouseEnter);
             MouseLeave += new System.Windows.Input.MouseEventHandler(CircleVisual_MouseLeave);
             Loaded += new RoutedEventHandler(OnLoaded);

             Text = "?";

             StrokeArrow.EndLineCap = PenLineCap.Triangle;
             StrokeArrow.LineJoin = PenLineJoin.Round;

             RenderTransform = scale;

             Width = Height = 22;
             FontSize = (Width/1.55);

             Background = background;
             Angle = null;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SceneView"/> class.
        /// </summary>
        public SceneView()
        {
            InitializeComponent();

            //  Handle the size changed event.
            SizeChanged += new SizeChangedEventHandler(SceneView_SizeChanged);
        }

 public ColorButton()
 {
     this.DefaultStyleKey = typeof(ColorButton);
     //if (System.ComponentModel.DesignerProperties.IsInDesignTool)
      //   return;
     SizeChanged += new SizeChangedEventHandler(ColorButton_SizeChanged);
 }

 public TPill()
 {
     InitializeComponent();
     tb.DataContext = this;
     foreColor = Colors.White;
     SizeChanged += new SizeChangedEventHandler(TPill_SizeChanged);
 }

        private void GlassWindow_Loaded( object sender, RoutedEventArgs e )
        {
            // update GlassRegion on window size change
            SizeChanged += new SizeChangedEventHandler( Window1_SizeChanged );

            // update background color on change of desktop composition mode
            AeroGlassCompositionChanged += new AeroGlassCompositionChangedEvent( Window1_AeroGlassCompositionChanged );

            // Set the window background color
            if( AeroGlassCompositionEnabled )
            {
                // exclude the GDI rendered controls from the initial GlassRegion
                ExcludeElementFromAeroGlass( eb1 );
                SetAeroGlassTransparency( );
            }
            else
            {
                this.Background = System.Windows.Media.Brushes.Teal;
            }

            // initialize the explorer browser control
            eb1.NavigationTarget = (ShellObject)KnownFolders.Computer;

            // set the state of the Desktop Composition check box.
            EnableCompositionCheck.IsChecked = AeroGlassCompositionEnabled;
        }

		public MainWindow() {
			InitializeComponent();

            devlistCaption.CreateBinding(TextBlock.TextProperty, LocalTitles.instance, s => s.devicesList);

			this.CommandBindings.Add(
				new CommandBinding(
					DeviceListView.HideCommand,
					(s, a) => {
						devlist.Visibility = Visibility.Collapsed;
						deviceListButton.Visibility = Visibility.Visible;
					}
				)
			);
			deviceListButton.Command = new DelegateCommand(
				() => {
					devlist.Visibility = Visibility.Visible;
					deviceListButton.Visibility = Visibility.Collapsed;
				}
			);


			//AppDefaults.InitConfigs();

			InitPosition();

			SizeChanged += new SizeChangedEventHandler((obj, evargs) => {
				var mvs = AppDefaults.visualSettings;
				mvs.WndState = this.WindowState;

				if (this.WindowState == System.Windows.WindowState.Maximized) {
					AppDefaults.UpdateVisualSettings(mvs);
					return;
				}

				if (this.WindowState == System.Windows.WindowState.Minimized) {
					AppDefaults.UpdateVisualSettings(mvs);
					return;
				}

				mvs.WndSize = new Rect(mvs.WndSize.X, mvs.WndSize.Y, evargs.NewSize.Width, evargs.NewSize.Height);
				AppDefaults.UpdateVisualSettings(mvs);
			});
			LocationChanged += new EventHandler((obj, evargs) => {
				var vs = AppDefaults.visualSettings;
				vs.WndState = this.WindowState;
				if (this.WindowState == System.Windows.WindowState.Maximized) {
					AppDefaults.UpdateVisualSettings(vs);
					return;
				}
				if (this.WindowState == System.Windows.WindowState.Minimized) {
					AppDefaults.UpdateVisualSettings(vs);
					return;
				}

				vs.WndSize = new Rect(this.Left, this.Top, vs.WndSize.Width, vs.WndSize.Height);
				AppDefaults.UpdateVisualSettings(vs);
			});
		}

 public RibbonWindow()
     : base()
 {
     SizeChanged += new SizeChangedEventHandler(OnSizeChanged);
     HookWndProc();
     RegisterCommands();
     SkinManager.SkinChanged += new EventHandler(OnSkinChanged);
 }

        public MainPage()
        {
            InitializeComponent();

            SupportedOrientations = SupportedPageOrientation.PortraitOrLandscape;
            SizeChanged += new SizeChangedEventHandler(BinaryClock_SizeChanged);
            Loaded += new RoutedEventHandler(BinaryClock_Loaded);
        }

        public TiledBackground()
        {
            // create an image as the content of the control
            tiledImage.Stretch = Stretch.None;
            Content = tiledImage;

            // no sizechanged to override
            SizeChanged += new SizeChangedEventHandler(TiledBackground_SizeChanged);
        }

        public GraphicsControlBase()
        {
            Loaded += new RoutedEventHandler(XnaWindowHost_Loaded);

            SizeChanged += new SizeChangedEventHandler(XnaWindowHost_SizeChanged);
            Application.Current.Activated += new EventHandler(Current_Activated);
            Application.Current.Deactivated += new EventHandler(Current_Deactivated);
            CompositionTarget.Rendering += CompositionTarget_Rendering;
        }

        public Viewport2D()
        {
         //   ClipToBounds = true;

            Grid.SetColumn(this, 1);
            Grid.SetRow(this, 1);
            visible = new Rect(new Point(0, 0), new Point(1, 1));
            SizeChanged += new SizeChangedEventHandler(Viewport2D_SizeChanged);
            UpdateTransform();
        }

 public Outline()
 {
     moves = new ObservableCollection<TXY>(outLineMoves);
     DataContext = this;
     fOutLineSize = 0.05;
     InitializeComponent();
     SizeChanged += new SizeChangedEventHandler(TPill_SizeChanged);
     text = "0";
     fKW = 1;
     fKH = 1;
 }

        internal LayoutDocumentPaneControl(LayoutDocumentPane model)
        {
            if (model == null)
                throw new ArgumentNullException("model");

            _model = model;
            SetBinding(ItemsSourceProperty, new Binding("Model.Children") { Source = this });
            SetBinding(FlowDirectionProperty, new Binding("Model.Root.Manager.FlowDirection") { Source = this });

            this.LayoutUpdated += new EventHandler(OnLayoutUpdated);
			SizeChanged += new SizeChangedEventHandler(LayoutDocumentPaneControl_SizeChanged);
        }

        public UIContainer()
        {
            m_elements = new VisualCollection(this);
            CreateElements();

            SnapsToDevicePixels = true;
            RenderOptions.SetEdgeMode(this, EdgeMode.Aliased);

            SizeChanged += new SizeChangedEventHandler((sender, e) => {
                VisualClip = new RectangleGeometry(new Rect(0, 0, ActualWidth, ActualHeight));
            });
        }

        /// <summary>
        /// Sets and registers the event handler responsible for monitoring
        /// size change events.
        /// </summary>
        /// <param name="sizeChangedEventHandler">The event handler.</param>
        public void SetOnSizeChangedListener(SizeChangedEventHandler sizeChangedEventHandler)
        {
            var current = _sizeChangedEventHandler;
            if (current != null)
            {
                SizeChanged -= current;
            }

            if (sizeChangedEventHandler != null)
            {
                _sizeChangedEventHandler = sizeChangedEventHandler;
                SizeChanged += _sizeChangedEventHandler;
            }
        }

        public GraphicsDeviceControl()
        {
            // We must be notified of the control finishing loading so we can get the GraphicsDeviceService
            Loaded += new System.Windows.RoutedEventHandler(XnaWindowHost_Loaded);

            // We must be notified of the control changing sizes so we can resize the GraphicsDeviceService
            SizeChanged += new SizeChangedEventHandler(XnaWindowHost_SizeChanged);

            // We must be notified of the application foreground status for our mouse input events
            Application.Current.Activated += new EventHandler(Current_Activated);
            Application.Current.Deactivated += new EventHandler(Current_Deactivated);

            // We use the CompositionTarget.Rendering event to trigger the control to draw itself
            CompositionTarget.Rendering += CompositionTarget_Rendering;
        }

        public SnapGrid()
        {
            LayoutUpdated += new EventHandler(SnapGrid_LayoutUpdated);
            SizeChanged += new SizeChangedEventHandler(SnapGrid_SizeChanged);
            MouseLeftButtonDown += new MouseButtonEventHandler(SnapGrid_MouseLeftButtonDown);
            MouseLeftButtonUp += new MouseButtonEventHandler(SnapGrid_MouseLeftButtonUp);
            LostMouseCapture += new MouseEventHandler(SnapGrid_LostMouseCapture);
            MouseMove += new MouseEventHandler(SnapGrid_MouseMove);
            Loaded += new RoutedEventHandler(SnapGrid_Loaded);

            ColumnCount = 20;
            RowCount = 20;
            ShowGridLines = true;

            Init();
        }

        public ChapterViewModel(Chapter chapter, FlipView flipView)
        {
            sizeChangedEventHandler = new SizeChangedEventHandler(textBlockResized);
            loadedEventHandler = new RoutedEventHandler(checkOverflow);
            this.flipView = flipView;
            this.chapter = chapter;
            this.Overflows = new List<RichTextBlockOverflow>();

            Windows.Storage.ApplicationDataContainer localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
            string currentChapter = (string)localSettings.Values["currentChapter"];
            if (currentChapter == null || currentChapter == "")
            {
                currentChapter = "jhn.1.esv";
            }
            ChangeChapter(currentChapter);
        }

 private FloatingWindow(DockPanel dockPanel)
 {
     Root = dockPanel;
     ShowInTaskbar = false;
     WindowStyle = WindowStyle.ToolWindow;
     WindowStartupLocation = WindowStartupLocation.Manual;
     m_dockOver = new List<IDockable>();
     Loaded += new RoutedEventHandler(FloatingWindow_Loaded);
     Closing += new System.ComponentModel.CancelEventHandler(FloatingWindow_Closing);
     MouseMove += new MouseEventHandler(FloatingWindow_MouseMove);
     MouseUp += new MouseButtonEventHandler(FloatingWindow_MouseUp);
     MouseLeave += new MouseEventHandler(FloatingWindow_MouseLeave);
     Activated += new EventHandler(FloatingWindow_Activated);
     LocationChanged += new EventHandler(FloatingWindow_LocationChanged);
     SizeChanged += new SizeChangedEventHandler(FloatingWindow_SizeChanged);
 }