BulletChrome.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Themes / Aero / Microsoft / Windows / Themes / BulletChrome.cs / 1305600 / BulletChrome.cs

                            //---------------------------------------------------------------------------- 
// File: BulletChrome.cs
//
// Description:
// Implementation of thick chrome for CheckBoxes and RadioButtons in Aero. 
//
// Copyright (C) by Microsoft Corporation.  All rights reserved. 
// 
//---------------------------------------------------------------------------
 
using System.Windows.Shapes;
using System.Windows.Controls;
using System.Diagnostics;
using System.Threading; 

using System.ComponentModel; 
using System.Windows; 
using System.Windows.Media;
using System.Windows.Media.Animation; 
using MS.Internal;

using System;
 
namespace Microsoft.Windows.Themes
{ 
    ///  
    /// The BulletChrome element
    /// This element is a theme-specific type that is used as an optimization 
    /// for a common complex rendering used in Aero
    ///
    /// 
    public sealed class BulletChrome : FrameworkElement 
    {
        #region Constructors 
 
        static BulletChrome()
        { 
            IsEnabledProperty.OverrideMetadata(typeof(BulletChrome), new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.AffectsRender, new PropertyChangedCallback(OnIsEnabledChanged)));
        }

        private static void OnIsEnabledChanged(DependencyObject o, DependencyPropertyChangedEventArgs e) 
        {
            OnIsCheckedChanged(o, e); 
        } 

        ///  
        /// Instantiates a new instance of a BulletChrome with no parent element.
        /// 
        /// 
        public BulletChrome() 
        {
        } 
 
        #endregion Constructors
 
        #region Dynamic Properties

        /// 
        /// DependencyProperty for  property. 
        /// 
        public static readonly DependencyProperty BackgroundProperty = 
                    Control.BackgroundProperty.AddOwner( 
                            typeof(BulletChrome),
                            new FrameworkPropertyMetadata( 
                                    null,
                                    FrameworkPropertyMetadataOptions.AffectsRender));

        ///  
        /// The Background property defines the brush used to fill the background of the button.
        ///  
        public Brush Background 
        {
            get { return (Brush) GetValue(BackgroundProperty); } 
            set { SetValue(BackgroundProperty, value); }
        }

 
        /// 
        /// DependencyProperty for  property. 
        ///  
        public static readonly DependencyProperty BorderBrushProperty =
                Border.BorderBrushProperty.AddOwner( 
                        typeof(BulletChrome),
                        new FrameworkPropertyMetadata(
                                null,
                                FrameworkPropertyMetadataOptions.AffectsRender)); 

        ///  
        /// The BorderBrush property defines the brush used to draw the outer border. 
        /// 
        public Brush BorderBrush 
        {
            get { return (Brush) GetValue(BorderBrushProperty); }
            set { SetValue(BorderBrushProperty, value); }
        } 

        ///  
        /// DependencyProperty for  property. 
        /// 
        public static readonly DependencyProperty RenderMouseOverProperty = 
                 DependencyProperty.Register("RenderMouseOver",
                         typeof(bool),
                         typeof(BulletChrome),
                         new FrameworkPropertyMetadata( 
                                false,
                                new PropertyChangedCallback(OnRenderMouseOverChanged))); 
 
        /// 
        /// When true the chrome renders with a mouse over look. 
        /// 
        public bool RenderMouseOver
        {
            get { return (bool)GetValue(RenderMouseOverProperty); } 
            set { SetValue(RenderMouseOverProperty, value); }
        } 
 
        private static void OnRenderMouseOverChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
        { 
            BulletChrome chrome = ((BulletChrome)o);

            if (chrome.Animates)
            { 
                if (((bool)e.NewValue))
                { 
                    AnimateToHover(chrome); 
                }
                else if (chrome._localResources == null) 
                {
                    chrome.InvalidateVisual();
                }
                else 
                {
                    Duration duration = new Duration(TimeSpan.FromSeconds(0.2)); 
 
                    DoubleAnimation da = new DoubleAnimation();
                    da.Duration = duration; 

                    chrome.BorderOverlayPen.Brush.BeginAnimation(SolidColorBrush.OpacityProperty, da);
                    chrome.BackgroundOverlay.BeginAnimation(SolidColorBrush.OpacityProperty, da);
                    GradientStopCollection stops; 
                    ColorAnimation ca = new ColorAnimation();
 
                    if (chrome.IsChecked == null) 
                    {
                        AnimateToIndeterminate(chrome); 
                    }
                    else
                    {
                        ca.Duration = duration; 

                        stops = ((GradientBrush)chrome.InnerBorderPen.Brush).GradientStops; 
                        stops[0].BeginAnimation(GradientStop.ColorProperty, ca); 
                        stops[1].BeginAnimation(GradientStop.ColorProperty, ca);
                        stops[2].BeginAnimation(GradientStop.ColorProperty, ca); 

                        chrome.InnerFill.GradientStops[0].BeginAnimation(GradientStop.ColorProperty, ca);
                        chrome.InnerFill.GradientStops[1].BeginAnimation(GradientStop.ColorProperty, ca);
                    } 

                    if (chrome.IsRound) 
                    { 
                        stops = ((GradientBrush)chrome.GlyphFill).GradientStops;
                        stops[0].BeginAnimation(GradientStop.ColorProperty, ca); 
                        stops[1].BeginAnimation(GradientStop.ColorProperty, ca);
                        stops[2].BeginAnimation(GradientStop.ColorProperty, ca);
                    }
                } 
            }
            else 
            { 
                chrome._localResources = null;
                chrome.InvalidateVisual(); 
            }
        }

        private static void AnimateToHover(BulletChrome chrome) 
        {
            if (chrome._localResources == null) 
            { 
                chrome._localResources = new LocalResources();
                chrome.InvalidateVisual(); 
            }

            Duration duration = new Duration(TimeSpan.FromSeconds(0.3));
 
            DoubleAnimation da = new DoubleAnimation(1, duration);
 
            // Border and Background Overlay Opacity 
            chrome.BorderOverlayPen.Brush.BeginAnimation(SolidColorBrush.OpacityProperty, da);
            chrome.BackgroundOverlay.BeginAnimation(SolidColorBrush.OpacityProperty, da); 

            // Background and Border Overlay Colors
            ColorAnimation ca = new ColorAnimation();
            ca.Duration = duration; 
            chrome.BorderOverlayPen.Brush.BeginAnimation(SolidColorBrush.ColorProperty, ca);
            chrome.BackgroundOverlay.BeginAnimation(SolidColorBrush.ColorProperty, ca); 
            GradientStopCollection stops; 

 
            if (chrome.IsChecked == null)
            {
                // InnerBorder
                stops = ((GradientBrush)chrome.InnerBorderPen.Brush).GradientStops; 

                ca = new ColorAnimation(Color.FromRgb(0x29, 0x62, 0x8D), duration); 
                stops[0].BeginAnimation(GradientStop.ColorProperty, ca); 

                ca = new ColorAnimation(Color.FromRgb(0x24, 0x54, 0x79), duration); 
                stops[1].BeginAnimation(GradientStop.ColorProperty, ca);

                ca = new ColorAnimation(Color.FromRgb(0x19, 0x3B, 0x55), duration);
                stops[2].BeginAnimation(GradientStop.ColorProperty, ca); 

                // InnerFill 
                ca = new ColorAnimation(Color.FromRgb(0x33, 0xD7, 0xED), duration); 
                chrome.InnerFill.GradientStops[0].BeginAnimation(GradientStop.ColorProperty, ca);
 
                ca = new ColorAnimation(Color.FromRgb(0x20, 0x94, 0xCE), duration);
                chrome.InnerFill.GradientStops[1].BeginAnimation(GradientStop.ColorProperty, ca);

                // Highlight Brush 
                stops = ((GradientBrush)chrome.HighlightStroke.Brush).GradientStops;
 
 
                ca = new ColorAnimation(Color.FromArgb(0x80, 0xFF, 0xFF, 0xFF), duration);
                stops[0].BeginAnimation(GradientStop.ColorProperty, ca); 

                ca = new ColorAnimation(Color.FromArgb(0x00, 0x33, 0x33, 0xA0), duration);
                stops[2].BeginAnimation(GradientStop.ColorProperty, ca);
 
                ca = new ColorAnimation(Color.FromArgb(0x80, 0x33, 0x33, 0xA0), duration);
                stops[3].BeginAnimation(GradientStop.ColorProperty, ca); 
            } 
            else
            { 
                // Inner Border Gradient Stops
                stops = ((GradientBrush)chrome.InnerBorderPen.Brush).GradientStops;

                ca = new ColorAnimation(Color.FromRgb(0x79, 0xC6, 0xF9), duration); 
                stops[0].BeginAnimation(GradientStop.ColorProperty, ca);
 
                ca = new ColorAnimation(Color.FromRgb(0x79, 0xC6, 0xF9), duration); 
                stops[1].BeginAnimation(GradientStop.ColorProperty, ca);
 
                ca = new ColorAnimation(Color.FromRgb(0xD2, 0xED, 0xFD), duration);
                stops[2].BeginAnimation(GradientStop.ColorProperty, ca);

 
                // Inner Fill
                ca = new ColorAnimation(Color.FromRgb(0xB1, 0xDF, 0xFD), duration); 
                chrome.InnerFill.GradientStops[0].BeginAnimation(GradientStop.ColorProperty, ca); 

                ca = new ColorAnimation(Color.FromRgb(0xE9, 0xF7, 0xFE), duration); 
                chrome.InnerFill.GradientStops[1].BeginAnimation(GradientStop.ColorProperty, ca);
            }

 
            // Glyph Fill
            if (chrome.IsRound && chrome.IsChecked == true) 
            { 
                stops = ((GradientBrush)chrome.GlyphFill).GradientStops;
 
                ca = new ColorAnimation(Color.FromRgb(0xFF, 0xFF, 0xFF), duration);
                stops[0].BeginAnimation(GradientStop.ColorProperty, ca);

                ca = new ColorAnimation(Color.FromRgb(0x74, 0xFF, 0xFF), duration); 
                stops[1].BeginAnimation(GradientStop.ColorProperty, ca);
 
                ca = new ColorAnimation(Color.FromRgb(0x0D, 0xA0, 0xF3), duration); 
                stops[2].BeginAnimation(GradientStop.ColorProperty, ca);
            } 
        }

        private static void AnimateToIndeterminate(BulletChrome chrome)
        { 
            DoubleAnimation da = new DoubleAnimation();
            Duration duration = new Duration(TimeSpan.FromSeconds(0.3)); 
            da.Duration = duration; 

            chrome.GlyphStroke.Brush.BeginAnimation(SolidColorBrush.OpacityProperty, da); 
            chrome.GlyphFill.BeginAnimation(SolidColorBrush.OpacityProperty, da);

            da = new DoubleAnimation(1.0, duration);
            chrome.HighlightStroke.Brush.BeginAnimation(LinearGradientBrush.OpacityProperty, da); 

            ColorAnimation ca = new ColorAnimation(Color.FromRgb(0x2A, 0x62, 0x8D), duration); 
 
            // Inner Border Pen
            GradientStopCollection stops = ((GradientBrush)chrome.InnerBorderPen.Brush).GradientStops; 

            stops[0].BeginAnimation(GradientStop.ColorProperty, ca);

            ca = new ColorAnimation(Color.FromRgb(0x24, 0x54, 0x79), duration); 
            stops[1].BeginAnimation(GradientStop.ColorProperty, ca);
 
            ca = new ColorAnimation(Color.FromRgb(0x19, 0x3B, 0x55), duration); 
            stops[2].BeginAnimation(GradientStop.ColorProperty, ca);
 
            // InnerFill
            ca = new ColorAnimation(Color.FromRgb(0x2F, 0xA8, 0xD5), duration);
            chrome.InnerFill.GradientStops[0].BeginAnimation(GradientStop.ColorProperty, ca);
 
            ca = new ColorAnimation(Color.FromRgb(0x25, 0x59, 0x8C), duration);
            chrome.InnerFill.GradientStops[1].BeginAnimation(GradientStop.ColorProperty, ca); 
 
            // Highlight Brush
            stops = ((GradientBrush)chrome.HighlightStroke.Brush).GradientStops; 

            ca = new ColorAnimation(Color.FromArgb(0x80, 0xFF, 0xFF, 0xFF), duration);
            stops[0].BeginAnimation(GradientStop.ColorProperty, ca);
 
            ca = new ColorAnimation(Color.FromArgb(0x00, 0x33, 0x33, 0xA0), duration);
            stops[2].BeginAnimation(GradientStop.ColorProperty, ca); 
 
            ca = new ColorAnimation(Color.FromArgb(0x00, 0x33, 0x33, 0xA0), duration);
            stops[3].BeginAnimation(GradientStop.ColorProperty, ca); 
        }

        /// 
        /// DependencyProperty for  property. 
        /// 
        public static readonly DependencyProperty RenderPressedProperty = 
                 DependencyProperty.Register("RenderPressed", 
                         typeof(bool),
                         typeof(BulletChrome), 
                         new FrameworkPropertyMetadata(
                                false,
                                new PropertyChangedCallback(OnRenderPressedChanged)));
 
        /// 
        /// When true the chrome renders with a pressed look. 
        ///  
        public bool RenderPressed
        { 
            get { return (bool)GetValue(RenderPressedProperty); }
            set { SetValue(RenderPressedProperty, value); }
        }
 
        private static void OnRenderPressedChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
        { 
            BulletChrome chrome = ((BulletChrome)o); 

            if (chrome.Animates) 
            {
                if (((bool)e.NewValue))
                {
                    if (chrome._localResources == null) 
                    {
                        chrome._localResources = new LocalResources(); 
                        chrome.InvalidateVisual(); 
                    }
 
                    Duration duration = new Duration(TimeSpan.FromSeconds(0.3));

                    ColorAnimation ca = new ColorAnimation(Color.FromRgb(0x2C, 0x62, 0x8B), duration);
                    chrome.BorderOverlayPen.Brush.BeginAnimation(SolidColorBrush.ColorProperty, ca); 

                    ca = new ColorAnimation(Color.FromRgb(0xC2, 0xE4, 0xF6), duration); 
                    chrome.BackgroundOverlay.BeginAnimation(SolidColorBrush.ColorProperty, ca); 

                    if (chrome.IsChecked == null) 
                    {
                        // InnerBorderPen
                        GradientStopCollection stops = ((GradientBrush)chrome.InnerBorderPen.Brush).GradientStops;
 
                        ca = new ColorAnimation(Color.FromRgb(0x19, 0x3B, 0x55), duration);
                        stops[0].BeginAnimation(GradientStop.ColorProperty, ca); 
 
                        ca = new ColorAnimation(Color.FromRgb(0x24, 0x54, 0x79), duration);
                        stops[1].BeginAnimation(GradientStop.ColorProperty, ca); 

                        ca = new ColorAnimation(Color.FromRgb(0x29, 0x62, 0x8D), duration);
                        stops[2].BeginAnimation(GradientStop.ColorProperty, ca);
 
                        //InnerFill
                        ca = new ColorAnimation(Color.FromRgb(0x17, 0x44, 0x7A), duration); 
                        chrome.InnerFill.GradientStops[0].BeginAnimation(GradientStop.ColorProperty, ca); 

                        ca = new ColorAnimation(Color.FromRgb(0x21, 0x8B, 0xC3), duration); 
                        chrome.InnerFill.GradientStops[1].BeginAnimation(GradientStop.ColorProperty, ca);

                        // HighlightStroke
                        stops = ((GradientBrush)chrome.HighlightStroke.Brush).GradientStops; 

                        ca = new ColorAnimation(Color.FromArgb(0x00, 0xFF, 0xFF, 0xFF), duration); 
                        stops[0].BeginAnimation(GradientStop.ColorProperty, ca); 

                        ca = new ColorAnimation(Color.FromArgb(0x00, 0xFF, 0xFF, 0xFF), duration); 
                        stops[2].BeginAnimation(GradientStop.ColorProperty, ca);

                        ca = new ColorAnimation(Color.FromArgb(0x20, 0xFF, 0xFF, 0xFF), duration);
                        stops[3].BeginAnimation(GradientStop.ColorProperty, ca); 
                    }
                    else 
                    { 
                        // Inner Border Pen
                        GradientStopCollection stops = ((GradientBrush)chrome.InnerBorderPen.Brush).GradientStops; 

                        ca = new ColorAnimation(Color.FromRgb(0x54, 0xA6, 0xD5), duration);
                        stops[0].BeginAnimation(GradientStop.ColorProperty, ca);
 
                        ca = new ColorAnimation(Color.FromRgb(0x5E, 0xB5, 0xE4), duration);
                        stops[1].BeginAnimation(GradientStop.ColorProperty, ca); 
 
                        ca = new ColorAnimation(Color.FromRgb(0xC4, 0xE5, 0xF6), duration);
                        stops[2].BeginAnimation(GradientStop.ColorProperty, ca); 

                        // Inner Fill
                        ca = new ColorAnimation(Color.FromRgb(0x7F, 0xBA, 0xDC), duration);
                        chrome.InnerFill.GradientStops[0].BeginAnimation(GradientStop.ColorProperty, ca); 

                        ca = new ColorAnimation(Color.FromRgb(0xD6, 0xED, 0xF9), duration); 
                        chrome.InnerFill.GradientStops[1].BeginAnimation(GradientStop.ColorProperty, ca); 
                    }
 
                    if (chrome.IsChecked != null)
                    {
                        DoubleAnimation da = new DoubleAnimation(1.0, duration);
 
                        chrome.GlyphFill.BeginAnimation(Brush.OpacityProperty, da);
                        chrome.GlyphStroke.Brush.BeginAnimation(Brush.OpacityProperty, da); 
                    } 

                    if (chrome.IsRound) 
                    {
                        GradientStopCollection stops = ((GradientBrush)chrome.GlyphFill).GradientStops;

                        ca = new ColorAnimation(Color.FromRgb(0x95, 0xD9, 0xFC), duration); 
                        stops[0].BeginAnimation(GradientStop.ColorProperty, ca);
 
                        ca = new ColorAnimation(Color.FromRgb(0x3A, 0x84, 0xAA), duration); 
                        stops[1].BeginAnimation(GradientStop.ColorProperty, ca);
 
                        ca = new ColorAnimation(Color.FromRgb(0x07, 0x54, 0x83), duration);
                        stops[2].BeginAnimation(GradientStop.ColorProperty, ca);
                    }
                } 
                else if (chrome._localResources == null)
                { 
                    chrome.InvalidateVisual(); 
                }
                else 
                {
                    AnimateToHover(chrome);

                    Duration duration = new Duration(TimeSpan.FromSeconds(0.3)); 
                    if (chrome.IsChecked != true)
                    { 
                        DoubleAnimation da = new DoubleAnimation(); 
                        da.Duration = duration;
                        chrome.GlyphFill.BeginAnimation(Brush.OpacityProperty, da); 
                        chrome.GlyphStroke.Brush.BeginAnimation(Brush.OpacityProperty, da);
                    }

                    if (chrome.IsRound) 
                    {
                        ColorAnimation ca = new ColorAnimation(); 
                        ca.Duration = duration; 

                        GradientStopCollection stops = ((GradientBrush)chrome.GlyphFill).GradientStops; 
                        stops[0].BeginAnimation(GradientStop.ColorProperty, ca);
                        stops[1].BeginAnimation(GradientStop.ColorProperty, ca);
                        stops[2].BeginAnimation(GradientStop.ColorProperty, ca);
                    } 
                }
            } 
            else 
            {
                chrome._localResources = null; 
                chrome.InvalidateVisual();
            }
        }
 
        /// 
        /// DependencyProperty for  property. 
        ///  
        public static readonly DependencyProperty IsCheckedProperty =
                 DependencyProperty.Register("IsChecked", 
                         typeof(bool?),
                         typeof(BulletChrome),
                         new FrameworkPropertyMetadata(
                                ((bool?)false), 
                                new PropertyChangedCallback(OnIsCheckedChanged)));
 
        ///  
        /// When true, the left border will have round corners, otherwise they will be square.
        ///  
        public bool? IsChecked
        {
            get { return (bool?)GetValue(IsCheckedProperty); }
            set { SetValue(IsCheckedProperty, value); } 
        }
 
        // Also called when IsRound and IsEnabled changes to set up Glyph animations 
        private static void OnIsCheckedChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
        { 
            BulletChrome chrome = ((BulletChrome)o);

            if (chrome.Animates)
            { 
                if (chrome._localResources == null)
                { 
                    chrome._localResources = new LocalResources(); 
                    chrome.InvalidateVisual();
                } 

                Duration duration = new Duration(TimeSpan.FromSeconds(0.3));

                if (chrome.IsChecked == null) 
                {
                    AnimateToIndeterminate(chrome); 
                } 
                else
                { 
                    if (chrome.IsChecked == true)
                    {
                        DoubleAnimation da = new DoubleAnimation(1, duration);
 
                        chrome.GlyphStroke.Brush.BeginAnimation(Brush.OpacityProperty, da);
                        chrome.GlyphFill.BeginAnimation(Brush.OpacityProperty, da); 
 
                        da = new DoubleAnimation();
                        da.Duration = duration; 
                        chrome.HighlightStroke.Brush.BeginAnimation(Brush.OpacityProperty, da);
                    }
                    else
                    { 
                        DoubleAnimation da = new DoubleAnimation();
                        da.Duration = duration; 
 
                        chrome.GlyphStroke.Brush.BeginAnimation(SolidColorBrush.OpacityProperty, da);
                        chrome.GlyphFill.BeginAnimation(SolidColorBrush.OpacityProperty, da); 
                        chrome.HighlightStroke.Brush.BeginAnimation(Brush.OpacityProperty, da);
                    }

                    if (chrome.RenderMouseOver) 
                    {
                        AnimateToHover(chrome); 
                    } 
                    else
                    { 
                        ColorAnimation ca = new ColorAnimation();
                        ca.Duration = duration;
                        GradientStopCollection stops = ((GradientBrush)chrome.InnerBorderPen.Brush).GradientStops;
                        stops[0].BeginAnimation(GradientStop.ColorProperty, ca); 
                        stops[1].BeginAnimation(GradientStop.ColorProperty, ca);
                        stops[2].BeginAnimation(GradientStop.ColorProperty, ca); 
 
                        chrome.InnerFill.GradientStops[0].BeginAnimation(GradientStop.ColorProperty, ca);
                        chrome.InnerFill.GradientStops[1].BeginAnimation(GradientStop.ColorProperty, ca); 

                    }
                }
            } 
            else
            { 
                chrome._localResources = null; 
                chrome.InvalidateVisual();
            } 
        }

        /// 
        /// DependencyProperty for  property. 
        /// 
        public static readonly DependencyProperty IsRoundProperty = 
                 DependencyProperty.Register("IsRound", 
                         typeof(bool),
                         typeof(BulletChrome), 
                         new FrameworkPropertyMetadata(
                                false,
                                FrameworkPropertyMetadataOptions.AffectsRender,
                                new PropertyChangedCallback(OnIsRoundChanged))); 

        private static void OnIsRoundChanged(DependencyObject o, DependencyPropertyChangedEventArgs e) 
        { 
            ((BulletChrome)o)._localResources = null;
 
            // Force update of glyph colors
            OnIsCheckedChanged(o, e);
        }
 
        /// 
        /// When true, the left border will have round corners, otherwise they will be square. 
        ///  
        public bool IsRound
        { 
            get { return (bool)GetValue(IsRoundProperty); }
            set { SetValue(IsRoundProperty, value); }
        }
 

        #endregion Dynamic Properties 
 
        #region Protected Methods
 
        /// 
        /// Updates DesiredSize of the BulletChrome.  Called by parent UIElement.  This is the first pass of layout.
        /// 
        /// Available size is an "upper limit" that the return value should not exceed. 
        /// The BulletChrome's desired size.
        protected override Size MeasureOverride(Size availableSize) 
        { 
            if (IsRound)
                return new Size(12.0, 12.0); 
            else
                return new Size(13.0, 13.0);
        }
 

        ///  
        /// Render callback. 
        /// 
        protected override void OnRender(DrawingContext drawingContext) 
        {
            Rect bounds = new Rect(0, 0, ActualWidth, ActualHeight);

            // Draw Background 
            DrawBackground(drawingContext, ref bounds);
 
            // Draw innerborder and fill with inner fill 
            DrawInnerBorder(drawingContext, ref bounds);
 
            DrawGlyph(drawingContext, ref bounds);

            // Draw outer border
            DrawBorder(drawingContext, ref bounds); 
        }
 
 
        private void DrawBackground(DrawingContext dc, ref Rect bounds)
        { 
            if ((bounds.Width > 4.0) && (bounds.Height > 4.0))
            {
                Brush fill = Background;
 

                if (!IsRound) 
                { 
                    Rect backgroundRect = new Rect(bounds.Left + 1.0,
                                                   bounds.Top + 1.0, 
                                                   bounds.Width - 2.0,
                                                   bounds.Height - 2.0);
                    // Draw Background
                    if (fill != null) 
                        dc.DrawRectangle(fill, null, backgroundRect);
 
                    // Draw BackgroundOverlay 
                    fill = BackgroundOverlay;
                    if (fill != null) 
                        dc.DrawRectangle(fill, null, backgroundRect);
                }
                else
                { 
                    double centerX = bounds.Width * 0.5;
                    double centerY = bounds.Height * 0.5; 
 
                    // Draw Background
                    if (fill != null) 
                        dc.DrawEllipse(fill, null, new Point(centerX, centerY), centerX - 1, centerY - 1);

                    // Draw BackgroundOverlay
                    fill = BackgroundOverlay; 
                    if (fill != null)
                        dc.DrawEllipse(fill, null, new Point(centerX, centerY), centerX - 1, centerY - 1); 
                } 
            }
        } 


        // Draw the inner border
        private void DrawInnerBorder(DrawingContext dc, ref Rect bounds) 
        {
            if ((bounds.Width >= 6.0) && (bounds.Height >= 6.0)) 
            { 
                Brush innerFill = InnerFill;
 
                if (!IsRound)
                {
                    if (innerFill != null)
                    { 
                        dc.DrawRectangle(innerFill, null, new Rect(bounds.Left + 3.0, bounds.Top + 3.0, bounds.Width - 6.0, bounds.Height - 6.0));
                    } 
 
                    Pen innerBorder = InnerBorderPen;
 
                    if (innerBorder != null)
                    {
                        dc.DrawRectangle(null, innerBorder, new Rect(bounds.Left + 2.5, bounds.Top + 2.5, bounds.Width - 5.0, bounds.Height - 5.0));
                    } 
                }
                else 
                { 
                    double centerX = bounds.Width * 0.5;
                    double centerY = bounds.Height * 0.5; 

                    if (innerFill != null)
                    {
                        dc.DrawEllipse(innerFill, null, new Point(centerX, centerY), centerX - 3.0, centerY - 3.0); 
                    }
 
                    Pen innerBorder = InnerBorderPen; 

                    if (innerBorder != null) 
                    {
                        dc.DrawEllipse(null, innerBorder, new Point(centerX, centerY), centerX - 2.5, centerY - 2.5);
                    }
                } 
            }
        } 
 
        // Draw the CheckMark or Dot
        private void DrawGlyph(DrawingContext dc, ref Rect bounds) 
        {
            if (!IsRound)
            {
 
                // Need to reverse Checkbox in RTL so it draws to screen the same as LTR
                if (FlowDirection == FlowDirection.RightToLeft) 
                { 
                    dc.PushTransform(new ScaleTransform(-1.0, 1.0, 6.5, 0));
                } 

                dc.DrawGeometry(null, GlyphStroke, CheckMarkGeometry);
                dc.DrawGeometry(GlyphFill, null, CheckMarkGeometry);
 
                if (FlowDirection == FlowDirection.RightToLeft)
                { 
                    dc.Pop(); 
                }
 
                dc.DrawRectangle(null, HighlightStroke, new Rect(3.5, 3.5, 6, 6));
            }
            else
            { 
                double centerX = bounds.Width * 0.5;
                double centerY = bounds.Height * 0.5; 
                dc.DrawEllipse(GlyphFill, GlyphStroke, new Point(centerX, centerY), centerX - 3, centerY - 3); 
            }
        } 

        // Draw the main border
        private void DrawBorder(DrawingContext dc, ref Rect bounds)
        { 
            if ((bounds.Width >= 5.0) && (bounds.Height >= 5.0))
            { 
 
                Pen pen = GetBorderPen(BorderBrush);
                Pen overlayPen = BorderOverlayPen; 

                if (pen != null || overlayPen != null)
                {
                    if (!IsRound) 
                    {
                        Rect rect = new Rect(bounds.Left + 0.5, 
                                            bounds.Top + 0.5, 
                                            bounds.Width - 1.0,
                                            bounds.Height - 1.0); 

                        if (pen != null)
                            dc.DrawRectangle(null, pen, rect);
 
                        if (overlayPen != null)
                            dc.DrawRectangle(null, overlayPen, rect); 
                    } 
                    else
                    { 
                        double centerX = bounds.Width * 0.5;
                        double centerY = bounds.Height * 0.5;

                        if (pen != null) 
                            dc.DrawEllipse(null, pen, new Point(centerX, centerY), centerX - 0.5, centerY - 0.5);
 
                        if (overlayPen != null) 
                            dc.DrawEllipse(null, overlayPen, new Point(centerX, centerY), centerX - 0.5, centerY - 0.5);
                    } 
                }
            }
        }
 

        private static Pen GetBorderPen(Brush border) 
        { 
            Pen pen = null;
 
            if (border != null)
            {
                if (_commonBorderPen == null)   // Common case, if non-null, avoid the lock
                { 
                    lock (_resourceAccess)   // If non-null, lock to create the pen for thread safety
                    { 
                        if (_commonBorderPen == null)   // Check again in case _pen was created within the last line 
                        {
                            // Assume that the first render of Button uses the most common brush for the app. 
                            // This breaks down if (a) the first Button is disabled, (b) the first Button is
                            // customized, or (c) BulletChrome becomes more broadly used than just on Button.
                            //
                            // If these cons sufficiently weaken the effectiveness of this cache, then we need 
                            // to build a larger brush-to-pen mapping cache.
 
 
                            // If the brush is not already frozen, we need to create our own
                            // copy.  Otherwise we will inadvertently freeze the user's 
                            // BorderBrush when we freeze the pen below.
                            if (!border.IsFrozen && border.CanFreeze)
                            {
                                border = border.Clone(); 
                                border.Freeze();
                            } 
 
                            Pen commonPen = new Pen(border, 1);
                            if (commonPen.CanFreeze) 
                            {
                                // Only save frozen pens, some brushes such as VisualBrush
                                // can not be frozen
                                commonPen.Freeze(); 
                                _commonBorderPen = commonPen;
                            } 
                        } 
                    }
                } 

                if (_commonBorderPen != null && border == _commonBorderPen.Brush)
                {
 
                    pen = _commonBorderPen;
                } 
                else 
                {
                    if (!border.IsFrozen && border.CanFreeze) 
                    {
                        border = border.Clone();
                        border.Freeze();
                    } 

                    pen = new Pen(border, 1); 
                    if (pen.CanFreeze) 
                    {
                        pen.Freeze(); 
                    }
                }
            }
 
            return pen;
        } 
 

        #endregion 

        #region Private Properties

        // 
        //  This property
        //  1. Finds the correct initial size for the _effectiveValues store on the current DependencyObject 
        //  2. This is a performance optimization 
        //
        internal override int EffectiveValuesInitialSize 
        {
            get { return 9; }
        }
 
        private bool Animates
        { 
            get 
            {
                return SystemParameters.ClientAreaAnimation && 
                       RenderCapability.Tier > 0 &&
                       IsEnabled;

            } 
        }
 
        private static Geometry CheckMarkGeometry 
        {
            get 
            {
                if (_checkMarkGeometry == null)
                {
                    lock (_resourceAccess) 
                    {
                        if (_checkMarkGeometry == null) 
                        { 
                            PathFigure figure = new PathFigure();
                            figure.StartPoint = new Point(9.0, 1.833); 
                            figure.Segments.Add(new LineSegment(new Point(10.667, 3.167), true));
                            figure.Segments.Add(new LineSegment(new Point(7, 10.667), true));
                            figure.Segments.Add(new LineSegment(new Point(5.333, 10.667), true));
                            figure.Segments.Add(new LineSegment(new Point(3.333, 8.167), true)); 
                            figure.Segments.Add(new LineSegment(new Point(3.333, 6.833), true));
                            figure.Segments.Add(new LineSegment(new Point(4.833, 6.5), true)); 
                            figure.Segments.Add(new LineSegment(new Point(6, 8), true)); 
                            figure.IsClosed = true;
                            figure.Freeze(); 

                            PathGeometry path = new PathGeometry();
                            path.Figures.Add(figure);
                            path.Freeze(); 

                            _checkMarkGeometry = path; 
                        } 
                    }
                } 

                return _checkMarkGeometry;
            }
        } 

        private static Pen CommonCheckMarkStroke 
        { 
            get
            { 
                if (_commonCheckMarkStroke == null)
                {
                    lock (_resourceAccess)
                    { 
                        if (_commonCheckMarkStroke == null)
                        { 
                            Pen temp = new Pen(); 
                            temp.Thickness = 1.5;
                            temp.Brush = new SolidColorBrush(Colors.White); 
                            temp.Freeze();

                            // Static field must not be set until the local has been frozen
                            _commonCheckMarkStroke = temp; 
                        }
                    } 
                } 
                return _commonCheckMarkStroke;
            } 
        }

        private static Pen CommonCheckMarkPressedStroke
        { 
            get
            { 
                if (_commonCheckMarkPressedStroke == null) 
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonCheckMarkPressedStroke == null)
                        {
                            Pen temp = new Pen(); 
                            temp.Thickness = 1.5;
                            temp.Brush = new SolidColorBrush(Colors.White); 
                            temp.Brush.Opacity = 0.7; 
                            temp.Freeze();
                            _commonCheckMarkPressedStroke = temp; 
                        }
                    }
                }
                return _commonCheckMarkPressedStroke; 
            }
        } 
 
        private static Pen CommonRadioButtonDisabledGlyphStroke
        { 
            get
            {
                if (_commonRadioButtonDisabledGlyphStroke == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonRadioButtonDisabledGlyphStroke == null) 
                        {
                            Pen temp = new Pen(); 
                            temp.Thickness = 1;
                            temp.Brush = new SolidColorBrush(Color.FromRgb(0xA2, 0xAE, 0xB9));
                            temp.Freeze();
                            _commonRadioButtonDisabledGlyphStroke = temp; 
                        }
                    } 
                } 
                return _commonRadioButtonDisabledGlyphStroke;
            } 
        }


        private static Pen CommonRadioButtonGlyphStroke 
        {
            get 
            { 
                if (_commonRadioButtonGlyphStroke == null)
                { 
                    lock (_resourceAccess)
                    {
                        if (_commonRadioButtonGlyphStroke == null)
                        { 
                            Pen temp = new Pen();
                            temp.Thickness = 1; 
                            temp.Brush = new SolidColorBrush(Color.FromRgb(0x19, 0x3B, 0x55)); 
                            temp.Freeze();
                            _commonRadioButtonGlyphStroke = temp; 
                        }
                    }
                }
                return _commonRadioButtonGlyphStroke; 
            }
        } 
 
        private static Pen CommonIndeterminateHighlight
        { 
            get
            {
                if (_commonIndeterminateHighlight == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonIndeterminateHighlight == null) 
                        {
                            Pen temp = new Pen(); 
                            temp.Thickness = 1;
                            LinearGradientBrush brush = new LinearGradientBrush();
                            brush.StartPoint = new Point(0, 0);
                            brush.EndPoint = new Point(1, 1); 

                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0x80, 0xFF, 0xFF, 0xFF), 0)); 
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0x00, 0xFF, 0xFF, 0xFF), 0.5)); 
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0x00, 0x33, 0x33, 0xA0), 0.5));
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0x00, 0x33, 0x33, 0xA0), 1)); 

                            temp.Brush = brush;

                            temp.Freeze(); 

                            _commonIndeterminateHighlight = temp; 
                        } 
                    }
                } 
                return _commonIndeterminateHighlight;
            }
        }
 
        private static Pen CommonIndeterminateHoverHighlight
        { 
            get 
            {
                if (_commonIndeterminateHoverHighlight == null) 
                {
                    lock (_resourceAccess)
                    {
                        if (_commonIndeterminateHoverHighlight == null) 
                        {
                            Pen temp = new Pen(); 
                            temp.Thickness = 1; 
                            LinearGradientBrush brush = new LinearGradientBrush();
                            brush.StartPoint = new Point(0, 0); 
                            brush.EndPoint = new Point(1, 1);

                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0x80, 0xFF, 0xFF, 0xFF), 0));
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0x00, 0xFF, 0xFF, 0xFF), 0.5)); 
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0x00, 0x33, 0x33, 0xA0), 0.5));
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0x80, 0x33, 0x33, 0xA0), 1)); 
 
                            temp.Brush = brush;
 
                            temp.Freeze();
                            _commonIndeterminateHoverHighlight = temp;
                        }
                    } 
                }
                return _commonIndeterminateHoverHighlight; 
            } 
        }
 
        private static Pen CommonIndeterminatePressedHighlight
        {
            get
            { 
                if (_commonIndeterminatePressedHighlight == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonIndeterminatePressedHighlight == null) 
                        {
                            Pen temp = new Pen();
                            temp.Thickness = 1;
                            LinearGradientBrush brush = new LinearGradientBrush(); 
                            brush.StartPoint = new Point(0, 0);
                            brush.EndPoint = new Point(1, 1); 
 
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0x00, 0xFF, 0xFF, 0xFF), 0.5));
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0x20, 0xFF, 0xFF, 0xFF), 1)); 

                            temp.Brush = brush;

                            temp.Freeze(); 
                            _commonIndeterminatePressedHighlight = temp;
                        } 
                    } 
                }
                return _commonIndeterminatePressedHighlight; 
            }
        }

        private Pen HighlightStroke 
        {
            get 
            { 
                if (_localResources != null)
                { 
                    if (_localResources.HighlightStroke == null)
                    {
                        _localResources.HighlightStroke = CommonIndeterminateHighlight.Clone();
                        _localResources.HighlightStroke.Brush.Opacity = 0; 
                    }
                    return _localResources.HighlightStroke; 
                } 

                if (!IsRound && IsChecked == null) 
                {
                    if (RenderPressed)
                    {
                        return CommonIndeterminatePressedHighlight; 
                    }
                    else if (RenderMouseOver) 
                    { 
                        return CommonIndeterminateHoverHighlight;
                    } 
                    else
                    {
                        return CommonIndeterminateHighlight;
                    } 
                }
 
                return null; 
            }
        } 

        private static SolidColorBrush CommonCheckMarkDisabledFill
        {
            get 
            {
                if (_commonCheckMarkDisabledFill == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonCheckMarkDisabledFill == null)
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromRgb(0xAE, 0xB7, 0xCF));
                            temp.Freeze(); 
                            _commonCheckMarkDisabledFill = temp;
                        } 
                    } 
                }
                return _commonCheckMarkDisabledFill; 
            }
        }

        private static SolidColorBrush CommonCheckMarkFill 
        {
            get 
            { 
                if (_commonCheckMarkFill == null)
                { 
                    lock (_resourceAccess)
                    {
                        if (_commonCheckMarkFill == null)
                        { 
                            SolidColorBrush temp = new SolidColorBrush(Color.FromRgb(0x31, 0x34, 0x7C));
                            temp.Freeze(); 
                            _commonCheckMarkFill = temp; 
                        }
                    } 
                }
                return _commonCheckMarkFill;
            }
        } 

 
 
        private static SolidColorBrush CommonCheckMarkPressedFill
        { 
            get
            {
                if (_commonCheckMarkPressedFill == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonCheckMarkPressedFill == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromRgb(0x31, 0x34, 0x7C)); 
                            temp.Opacity = 0.7;
                            temp.Freeze();
                            _commonCheckMarkPressedFill = temp;
                        } 
                    }
                } 
                return _commonCheckMarkPressedFill; 
            }
        } 

        private static RadialGradientBrush CommonRadioButtonGlyphDisabledFill
        {
            get 
            {
                if (_commonRadioButtonGlyphDisabledFill == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonRadioButtonGlyphDisabledFill == null)
                        {
                            RadialGradientBrush temp = new RadialGradientBrush();
 
                            temp.Center = new Point(0.25, 0.25);
                            temp.GradientOrigin = new Point(0.25, 0.25); 
                            temp.RadiusX = 0.75; 
                            temp.RadiusY = 0.75;
                            temp.Opacity = 0.7; 

                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0xC9, 0xD5, 0xDE), 0));
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0xC0, 0xE3, 0xE8), 0.35));
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0xB0, 0xD4, 0xE9), 1)); 

                            temp.Freeze(); 
                            _commonRadioButtonGlyphDisabledFill = temp; 
                        }
                    } 
                }
                return _commonRadioButtonGlyphDisabledFill;
            }
        } 

        private static RadialGradientBrush CommonRadioButtonGlyphFill 
        { 
            get
            { 
                if (_commonRadioButtonGlyphFill == null)
                {
                    lock (_resourceAccess)
                    { 
                        if (_commonRadioButtonGlyphFill == null)
                        { 
                            RadialGradientBrush temp = new RadialGradientBrush(); 

                            temp.Center = new Point(0.25, 0.25); 
                            temp.GradientOrigin = new Point(0.25, 0.25);
                            temp.RadiusX = 0.75;
                            temp.RadiusY = 0.75;
 
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0xE5, 0xE5, 0xE5), 0.1));
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0x5D, 0xCE, 0xDD), 0.35)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0x0B, 0x82, 0xC7), 1)); 

                            temp.Freeze(); 
                            _commonRadioButtonGlyphFill = temp;
                        }
                    }
                } 
                return _commonRadioButtonGlyphFill;
            } 
        } 

        private static RadialGradientBrush CommonRadioButtonGlyphHoverFill 
        {
            get
            {
                if (_commonRadioButtonGlyphHoverFill == null) 
                {
                    lock (_resourceAccess) 
                    { 
                        if (_commonRadioButtonGlyphHoverFill == null)
                        { 
                            RadialGradientBrush temp = new RadialGradientBrush();

                            temp.Center = new Point(0.25, 0.25);
                            temp.GradientOrigin = new Point(0.25, 0.25); 
                            temp.RadiusX = 0.75;
                            temp.RadiusY = 0.75; 
 
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0xFF, 0xFF, 0xFF), 0.1));
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0x74, 0xFF, 0xFF), 0.35)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0x0D, 0xA0, 0xF3), 1));

                            temp.Freeze();
                            _commonRadioButtonGlyphHoverFill = temp; 
                        }
                    } 
                } 
                return _commonRadioButtonGlyphHoverFill;
            } 
        }


 
        private static RadialGradientBrush CommonRadioButtonGlyphPressedFill
        { 
            get 
            {
                if (_commonRadioButtonGlyphPressedFill == null) 
                {
                    lock (_resourceAccess)
                    {
                        if (_commonRadioButtonGlyphPressedFill == null) 
                        {
                            RadialGradientBrush temp = new RadialGradientBrush(); 
 
                            temp.Center = new Point(0.25, 0.25);
                            temp.GradientOrigin = new Point(0.25, 0.25); 
                            temp.RadiusX = 0.75;
                            temp.RadiusY = 0.75;

                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0x95, 0xD9, 0xFC), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0x3A, 0x84, 0xAA), 0.35));
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0x07, 0x54, 0x83), 1)); 
 
                            temp.Freeze();
                            _commonRadioButtonGlyphPressedFill = temp; 
                        }
                    }
                }
                return _commonRadioButtonGlyphPressedFill; 
            }
        } 
 
        private static SolidColorBrush CommonHoverBackgroundOverlay
        { 
            get
            {
                if (_commonHoverBackgroundOverlay == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonHoverBackgroundOverlay == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromRgb(0xDE, 0xF9, 0xFA)); 
                            temp.Freeze();
                            _commonHoverBackgroundOverlay = temp;
                        }
                    } 
                }
                return _commonHoverBackgroundOverlay; 
            } 
        }
 
        private static SolidColorBrush CommonPressedBackgroundOverlay
        {
            get
            { 
                if (_commonPressedBackgroundOverlay == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonPressedBackgroundOverlay == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromRgb(0xC2, 0xE4, 0xF6));
                            temp.Freeze();
                            _commonPressedBackgroundOverlay = temp; 
                        }
                    } 
                } 
                return _commonPressedBackgroundOverlay;
            } 
        }

        private static SolidColorBrush CommonDisabledBackgroundOverlay
        { 
            get
            { 
                if (_commonDisabledBackgroundOverlay == null) 
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonDisabledBackgroundOverlay == null)
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromRgb(0xF4, 0xF4, 0xF4)); 
                            temp.Freeze();
                            _commonDisabledBackgroundOverlay = temp; 
                        } 
                    }
                } 
                return _commonDisabledBackgroundOverlay;
            }
        }
 
       private static Pen CommonHoverBorderOverlay
        { 
            get 
            {
                if (_commonHoverBorderOverlay == null) 
                {
                    lock (_resourceAccess)
                    {
                        if (_commonHoverBorderOverlay == null) 
                        {
                            Pen temp = new Pen(); 
                            temp.Thickness = 1; 
                            temp.Brush = new SolidColorBrush(Color.FromRgb(0x3C, 0x7F, 0xB1));
                            temp.Freeze(); 
                            _commonHoverBorderOverlay = temp;
                        }
                    }
                } 
                return _commonHoverBorderOverlay;
            } 
        } 

        private static Pen CommonPressedBorderOverlay 
        {
            get
            {
                if (_commonPressedBorderOverlay == null) 
                {
                    lock (_resourceAccess) 
                    { 
                        if (_commonPressedBorderOverlay == null)
                        { 
                            Pen temp = new Pen();
                            temp.Thickness = 1;
                            temp.Brush = new SolidColorBrush(Color.FromRgb(0x2C, 0x62, 0x8B));
                            temp.Freeze(); 
                            _commonPressedBorderOverlay = temp;
                        } 
                    } 
                }
                return _commonPressedBorderOverlay; 
            }
        }

        private static Pen CommonDisabledBorderOverlay 
        {
            get 
            { 
                if (_commonDisabledBorderOverlay == null)
                { 
                    lock (_resourceAccess)
                    {
                        if (_commonDisabledBorderOverlay == null)
                        { 
                            Pen temp = new Pen();
                            temp.Thickness = 1; 
                            temp.Brush = new SolidColorBrush(Color.FromRgb(0xAD, 0xB2, 0xB5)); 
                            temp.Freeze();
                            _commonDisabledBorderOverlay = temp; 
                        }
                    }
                }
                return _commonDisabledBorderOverlay; 
            }
        } 
 
        private static Pen CommonCheckBoxDisabledInnerBorderPen
        { 
            get
            {
                if (_commonCheckBoxDisabledInnerBorderPen == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonCheckBoxDisabledInnerBorderPen == null) 
                        {
                            Pen temp = new Pen(); 

                            temp.Thickness = 1;

                            LinearGradientBrush brush = new LinearGradientBrush(); 
                            brush.StartPoint = new Point(0,0);
                            brush.EndPoint = new Point(1,1); 
 
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0xE1, 0xE3, 0xE5), 0.25));
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0xE8, 0xE9, 0xEA), 0.5)); 
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0xF3, 0xF3, 0xF3), 1));

                            temp.Brush = brush;
                            temp.Freeze(); 
                            _commonCheckBoxDisabledInnerBorderPen = temp;
                        } 
                    } 
                }
                return _commonCheckBoxDisabledInnerBorderPen; 
            }
        }

        private static Pen CommonCheckBoxInnerBorderPen 
        {
            get 
            { 
                if (_commonCheckBoxInnerBorderPen == null)
                { 
                    lock (_resourceAccess)
                    {
                        if (_commonCheckBoxInnerBorderPen == null)
                        { 
                            Pen temp = new Pen();
 
                            temp.Thickness = 1; 

                            LinearGradientBrush brush = new LinearGradientBrush(); 
                            brush.StartPoint = new Point(0,0);
                            brush.EndPoint = new Point(1,1);

                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0xAE, 0xB3, 0xB9), 0.25)); 
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0xC2, 0xC4, 0xC6), 0.5));
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0xEA, 0xEB, 0xEB), 1)); 
 
                            temp.Brush = brush;
                            temp.Freeze(); 
                            _commonCheckBoxInnerBorderPen = temp;
                        }
                    }
                } 
                return _commonCheckBoxInnerBorderPen;
            } 
        } 

        private static Pen CommonCheckBoxHoverInnerBorderPen 
        {
            get
            {
                if (_commonCheckBoxHoverInnerBorderPen == null) 
                {
                    lock (_resourceAccess) 
                    { 
                        if (_commonCheckBoxHoverInnerBorderPen == null)
                        { 
                            Pen temp = new Pen();

                            temp.Thickness = 1;
 
                            LinearGradientBrush brush = new LinearGradientBrush();
                            brush.StartPoint = new Point(0, 0); 
                            brush.EndPoint = new Point(1, 1); 

                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0x79, 0xC6, 0xF9), 0.3)); 
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0x79, 0xC6, 0xF9), 0.5));
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0xD2, 0xED, 0xFD), 1));

                            temp.Brush = brush; 
                            temp.Freeze();
                            _commonCheckBoxHoverInnerBorderPen = temp; 
                        } 
                    }
                } 
                return _commonCheckBoxHoverInnerBorderPen;
            }
        }
 
        private static Pen CommonCheckBoxPressedInnerBorderPen
        { 
            get 
            {
                if (_commonCheckBoxPressedInnerBorderPen == null) 
                {
                    lock (_resourceAccess)
                    {
                        if (_commonCheckBoxPressedInnerBorderPen == null) 
                        {
                            Pen temp = new Pen(); 
 
                            temp.Thickness = 1;
 
                            LinearGradientBrush brush = new LinearGradientBrush();
                            brush.StartPoint = new Point(0, 0);
                            brush.EndPoint = new Point(1, 1);
 
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0x54, 0xA6, 0xD5), 0.3));
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0x5E, 0xB5, 0xE4), 0.5)); 
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0xC4, 0xE5, 0xF6), 1)); 

                            temp.Brush = brush; 
                            temp.Freeze();
                            _commonCheckBoxPressedInnerBorderPen = temp;
                        }
                    } 
                }
                return _commonCheckBoxPressedInnerBorderPen; 
            } 
        }
 
        private static Pen CommonIndeterminateDisabledInnerBorderPen
        {
            get
            { 
                if (_commonIndeterminateDisabledInnerBorderPen == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonIndeterminateDisabledInnerBorderPen == null) 
                        {
                            Pen temp = new Pen();

                            temp.Thickness = 1; 

                            LinearGradientBrush brush = new LinearGradientBrush(); 
                            brush.StartPoint = new Point(0, 0); 
                            brush.EndPoint = new Point(1, 1);
 
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0xBF, 0xD0, 0xDD), 0));
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0xBD, 0xCB, 0xD7), 0.5));
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0xBA, 0xC4, 0xCC), 1));
 
                            temp.Brush = brush;
                            temp.Freeze(); 
                            _commonIndeterminateDisabledInnerBorderPen = temp; 
                        }
                    } 
                }
                return _commonIndeterminateDisabledInnerBorderPen;
            }
        } 

        private static Pen CommonIndeterminateInnerBorderPen 
        { 
            get
            { 
                if (_commonIndeterminateInnerBorderPen == null)
                {
                    lock (_resourceAccess)
                    { 
                        if (_commonIndeterminateInnerBorderPen == null)
                        { 
                            Pen temp = new Pen(); 

                            temp.Thickness = 1; 

                            LinearGradientBrush brush = new LinearGradientBrush();
                            brush.StartPoint = new Point(0, 0);
                            brush.EndPoint = new Point(1, 1); 

                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0x2A, 0x62, 0x8D), 0)); 
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0x24, 0x54, 0x79), 0.5)); 
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0x19, 0x3B, 0x55), 1));
 
                            temp.Brush = brush;
                            temp.Freeze();
                            _commonIndeterminateInnerBorderPen = temp;
                        } 
                    }
                } 
                return _commonIndeterminateInnerBorderPen; 
            }
        } 

        private static Pen CommonIndeterminateHoverInnerBorderPen
        {
            get 
            {
                if (_commonIndeterminateHoverInnerBorderPen == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonIndeterminateHoverInnerBorderPen == null)
                        {
                            Pen temp = new Pen();
 
                            temp.Thickness = 1;
 
                            LinearGradientBrush brush = new LinearGradientBrush(); 
                            brush.StartPoint = new Point(0, 0);
                            brush.EndPoint = new Point(1, 1); 

                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0x29, 0x62, 0x8D), 0));
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0x24, 0x54, 0x79), 0.5));
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0x19, 0x3B, 0x55), 1)); 

                            temp.Brush = brush; 
                            temp.Freeze(); 
                            _commonIndeterminateHoverInnerBorderPen = temp;
                        } 
                    }
                }
                return _commonIndeterminateHoverInnerBorderPen;
            } 
        }
 
        private static Pen CommonIndeterminatePressedInnerBorderPen 
        {
            get 
            {
                if (_commonIndeterminatePressedInnerBorderPen == null)
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonIndeterminatePressedInnerBorderPen == null) 
                        { 
                            Pen temp = new Pen();
 
                            temp.Thickness = 1;

                            LinearGradientBrush brush = new LinearGradientBrush();
                            brush.StartPoint = new Point(0, 0); 
                            brush.EndPoint = new Point(1, 1);
 
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0x19, 0x3B, 0x55), 0)); 
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0x24, 0x54, 0x79), 0.5));
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0x29, 0x62, 0x8D), 1)); 

                            temp.Brush = brush;
                            temp.Freeze();
                            _commonIndeterminatePressedInnerBorderPen = temp; 
                        }
                    } 
                } 
                return _commonIndeterminatePressedInnerBorderPen;
            } 
        }


        private static Pen CommonRadioButtonInnerBorderPen 
        {
            get 
            { 
                if (_commonRadioButtonInnerBorderPen == null)
                { 
                    lock (_resourceAccess)
                    {
                        if (_commonRadioButtonInnerBorderPen == null)
                        { 
                            Pen temp = new Pen();
 
                            temp.Thickness = 1; 

                            LinearGradientBrush brush = new LinearGradientBrush(); 
                            brush.StartPoint = new Point(0, 0);
                            brush.EndPoint = new Point(1, 1);

                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0xB3, 0xB8, 0xBD), 0)); 
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0xEB, 0xEB, 0xEB), 1));
 
                            temp.Brush = brush; 
                            temp.Freeze();
                            _commonRadioButtonInnerBorderPen = temp; 
                        }
                    }
                }
                return _commonRadioButtonInnerBorderPen; 
            }
        } 
 
        private static Pen CommonRadioButtonHoverInnerBorderPen
        { 
            get
            {
                if (_commonRadioButtonHoverInnerBorderPen == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonRadioButtonHoverInnerBorderPen == null) 
                        {
                            Pen temp = new Pen(); 

                            temp.Thickness = 1;

                            LinearGradientBrush brush = new LinearGradientBrush(); 
                            brush.StartPoint = new Point(0, 0);
                            brush.EndPoint = new Point(1, 1); 
 
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0x80, 0xCA, 0xF9), 0));
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0xD2, 0xEE, 0xFD), 1)); 

                            temp.Brush = brush;
                            temp.Freeze();
                            _commonRadioButtonHoverInnerBorderPen = temp; 
                        }
                    } 
                } 
                return _commonRadioButtonHoverInnerBorderPen;
            } 
        }

        private static Pen CommonRadioButtonPressedInnerBorderPen
        { 
            get
            { 
                if (_commonRadioButtonPressedInnerBorderPen == null) 
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonRadioButtonPressedInnerBorderPen == null)
                        {
                            Pen temp = new Pen(); 

                            temp.Thickness = 1; 
 
                            LinearGradientBrush brush = new LinearGradientBrush();
                            brush.StartPoint = new Point(0, 0); 
                            brush.EndPoint = new Point(1, 1);

                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0x5C, 0xAA, 0xD7), 0));
                            brush.GradientStops.Add(new GradientStop(Color.FromRgb(0xC3, 0xE4, 0xF6), 1)); 

                            temp.Brush = brush; 
                            temp.Freeze(); 
                            _commonRadioButtonPressedInnerBorderPen = temp;
                        } 
                    }
                }
                return _commonRadioButtonPressedInnerBorderPen;
            } 
        }
 
        private Brush BackgroundOverlay 
        {
            get 
            {
                if (!IsEnabled)
                {
                    return CommonDisabledBackgroundOverlay; 
                }
 
                if (!Animates) 
                {
                    if (RenderPressed) 
                    {
                        return CommonPressedBackgroundOverlay;
                    }
                    else if (RenderMouseOver) 
                    {
                        return CommonHoverBackgroundOverlay; 
                    } 
                    else
                    { 
                        return null;
                    }
                }
 
                if (_localResources != null)
                { 
                    if (_localResources.BackgroundOverlay == null) 
                    {
                        _localResources.BackgroundOverlay = CommonHoverBackgroundOverlay.Clone(); 
                        _localResources.BackgroundOverlay.Opacity = 0;
                    }
                    return _localResources.BackgroundOverlay;
                } 
                else
                { 
                    return null; 
                }
            } 
        }


        private static LinearGradientBrush CommonCheckBoxInnerFill 
        {
            get 
            { 
                if (_commonCheckBoxInnerFill == null)
                { 
                    lock (_resourceAccess)
                    {
                        if (_commonCheckBoxInnerFill == null)
                        { 
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0); 
                            temp.EndPoint = new Point(1, 1); 

                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0xCB, 0xCF, 0xD5), 0.2)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0xF7, 0xF7, 0xF7), 0.8));

                            temp.Freeze();
                            _commonCheckBoxInnerFill = temp; 
                        }
                    } 
                } 
                return _commonCheckBoxInnerFill;
            } 
        }

        private static LinearGradientBrush CommonCheckBoxHoverInnerFill
        { 
            get
            { 
                if (_commonCheckBoxHoverInnerFill == null) 
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonCheckBoxHoverInnerFill == null)
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(1, 1); 
 
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0xB1, 0xDF, 0xFD), 0.2));
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0xE9, 0xF7, 0xFE), 0.8)); 

                            temp.Freeze();
                            _commonCheckBoxHoverInnerFill = temp;
                        } 
                    }
                } 
                return _commonCheckBoxHoverInnerFill; 
            }
        } 

        private static LinearGradientBrush CommonCheckBoxPressedInnerFill
        {
            get 
            {
                if (_commonCheckBoxPressedInnerFill == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonCheckBoxPressedInnerFill == null)
                        {
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0); 
                            temp.EndPoint = new Point(1, 1);
 
 
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0x7F, 0xBA, 0xDC), 0.2));
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0xD6, 0xED, 0xF9), 0.8)); 

                            temp.Freeze();
                            _commonCheckBoxPressedInnerFill = temp;
                        } 
                    }
                } 
                return _commonCheckBoxPressedInnerFill; 
            }
        } 



        private static LinearGradientBrush CommonIndeterminateDisabledFill 
        {
            get 
            { 
                if (_commonIndeterminateDisabledFill == null)
                { 
                    lock (_resourceAccess)
                    {
                        if (_commonIndeterminateDisabledFill == null)
                        { 
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0); 
                            temp.EndPoint = new Point(1, 1); 

                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0xC0, 0xE5, 0xF3), 0.2)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0xBD, 0xCD, 0xDC), 0.8));

                            temp.Freeze();
                            _commonIndeterminateDisabledFill = temp; 
                        }
                    } 
                } 
                return _commonIndeterminateDisabledFill;
            } 
        }


        private static LinearGradientBrush CommonIndeterminateFill 
        {
            get 
            { 
                if (_commonIndeterminateFill == null)
                { 
                    lock (_resourceAccess)
                    {
                        if (_commonIndeterminateFill == null)
                        { 
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0); 
                            temp.EndPoint = new Point(1, 1); 

                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0x2F, 0xA8, 0xD5), 0.2)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0x25, 0x59, 0x8C), 0.8));

                            temp.Freeze();
                            _commonIndeterminateFill = temp; 
                        }
                    } 
                } 
                return _commonIndeterminateFill;
            } 
        }

        private static LinearGradientBrush CommonIndeterminateHoverFill
        { 
            get
            { 
                if (_commonIndeterminateHoverFill == null) 
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonIndeterminateHoverFill == null)
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(1, 1); 
 
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0x33, 0xD7, 0xED), 0.2));
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0x20, 0x94, 0xCE), 0.8)); 

                            temp.Freeze();
                            _commonIndeterminateHoverFill = temp;
                        } 
                    }
                } 
                return _commonIndeterminateHoverFill; 
            }
        } 

        private static LinearGradientBrush CommonIndeterminatePressedFill
        {
            get 
            {
                if (_commonIndeterminatePressedFill == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonIndeterminatePressedFill == null)
                        {
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0); 
                            temp.EndPoint = new Point(1, 1);
 
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0x17, 0x44, 0x7A), 0.2)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromRgb(0x21, 0x8B, 0xC3), 0.8));
 
                            temp.Freeze();
                            _commonIndeterminatePressedFill = temp;
                        }
                    } 
                }
                return _commonIndeterminatePressedFill; 
            } 
        }
 
        private GradientBrush InnerFill
        {
            get
            { 
                if (!IsEnabled)
                { 
                    if (IsChecked == null) 
                    {
                        return CommonIndeterminateDisabledFill; 
                    }
                    else
                    {
                        return null; 
                    }
                } 
 
                if (_localResources != null)
                { 
                    if (_localResources.InnerFill == null)
                    {
                        _localResources.InnerFill = CommonCheckBoxInnerFill.Clone();
                    } 
                    return _localResources.InnerFill;
                } 
 
                if (IsChecked == null)
                { 
                    if (RenderPressed)
                    {
                        return CommonIndeterminatePressedFill;
                    } 
                    else if (RenderMouseOver)
                    { 
                        return CommonIndeterminateHoverFill; 
                    }
                    else 
                    {
                        return CommonIndeterminateFill;
                    }
                } 

                if (RenderPressed) 
                { 
                    return CommonCheckBoxPressedInnerFill;
                } 
                else if (RenderMouseOver)
                {
                    return CommonCheckBoxHoverInnerFill;
 
                }
                else 
                { 
                    return CommonCheckBoxInnerFill;
                } 
            }
        }

        private Pen GlyphStroke 
        {
            get 
            { 
                if (!IsEnabled)
                { 
                    if (IsRound && IsChecked == true)
                    {
                        return CommonRadioButtonDisabledGlyphStroke;
                    } 
                    else
                    { 
                        return null; 
                    }
                } 

                if (_localResources != null)
                {
                    if (_localResources.GlyphStroke == null) 
                    {
                        if (!IsRound) 
                        { 
                            _localResources.GlyphStroke = CommonCheckMarkStroke.Clone();
                            _localResources.GlyphStroke.Brush.Opacity = 0; 
                        }
                        else
                        {
                            _localResources.GlyphStroke = CommonRadioButtonGlyphStroke.Clone(); 
                            _localResources.GlyphStroke.Brush.Opacity = 0;
                        } 
                    } 
                    return _localResources.GlyphStroke;
                } 

                if (!IsRound)
                {
                    if (IsChecked == true) 
                    {
                        if (RenderPressed) 
                        { 
                            return CommonCheckMarkPressedStroke;
                        } 
                        else
                        {
                            return CommonCheckMarkStroke;
                        } 
                    }
                    else if (IsChecked == false && RenderPressed) 
                    { 
                        return CommonCheckMarkPressedStroke;
                    } 
                    else
                    {
                        return null;
                    } 
                }
                else 
                { 
                    if (IsChecked == true || RenderPressed)
                    { 
                        return CommonRadioButtonGlyphStroke;
                    }
                    else
                    { 
                        return null;
                    } 
                } 
            }
        } 



        private Brush GlyphFill 
        {
            get 
            { 
                if (!IsEnabled)
                { 
                    if (IsChecked == true)
                    {
                        if (!IsRound)
                        { 
                            return CommonCheckMarkDisabledFill;
                        } 
                        else 
                        {
                            return CommonRadioButtonGlyphDisabledFill; 
                        }
                    }
                    else
                    { 
                        return null;
                    } 
                } 

                if (_localResources != null) 
                {
                    if (_localResources.GlyphFill == null)
                    {
                        if (!IsRound) 
                        {
                            _localResources.GlyphFill = CommonCheckMarkFill.Clone(); 
                            _localResources.GlyphFill.Opacity = 0; 
                        }
                        else 
                        {
                            _localResources.GlyphFill = CommonRadioButtonGlyphFill.Clone();
                            _localResources.GlyphFill.Opacity = 0;
                        } 
                    }
                    return _localResources.GlyphFill; 
                } 

                if (!IsRound) 
                {
                    if (IsChecked == true)
                    {
                        if (RenderPressed) 
                        {
                            return CommonCheckMarkPressedFill; 
                        } 
                        else
                        { 
                            return CommonCheckMarkFill;
                        }
                    }
                    else if (IsChecked == false && RenderPressed) 
                    {
                        return CommonCheckMarkPressedFill; 
                    } 
                    else
                    { 
                        return null;
                    }
                }
                else 
                {
                    if (IsChecked == true) 
                    { 
                        if (RenderPressed)
                        { 
                            return CommonRadioButtonGlyphPressedFill;
                        }
                        else if (RenderMouseOver)
                        { 
                            return CommonRadioButtonGlyphHoverFill;
                        } 
                        else 
                        {
                            return CommonRadioButtonGlyphFill; 
                        }
                    }
                    else if (RenderPressed)
                    { 
                        return CommonRadioButtonGlyphPressedFill;
                    } 
                    else 
                    {
                        return null; 
                    }
                }
            }
        } 

 
        private Pen BorderOverlayPen 
        {
            get 
            {
                if (!IsEnabled)
                {
                    return CommonDisabledBorderOverlay; 
                }
 
                if (_localResources != null) 
                {
                    if (_localResources.BorderOverlayPen == null) 
                    {
                        _localResources.BorderOverlayPen = CommonHoverBorderOverlay.Clone();
                        _localResources.BorderOverlayPen.Brush.Opacity = 0;
                    } 
                    return _localResources.BorderOverlayPen;
                } 
                else 
                {
                    if (RenderPressed) 
                    {
                        return CommonPressedBorderOverlay;
                    }
                    else if (RenderMouseOver) 
                    {
                        return CommonHoverBorderOverlay; 
                    } 
                    else
                    { 
                        return null;
                    }
                }
            } 
        }
 
 
        private Pen InnerBorderPen
        { 
            get
            {
                if (!IsEnabled)
                { 
                    if (IsChecked == null)
                    { 
                        return CommonIndeterminateDisabledInnerBorderPen; 
                    }
                    else 
                    {
                        return CommonCheckBoxDisabledInnerBorderPen;
                    }
                } 

                if (_localResources != null) 
                { 
                    if (_localResources.InnerBorderPen == null)
                    { 
                        _localResources.InnerBorderPen = CommonCheckBoxInnerBorderPen.Clone();
                    }
                    return _localResources.InnerBorderPen;
                } 

                if (RenderPressed) 
                { 
                    if (!IsRound)
                    { 
                        if (IsChecked == null)
                        {
                            return CommonIndeterminatePressedInnerBorderPen;
                        } 
                        else
                        { 
                            return CommonCheckBoxPressedInnerBorderPen; 
                        }
                    } 
                    else
                    {
                        return CommonRadioButtonPressedInnerBorderPen;
                    } 
                }
                else if (RenderMouseOver) 
                { 
                    if (!IsRound)
                    { 
                        if (IsChecked == null)
                        {
                            return CommonIndeterminateHoverInnerBorderPen;
                        } 
                        else
                        { 
                            return CommonCheckBoxHoverInnerBorderPen; 
                        }
                    } 
                    else
                    {
                        return CommonRadioButtonHoverInnerBorderPen;
                    } 
                }
                else 
                { 
                    if (!IsRound)
                    { 
                        if (IsChecked == null)
                        {
                            return CommonIndeterminateInnerBorderPen;
                        } 
                        else
                        { 
                            return CommonCheckBoxInnerBorderPen; 
                        }
                    } 
                    else
                    {
                        return CommonRadioButtonInnerBorderPen;
                    } 
                }
            } 
        } 

 

        // Common LocalResources
        private static Geometry _checkMarkGeometry;
 
        private static Pen _commonCheckMarkStroke;
        private static Pen _commonCheckMarkPressedStroke; 
        private static SolidColorBrush _commonCheckMarkDisabledFill; 
        private static SolidColorBrush _commonCheckMarkFill;
        private static SolidColorBrush _commonCheckMarkPressedFill; 
        private static Pen _commonRadioButtonDisabledGlyphStroke;
        private static Pen _commonRadioButtonGlyphStroke;
        private static RadialGradientBrush _commonRadioButtonGlyphFill;
        private static RadialGradientBrush _commonRadioButtonGlyphHoverFill; 
        private static RadialGradientBrush _commonRadioButtonGlyphPressedFill;
        private static RadialGradientBrush _commonRadioButtonGlyphDisabledFill; 
 
        private static LinearGradientBrush _commonIndeterminateFill;
        private static LinearGradientBrush _commonIndeterminateHoverFill; 
        private static LinearGradientBrush _commonIndeterminatePressedFill;
        private static LinearGradientBrush _commonIndeterminateDisabledFill;

        private static Pen _commonIndeterminateInnerBorderPen; 
        private static Pen _commonIndeterminateHoverInnerBorderPen;
        private static Pen _commonIndeterminatePressedInnerBorderPen; 
        private static Pen _commonIndeterminateDisabledInnerBorderPen; 

        private static Pen _commonIndeterminateHighlight; 
        private static Pen _commonIndeterminateHoverHighlight;
        private static Pen _commonIndeterminatePressedHighlight;

        private static Pen _commonBorderPen; 
        private static Pen _commonCheckBoxInnerBorderPen;
        private static Pen _commonRadioButtonInnerBorderPen; 
        private static LinearGradientBrush _commonCheckBoxInnerFill; 

        private static Pen _commonDisabledBorderOverlay; 
        private static SolidColorBrush _commonDisabledBackgroundOverlay;
        private static Pen _commonCheckBoxDisabledInnerBorderPen;

        private static SolidColorBrush _commonHoverBackgroundOverlay; 
        private static Pen _commonHoverBorderOverlay;
        private static Pen _commonCheckBoxHoverInnerBorderPen; 
        private static Pen _commonRadioButtonHoverInnerBorderPen; 
        private static LinearGradientBrush _commonCheckBoxHoverInnerFill;
 
        private static SolidColorBrush _commonPressedBackgroundOverlay;
        private static Pen _commonPressedBorderOverlay;
        private static Pen _commonCheckBoxPressedInnerBorderPen;
        private static Pen _commonRadioButtonPressedInnerBorderPen; 
        private static LinearGradientBrush _commonCheckBoxPressedInnerFill;
 
        private static object _resourceAccess = new object(); 

        // Per instance resources 

        private LocalResources _localResources;

        private class LocalResources 
        {
            public Pen BorderOverlayPen; 
            public Pen InnerBorderPen; 
            public SolidColorBrush BackgroundOverlay;
            public GradientBrush InnerFill; 
            public Pen HighlightStroke;
            public Pen GlyphStroke;
            public Brush GlyphFill;
        } 

        #endregion 
    } 
}
 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK