ScrollChrome.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / Orcas / SP / wpf / src / Themes / Luna / Microsoft / Windows / Themes / ScrollChrome.cs / 1 / ScrollChrome.cs

                            //---------------------------------------------------------------------------- 
// File: ScrollChrome.cs
//
// Description:
// Implementation of chrome for scrollbar and combobox buttons and thumbs in Luna. 
//
// Copyright (C) 2004 by Microsoft Corporation.  All rights reserved. 
// 
//---------------------------------------------------------------------------
 
using System;
using System.Windows.Shapes;
using System.Windows.Controls;
using System.Diagnostics; 
using System.Threading;
 
using System.Windows; 
using System.Windows.Media;
using MS.Internal; 

namespace Microsoft.Windows.Themes
{
    ///  
    ///     The ScrollChrome element
    ///     This element is a theme-specific type that is used as an optimization 
    ///     for a common complex rendering used in Luna 
    /// 
    public sealed class ScrollChrome : FrameworkElement 
    {

        #region Constructors
 
        static ScrollChrome()
        { 
            IsEnabledProperty.OverrideMetadata(typeof(ScrollChrome), new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.AffectsRender)); 
        }
 
        /// 
        ///     Instantiates a new instance of a ScrollChrome with no parent element.
        /// 
        public ScrollChrome() 
        {
        } 
 
        #endregion Constructors
 
        #region Dynamic Properties

        /// 
        ///     Attached DependencyProperty to assign the orientation and type of the glyph 
        /// 
        public static readonly DependencyProperty ThemeColorProperty 
            = ButtonChrome.ThemeColorProperty.AddOwner(typeof(ScrollChrome), 
                                new FrameworkPropertyMetadata(
                                ThemeColor.NormalColor, 
                                FrameworkPropertyMetadataOptions.AffectsRender));

        /// 
        /// The color variation of the button. 
        /// 
        public ThemeColor ThemeColor 
        { 
            get { return (ThemeColor)GetValue(ThemeColorProperty); }
            set { SetValue(ThemeColorProperty, value); } 
        }

        /// 
        /// DependencyProperty for  property. 
        /// 
        public static readonly DependencyProperty HasOuterBorderProperty = 
                 DependencyProperty.Register("HasOuterBorder", 
                         typeof(bool),
                         typeof(ScrollChrome), 
                         new FrameworkPropertyMetadata(
                                true,
                                FrameworkPropertyMetadataOptions.AffectsRender));
 
        /// 
        /// When true the chrome renders with a white outer border. 
        ///  
        public bool HasOuterBorder
        { 
            get { return (bool)GetValue(HasOuterBorderProperty); }
            set { SetValue(HasOuterBorderProperty, value); }
        }
 

        ///  
        ///     Attached DependencyProperty to assign the orientation and type of the glyph 
        /// 
        public static readonly DependencyProperty ScrollGlyphProperty = 
                DependencyProperty.RegisterAttached(
                        "ScrollGlyph",
                        typeof(ScrollGlyph),
                        typeof(ScrollChrome), 
                        new FrameworkPropertyMetadata(
                                ScrollGlyph.None, 
                                FrameworkPropertyMetadataOptions.AffectsRender), 
                        new ValidateValueCallback(IsValidScrollGlyph));
 
        /// 
        ///     Gets the value of the ScrollGlyph property on the object.
        /// 
        /// The object to which the property is attached. 
        /// The value of the property.
        public static ScrollGlyph GetScrollGlyph(DependencyObject element) 
        { 
            if (element == null) { throw new ArgumentNullException("element"); }
 
            return (ScrollGlyph)element.GetValue(ScrollGlyphProperty);
        }

        ///  
        ///     Attachs the value to the object.
        ///  
        /// The object on which the value will be attached. 
        /// The value to attach.
        public static void SetScrollGlyph(DependencyObject element, ScrollGlyph value) 
        {
            if (element == null) { throw new ArgumentNullException("element"); }

            element.SetValue(ScrollGlyphProperty, value); 
        }
 
        private ScrollGlyph ScrollGlyph 
        {
            get { return (ScrollGlyph)GetValue(ScrollGlyphProperty); } 
        }

        private static bool IsValidScrollGlyph(object o)
        { 
            ScrollGlyph glyph = (ScrollGlyph)o;
            return glyph == ScrollGlyph.None || 
                glyph == ScrollGlyph.LeftArrow || 
                glyph == ScrollGlyph.RightArrow ||
                glyph == ScrollGlyph.UpArrow || 
                glyph == ScrollGlyph.DownArrow ||
                glyph == ScrollGlyph.VerticalGripper ||
                glyph == ScrollGlyph.HorizontalGripper;
        } 

        ///  
        ///     DependencyProperty for  property. 
        /// 
        public static readonly DependencyProperty PaddingProperty = Control.PaddingProperty.AddOwner(typeof(ScrollChrome)); 

        /// 
        ///     Insets the border of the element.
        ///  
        public Thickness Padding
        { 
            get { return (Thickness)GetValue(PaddingProperty); } 
            set { SetValue(PaddingProperty, value); }
        } 

        /// 
        /// DependencyProperty for  property.
        ///  
        public static readonly DependencyProperty RenderMouseOverProperty
            = ButtonChrome.RenderMouseOverProperty.AddOwner(typeof(ScrollChrome), 
                                new FrameworkPropertyMetadata( 
                                false,
                                FrameworkPropertyMetadataOptions.AffectsRender)); 

        /// 
        /// When true the chrome renders with a mouse over look.
        ///  
        public bool RenderMouseOver
        { 
            get { return (bool)GetValue(RenderMouseOverProperty); } 
            set { SetValue(RenderMouseOverProperty, value); }
        } 


        /// 
        /// DependencyProperty for  property. 
        /// 
        public static readonly DependencyProperty RenderPressedProperty 
            = ButtonChrome.RenderPressedProperty.AddOwner(typeof(ScrollChrome), 
                                new FrameworkPropertyMetadata(
                                false, 
                                FrameworkPropertyMetadataOptions.AffectsRender));

        /// 
        /// When true the chrome renders with a pressed look. 
        /// 
        public bool RenderPressed 
        { 
            get { return (bool)GetValue(RenderPressedProperty); }
            set { SetValue(RenderPressedProperty, value); } 
        }

        #endregion Dynamic Properties
 
        #region Protected Methods
 
        ///  
        ///     Updates DesiredSize of the ScrollChrome.  Called by parent UIElement.  This is the first pass of layout.
        ///  
        /// 
        ///     ScrollChrome basically constrains the value of its Width and Height properties.
        /// 
        /// Available size is an "upper limit" that the return value should not exceed. 
        /// The ScrollChrome's desired size.
        protected override Size MeasureOverride(Size availableSize) 
        { 
            _transform = null;
 
            return new Size(0, 0);
        }

        ///  
        ///     ScrollChrome does no work here and returns arrangeSize.
        ///  
        /// Size the ContentPresenter will assume. 
        protected override Size ArrangeOverride(Size finalSize)
        { 
            _transform = null;
            return finalSize;
        }
 
        /// 
        /// Render callback. 
        /// Note: Assumes all borders are 1 unit. 
        /// 
        protected override void OnRender(DrawingContext drawingContext) 
        {
            Rect bounds = new Rect(0, 0, ActualWidth, ActualHeight);
            ScrollGlyph glyph = ScrollGlyph;
            bool hasModifiers; 

            // Padding will be used to inset the border - used by ComboBox buttons 
            if (GetValueSource(PaddingProperty, null, out hasModifiers) != BaseValueSourceInternal.Default || hasModifiers) 
            {
                Thickness padding = Padding; 

                double totalPadding = padding.Left + padding.Right;
                if (totalPadding >= bounds.Width)
                { 
                    bounds.Width = 0.0;
                } 
                else 
                {
                    bounds.X += padding.Left; 
                    bounds.Width -= totalPadding;
                }

                totalPadding = padding.Top + padding.Bottom; 
                if (totalPadding >= bounds.Height)
                { 
                    bounds.Height = 0.0; 
                }
                else 
                {
                    bounds.Y += padding.Top;
                    bounds.Height -= totalPadding;
                } 
            }
 
            if ((bounds.Width >= 1.0) && (bounds.Height >= 1.0)) 
            {
                bounds.X += 0.5; 
                bounds.Y += 0.5;
                bounds.Width -= 1.0;
                bounds.Height -= 1.0;
            } 

            switch (glyph) 
            { 
                case ScrollGlyph.LeftArrow:
                case ScrollGlyph.RightArrow: 
                case ScrollGlyph.HorizontalGripper:
                    if (bounds.Height >= 1.0)
                    {
                        bounds.Y += 1.0; 
                        bounds.Height -= 1.0;
                    } 
                    break; 

                case ScrollGlyph.UpArrow: 
                case ScrollGlyph.DownArrow:
                case ScrollGlyph.VerticalGripper:
                    if (bounds.Width >= 1.0)
                    { 
                        bounds.X += 1.0;
                        bounds.Width -= 1.0; 
                    } 
                    break;
            } 

            DrawShadow(drawingContext, ref bounds);
            DrawBorders(drawingContext, ref bounds);
            DrawGlyph(drawingContext, glyph, ref bounds); 
        }
 
        #endregion 

        #region Private Methods 



        private void DrawShadow(DrawingContext dc, ref Rect bounds) 
        {
            if ((bounds.Width > 0.0) && (bounds.Height > 2.0)) 
            { 
                Pen pen = Shadow;
                if (pen != null) 
                {
                    dc.DrawRoundedRectangle(
                        null,
                        pen, 
                        new Rect(bounds.X, bounds.Y + 2.0, bounds.Width, bounds.Height - 2.0),
                        3.0, 3.0); 
 
                    bounds.Height -= 1.0;
                    bounds.Width = Math.Max(0.0, bounds.Width - 1.0); 
                }
            }
        }
 
        private void DrawBorders(DrawingContext dc, ref Rect bounds)
        { 
            if ((bounds.Width >= 2.0) && (bounds.Height >= 2.0)) 
            {
                Brush brush = Fill; 
                Pen pen = OuterBorder;
                if (pen != null)
                {
                    dc.DrawRoundedRectangle( 
                        brush,
                        pen, 
                        new Rect(bounds.X, bounds.Y, bounds.Width, bounds.Height), 
                        2.0, 2.0);
                    brush = null; // Done with the fill 
                    bounds.Inflate(-1.0, -1.0);
                }

                if ((bounds.Width >= 2.0) && (bounds.Height >= 2.0)) 
                {
                    pen = InnerBorder; 
                    if ((pen != null) || (brush != null)) 
                    {
                        dc.DrawRoundedRectangle( 
                            brush,
                            pen,
                            new Rect(bounds.X, bounds.Y, bounds.Width, bounds.Height),
                            1.5, 1.5); 
                        bounds.Inflate(-1.0, -1.0);
                    } 
                } 
            }
        } 

        private void DrawGlyph(DrawingContext dc, ScrollGlyph glyph, ref Rect bounds)
        {
 
            if ((bounds.Width > 0.0) && (bounds.Height > 0.0))
            { 
                Brush brush = Glyph; 

                if ((brush != null) && (glyph != ScrollGlyph.None)) 
                {
                    switch (glyph)
                    {
                        case ScrollGlyph.HorizontalGripper: 
                            DrawHorizontalGripper(dc, brush, bounds);
                            break; 
 
                        case ScrollGlyph.VerticalGripper:
                            DrawVerticalGripper(dc, brush, bounds); 
                            break;

                        case ScrollGlyph.LeftArrow:
                        case ScrollGlyph.RightArrow: 
                        case ScrollGlyph.UpArrow:
                        case ScrollGlyph.DownArrow: 
                            DrawArrow(dc, brush, bounds, glyph); 
                            break;
                    } 
                }
            }
        }
 
        private void DrawHorizontalGripper(DrawingContext dc, Brush brush, Rect bounds)
        { 
            if ((bounds.Width > 8.0) && (bounds.Height > 2.0)) 
            {
                Brush glyphShadow = GlyphShadow; 

                double height = Math.Min(6.0, bounds.Height);
                double x = bounds.X + ((bounds.Width * 0.5) - 4.0);
                double y = bounds.Y + ((bounds.Height - height) * 0.5); 

                height -= 1.0; 
                for (int i = 0; i < 8; i += 2) 
                {
                    dc.DrawRectangle(brush, null, new Rect(x + i, y, 1.0, height)); 
                    if (glyphShadow != null)
                    {
                        dc.DrawRectangle(glyphShadow, null, new Rect(x + i + 1, y + 1, 1.0, height));
                    } 
                }
            } 
        } 

        private void DrawVerticalGripper(DrawingContext dc, Brush brush, Rect bounds) 
        {
            if ((bounds.Width > 2.0) && (bounds.Height > 8.0))
            {
                Brush glyphShadow = GlyphShadow; 

                double width = Math.Min(6.0, bounds.Width); 
                double x = bounds.X + ((bounds.Width - width) * 0.5); 
                double y = bounds.Y + ((bounds.Height * 0.5) - 4.0);
 
                width -= 1.0;
                for (int i = 0; i < 8; i += 2)
                {
                    dc.DrawRectangle(brush, null, new Rect(x, y + i, width, 1.0)); 
                    if (glyphShadow != null)
                    { 
                        dc.DrawRectangle(glyphShadow, null, new Rect(x + 1, y + i + 1, width, 1.0)); 
                    }
                } 
            }
        }

        #region Arrow Geometry Generation 

        // Geometries for arrows don't change so use static versions to reduce working set 
        private static object _glyphAccess = new object(); 
        private static Geometry _leftArrowGeometry;
        private static Geometry _rightArrowGeometry; 
        private static Geometry _upArrowGeometry;
        private static Geometry _downArrowGeometry;

        private static Geometry LeftArrowGeometry 
        {
            get 
            { 
                if (_leftArrowGeometry == null)
                { 
                    lock (_glyphAccess)
                    {
                        if (_leftArrowGeometry == null)
                        { 
                            PathFigure figure = new PathFigure();
                            figure.StartPoint = new Point(4.5, 0.0); 
                            figure.Segments.Add(new LineSegment(new Point(0.0, 4.5), true)); 
                            figure.Segments.Add(new LineSegment(new Point(4.5, 9.0), true));
                            figure.Segments.Add(new LineSegment(new Point(6.0, 7.5), true)); 
                            figure.Segments.Add(new LineSegment(new Point(3.0, 4.5), true));
                            figure.Segments.Add(new LineSegment(new Point(6.0, 1.5), true));
                            figure.IsClosed = true;
                            figure.Freeze(); 

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

                return _leftArrowGeometry; 
            } 
        }
 
        private static Geometry RightArrowGeometry
        {
            get
            { 
                if (_rightArrowGeometry == null)
                { 
                    lock (_glyphAccess) 
                    {
                        if (_rightArrowGeometry == null) 
                        {
                            PathFigure figure = new PathFigure();
                            figure.StartPoint = new Point(3.5, 0.0);
                            figure.Segments.Add(new LineSegment(new Point(8.0, 4.5), true)); 
                            figure.Segments.Add(new LineSegment(new Point(3.5, 9.0), true));
                            figure.Segments.Add(new LineSegment(new Point(2.0, 7.5), true)); 
                            figure.Segments.Add(new LineSegment(new Point(5.0, 4.5), true)); 
                            figure.Segments.Add(new LineSegment(new Point(2.0, 1.5), true));
                            figure.IsClosed = true; 
                            figure.Freeze();

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

                return _rightArrowGeometry;
            } 
        }
 
        private static Geometry UpArrowGeometry 
        {
            get 
            {
                if (_upArrowGeometry == null)
                {
                    lock (_glyphAccess) 
                    {
                        if (_upArrowGeometry == null) 
                        { 
                            PathFigure figure = new PathFigure();
                            figure.StartPoint = new Point(0.0, 4.5); 
                            figure.Segments.Add(new LineSegment(new Point(4.5, 0.0), true));
                            figure.Segments.Add(new LineSegment(new Point(9.0, 4.5), true));
                            figure.Segments.Add(new LineSegment(new Point(7.5, 6.0), true));
                            figure.Segments.Add(new LineSegment(new Point(4.5, 3.0), true)); 
                            figure.Segments.Add(new LineSegment(new Point(1.5, 6.0), true));
                            figure.IsClosed = true; 
                            figure.Freeze(); 

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

                            _upArrowGeometry = path; 
                        }
                    } 
                } 

                return _upArrowGeometry; 
            }
        }

        private static Geometry DownArrowGeometry 
        {
            get 
            { 
                if (_downArrowGeometry == null)
                { 
                    lock (_glyphAccess)
                    {
                        if (_downArrowGeometry == null)
                        { 
                            PathFigure figure = new PathFigure();
                            figure.StartPoint = new Point(0.0, 3.5); 
                            figure.Segments.Add(new LineSegment(new Point(4.5, 8.0), true)); 
                            figure.Segments.Add(new LineSegment(new Point(9.0, 3.5), true));
                            figure.Segments.Add(new LineSegment(new Point(7.5, 2.0), true)); 
                            figure.Segments.Add(new LineSegment(new Point(4.5, 5.0), true));
                            figure.Segments.Add(new LineSegment(new Point(1.5, 2.0), true));
                            figure.IsClosed = true;
                            figure.Freeze(); 

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

                return _downArrowGeometry; 
            } 
        }
 

        #endregion

        private void DrawArrow(DrawingContext dc, Brush brush, Rect bounds, ScrollGlyph glyph) 
        {
            if (_transform == null) 
            { 
                double glyphWidth = 9.0;
                double glyphHeight = 9.0; 
                switch (glyph)
                {
                    case ScrollGlyph.LeftArrow:
                    case ScrollGlyph.RightArrow: 
                        glyphWidth = 8.0;
                        break; 
 
                    case ScrollGlyph.UpArrow:
                    case ScrollGlyph.DownArrow: 
                        glyphHeight = 8.0;
                        break;
                }
                Matrix matrix = new Matrix(); 

                if ((bounds.Width < glyphWidth) || (bounds.Height < glyphHeight)) 
                { 
                    double widthScale = Math.Min(glyphWidth, bounds.Width) / glyphWidth;
                    double heightScale = Math.Min(glyphHeight, bounds.Height) / glyphHeight; 

                    double x = (bounds.X + (bounds.Width * 0.5)) / widthScale - (glyphWidth * 0.5);
                    double y = (bounds.Y + (bounds.Height * 0.5)) / heightScale - (glyphHeight * 0.5);
 
                    if (double.IsNaN(widthScale) || double.IsInfinity(widthScale) || double.IsNaN(heightScale) || double.IsInfinity(heightScale) ||
                        double.IsNaN(x) || double.IsInfinity(x) || double.IsNaN(y) || double.IsInfinity(y)) 
                    { 
                        return;
                    } 

                    matrix.Translate(x, y);
                    matrix.Scale(widthScale, heightScale);
                } 
                else
                { 
                    double x = bounds.X + (bounds.Width * 0.5) - (glyphWidth * 0.5); 
                    double y = bounds.Y + (bounds.Height * 0.5) - (glyphHeight * 0.5);
                    matrix.Translate(x, y); 
                }

                _transform = new MatrixTransform();
                _transform.Matrix = matrix; 
            }
 
            dc.PushTransform(_transform); 

            switch (glyph) 
            {
                case ScrollGlyph.LeftArrow:
                    dc.DrawGeometry(brush, null, LeftArrowGeometry);
                    break; 

                case ScrollGlyph.RightArrow: 
                    dc.DrawGeometry(brush, null, RightArrowGeometry); 
                    break;
 
                case ScrollGlyph.UpArrow:
                    dc.DrawGeometry(brush, null, UpArrowGeometry);
                    break;
 
                case ScrollGlyph.DownArrow:
                    dc.DrawGeometry(brush, null, DownArrowGeometry); 
                    break; 
            }
 
            dc.Pop(); // Center and scaling transform
        }

        // 
        //  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 static LinearGradientBrush CommonLineButtonFillNC 
        {
            get 
            {
                if (_commonLineButtonFillNC == null)
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonLineButtonFillNC == null) 
                        { 
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0); 
                            temp.EndPoint = new Point(1, 1);

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xE1, 0xEA, 0xFE), 0));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC3, 0xD3, 0xFD), 0.3)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC3, 0xD3, 0xFD), 0.6));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xBB, 0xCD, 0xF9), 1)); 
                            temp.Freeze(); 

                            _commonLineButtonFillNC = temp; 
                        }
                    }
                }
                return _commonLineButtonFillNC; 
            }
        } 
 
        private static LinearGradientBrush CommonVerticalFillNC
        { 
            get
            {
                if (_commonVerticalFillNC == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonVerticalFillNC == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(1, 0);

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC9, 0xD8, 0xFC), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC2, 0xD3, 0xFC), 0.65));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xB6, 0xCD, 0xFB), 1)); 
                            temp.Freeze(); 

                            _commonVerticalFillNC = temp; 
                        }
                    }
                }
                return _commonVerticalFillNC; 
            }
        } 
 
        private static LinearGradientBrush CommonHorizontalFillNC
        { 
            get
            {
                if (_commonHorizontalFillNC == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonHorizontalFillNC == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(0, 1);

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC9, 0xD8, 0xFC), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC2, 0xD3, 0xFC), 0.65));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xB6, 0xCD, 0xFB), 1)); 
                            temp.Freeze(); 

                            _commonHorizontalFillNC = temp; 
                        }
                    }
                }
                return _commonHorizontalFillNC; 
            }
        } 
 
        private static LinearGradientBrush CommonHoverLineButtonFillNC
        { 
            get
            {
                if (_commonHoverLineButtonFillNC == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonHoverLineButtonFillNC == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(1, 1);

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFD, 0xFF, 0xFF), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xE2, 0xF3, 0xFD), 0.25));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xB9, 0xDA, 0xFB), 1)); 
                            temp.Freeze(); 

                            _commonHoverLineButtonFillNC = temp; 
                        }
                    }
                }
                return _commonHoverLineButtonFillNC; 
            }
        } 
 
        private static LinearGradientBrush CommonHoverVerticalFillNC
        { 
            get
            {
                if (_commonHoverVerticalFillNC == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonHoverVerticalFillNC == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(1, 0);

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDA, 0xE9, 0xFF), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xD4, 0xE6, 0xFF), 0.65));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCA, 0xE0, 0xFF), 1)); 
                            temp.Freeze(); 

                            _commonHoverVerticalFillNC = temp; 
                        }
                    }
                }
                return _commonHoverVerticalFillNC; 
            }
        } 
 
        private static LinearGradientBrush CommonHoverHorizontalFillNC
        { 
            get
            {
                if (_commonHoverHorizontalFillNC == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonHoverHorizontalFillNC == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(0, 1);

 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDA, 0xE9, 0xFF), 0));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xD4, 0xE6, 0xFF), 0.65)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCA, 0xE0, 0xFF), 1)); 
                            temp.Freeze();
 
                            _commonHoverHorizontalFillNC = temp;
                        }
                    }
                } 
                return _commonHoverHorizontalFillNC;
            } 
        } 

        private static LinearGradientBrush CommonPressedLineButtonFillNC 
        {
            get
            {
                if (_commonPressedLineButtonFillNC == null) 
                {
                    lock (_resourceAccess) 
                    { 
                        if (_commonPressedLineButtonFillNC == null)
                        { 
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(1, 1);
 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x6E, 0x8E, 0xF1), 0));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x80, 0x9D, 0xF1), 0.3)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xAF, 0xBF, 0xED), 0.7)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xD2, 0xDE, 0xEB), 1));
                            temp.Freeze(); 

                            _commonPressedLineButtonFillNC = temp;
                        }
                    } 
                }
                return _commonPressedLineButtonFillNC; 
            } 
        }
 
        private static LinearGradientBrush CommonPressedVerticalFillNC
        {
            get
            { 
                if (_commonPressedVerticalFillNC == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonPressedVerticalFillNC == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(1, 0); 

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA8, 0xBE, 0xF5), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA1, 0xBD, 0xFA), 0.65)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x98, 0xB0, 0xEE), 1));
                            temp.Freeze(); 

                            _commonPressedVerticalFillNC = temp;
                        }
                    } 
                }
                return _commonPressedVerticalFillNC; 
            } 
        }
 
        private static LinearGradientBrush CommonPressedHorizontalFillNC
        {
            get
            { 
                if (_commonPressedHorizontalFillNC == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonPressedHorizontalFillNC == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(0, 1); 

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA8, 0xBE, 0xF5), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA1, 0xBD, 0xFA), 0.65)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x98, 0xB0, 0xEE), 1));
                            temp.Freeze(); 

                            _commonPressedHorizontalFillNC = temp;
                        }
                    } 
                }
                return _commonPressedHorizontalFillNC; 
            } 
        }
 
        private static LinearGradientBrush CommonVerticalFillHS
        {
            get
            { 
                if (_commonVerticalFillHS == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonVerticalFillHS == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(1, 0); 

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA2, 0xB3, 0x8D), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA5, 0xB7, 0x8E), 0.25)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA5, 0xB7, 0x8E), 0.4));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x95, 0xA7, 0x75), .82)); 
                            temp.Freeze();

                            _commonVerticalFillHS = temp;
                        } 
                    }
                } 
                return _commonVerticalFillHS; 
            }
        } 

        private static LinearGradientBrush CommonHorizontalFillHS
        {
            get 
            {
                if (_commonHorizontalFillHS == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonHorizontalFillHS == null)
                        {
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0); 
                            temp.EndPoint = new Point(0, 1);
 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA2, 0xB3, 0x8D), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA5, 0xB7, 0x8E), 0.25));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA5, 0xB7, 0x8E), 0.4)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x95, 0xA7, 0x75), .82));
                            temp.Freeze();

                            _commonHorizontalFillHS = temp; 
                        }
                    } 
                } 
                return _commonHorizontalFillHS;
            } 
        }

        private static LinearGradientBrush CommonHoverVerticalFillHS
        { 
            get
            { 
                if (_commonHoverVerticalFillHS == null) 
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonHoverVerticalFillHS == null)
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(1, 0); 
 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCA, 0xD7, 0xA7), 0));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCB, 0xD9, 0xA9), 0.25)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCB, 0xD9, 0xA9), 0.4));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC3, 0xD0, 0x96), .82));
                            temp.Freeze();
 
                            _commonHoverVerticalFillHS = temp;
                        } 
                    } 
                }
                return _commonHoverVerticalFillHS; 
            }
        }

 
        private static LinearGradientBrush CommonHoverHorizontalFillHS
        { 
            get 
            {
                if (_commonHoverHorizontalFillHS == null) 
                {
                    lock (_resourceAccess)
                    {
                        if (_commonHoverHorizontalFillHS == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0); 
                            temp.EndPoint = new Point(0, 1);
 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCA, 0xD7, 0xA7), 0));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCB, 0xD9, 0xA9), 0.25));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCB, 0xD9, 0xA9), 0.4));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC3, 0xD0, 0x96), .82)); 
                            temp.Freeze();
 
                            _commonHoverHorizontalFillHS = temp; 
                        }
                    } 
                }
                return _commonHoverHorizontalFillHS;
            }
        } 

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

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x92, 0xA4, 0x7A), 0));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x9A, 0xAD, 0x80), 0.25));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x9A, 0xAD, 0x80), 0.4)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x95, 0xAA, 0x72), 0.8));
                            temp.Freeze(); 
 
                            _commonPressedVerticalFillHS = temp;
                        } 
                    }
                }
                return _commonPressedVerticalFillHS;
            } 
        }
 
        private static LinearGradientBrush CommonPressedHorizontalFillHS 
        {
            get 
            {
                if (_commonPressedHorizontalFillHS == null)
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonPressedHorizontalFillHS == null) 
                        { 
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0); 
                            temp.EndPoint = new Point(0, 1);

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x92, 0xA4, 0x7A), 0));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x9A, 0xAD, 0x80), 0.25)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x9A, 0xAD, 0x80), 0.4));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x95, 0xAA, 0x72), 0.8)); 
                            temp.Freeze(); 

                            _commonPressedHorizontalFillHS = temp; 
                        }
                    }
                }
                return _commonPressedHorizontalFillHS; 
            }
        } 
 
        private static LinearGradientBrush CommonVerticalFillM
        { 
            get
            {
                if (_commonVerticalFillM == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonVerticalFillM == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(1, 0);

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xE9, 0xE9, 0xEE), 0.25));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xE9, 0xE9, 0xEE), 0.4)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDB, 0xDB, 0xE6), 0.6)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC7, 0xC8, 0xD6), 0.9));
                            temp.Freeze(); 

                            _commonVerticalFillM = temp;
                        }
                    } 
                }
                return _commonVerticalFillM; 
            } 
        }
 
        private static LinearGradientBrush CommonHorizontalFillM
        {
            get
            { 
                if (_commonHorizontalFillM == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonHorizontalFillM == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0.5, 0);
                            temp.EndPoint = new Point(0.5, 1); 

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xE9, 0xE9, 0xEE), 0.25)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xE9, 0xE9, 0xEE), 0.4));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDB, 0xDB, 0xE6), 0.6)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC7, 0xC8, 0xD6), 0.9));
                            temp.Freeze();

                            _commonHorizontalFillM = temp; 
                        }
                    } 
                } 
                return _commonHorizontalFillM;
            } 
        }


 
        private static LinearGradientBrush CommonHoverVerticalFillM
        { 
            get 
            {
                if (_commonHoverVerticalFillM == null) 
                {
                    lock (_resourceAccess)
                    {
                        if (_commonHoverVerticalFillM == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0); 
                            temp.EndPoint = new Point(1, 0);
 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), 0.18));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xED, 0xF4), 0.3));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xED, 0xF4), 0.45));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDC, 0xDD, 0xE8), 0.6)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC3, 0xC5, 0xD6), 1));
                            temp.Freeze(); 
 
                            _commonHoverVerticalFillM = temp;
                        } 
                    }
                }
                return _commonHoverVerticalFillM;
            } 
        }
 
        private static LinearGradientBrush CommonHoverHorizontalFillM 
        {
            get 
            {
                if (_commonHoverHorizontalFillM == null)
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonHoverHorizontalFillM == null) 
                        { 
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0.5, 0); 
                            temp.EndPoint = new Point(0.5, 1);

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), 0.18));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xED, 0xF4), 0.3)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xED, 0xF4), 0.45));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDC, 0xDD, 0xE8), 0.6)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC3, 0xC5, 0xD6), 1)); 
                            temp.Freeze();
 
                            _commonHoverHorizontalFillM = temp;
                        }
                    }
                } 
                return _commonHoverHorizontalFillM;
            } 
        } 

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

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), 0.12)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC3, 0xC5, 0xD6), 0.12)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDC, 0xDD, 0xE8), 0.48));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xED, 0xF4), 0.58)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xED, 0xF4), 0.7));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), 0.9));
                            temp.Freeze();
 
                            _commonPressedVerticalFillM = temp;
                        } 
                    } 
                }
                return _commonPressedVerticalFillM; 
            }
        }

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

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), 0.12)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC3, 0xC5, 0xD6), 0.12));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDC, 0xDD, 0xE8), 0.48));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xED, 0xF4), 0.58));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xED, 0xF4), 0.7)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), 0.9));
                            temp.Freeze(); 
 
                            _commonPressedHorizontalFillM = temp;
                        } 
                    }
                }
                return _commonPressedHorizontalFillM;
            } 
        }
 
        private static LinearGradientBrush CommonDisabledFill 
        {
            get 
            {
                if (_commonDisabledFill == null)
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonDisabledFill == null) 
                        { 
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0); 
                            temp.EndPoint = new Point(1, 1);

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xF7, 0xF7, 0xF7), 0));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xF0, 0xF0, 0xF0), 0.3)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xEC, 0xEC), 0.6));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xE3, 0xE3, 0xE3), 1)); 
                            temp.Freeze(); 

                            _commonDisabledFill = temp; 
                        }
                    }
                }
                return _commonDisabledFill; 
            }
        } 
 

        private Brush Fill 
        {
            get
            {
                if (!IsEnabled) 
                    return CommonDisabledFill;
 
                ScrollGlyph glyph = ScrollGlyph; 
                ThemeColor themeColor = ThemeColor;
 
                if (glyph == ScrollGlyph.VerticalGripper)
                {
                    if (RenderPressed)
                    { 
                        if (themeColor == ThemeColor.NormalColor)
                            return CommonPressedVerticalFillNC; 
                        else if (themeColor == ThemeColor.Homestead) 
                            return CommonPressedVerticalFillHS;
                        else 
                            return CommonPressedVerticalFillM;
                    }

                    if (RenderMouseOver) 
                    {
                        if (themeColor == ThemeColor.NormalColor) 
                            return CommonHoverVerticalFillNC; 
                        else if (themeColor == ThemeColor.Homestead)
                            return CommonHoverVerticalFillHS; 
                        else
                            return CommonHoverVerticalFillM;
                    }
 
                    if (themeColor == ThemeColor.NormalColor)
                        return CommonVerticalFillNC; 
                    else if (themeColor == ThemeColor.Homestead) 
                        return CommonVerticalFillHS;
                    else 
                        return CommonVerticalFillM;
                }
                else if (glyph == ScrollGlyph.HorizontalGripper)
                { 
                    if (RenderPressed)
                    { 
                        if (themeColor == ThemeColor.NormalColor) 
                            return CommonPressedHorizontalFillNC;
                        else if (themeColor == ThemeColor.Homestead) 
                            return CommonPressedHorizontalFillHS;
                        else
                            return CommonPressedHorizontalFillM;
                    } 

                    if (RenderMouseOver) 
                    { 
                        if (themeColor == ThemeColor.NormalColor)
                            return CommonHoverHorizontalFillNC; 
                        else if (themeColor == ThemeColor.Homestead)
                            return CommonHoverHorizontalFillHS;
                        else
                            return CommonHoverHorizontalFillM; 
                    }
 
                    if (themeColor == ThemeColor.NormalColor) 
                        return CommonHorizontalFillNC;
                    else if (themeColor == ThemeColor.Homestead) 
                        return CommonHorizontalFillHS;
                    else
                        return CommonHorizontalFillM;
                } 
                else
                { 
                    if (RenderPressed) 
                    {
                        if (themeColor == ThemeColor.NormalColor) 
                            return CommonPressedLineButtonFillNC;
                        else if (themeColor == ThemeColor.Homestead)
                            return CommonPressedHorizontalFillHS;
                        else 
                            return CommonPressedHorizontalFillM;
                    } 
 
                    if (RenderMouseOver)
                    { 
                        if (themeColor == ThemeColor.NormalColor)
                            return CommonHoverLineButtonFillNC;
                        else if (themeColor == ThemeColor.Homestead)
                            return CommonHoverHorizontalFillHS; 
                        else
                            return CommonHoverHorizontalFillM; 
                    } 

                    if (themeColor == ThemeColor.NormalColor) 
                        return CommonLineButtonFillNC;
                    else if (themeColor == ThemeColor.Homestead)
                        return CommonHorizontalFillHS;
                    else 
                        return CommonHorizontalFillM;
                } 
            } 
        }
 

        private static SolidColorBrush CommonDisabledGlyph
        {
            get 
            {
                if (_commonDisabledGlyph == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonDisabledGlyph == null)
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xC9, 0xC9, 0xC2));
                            temp.Freeze(); 

                            _commonDisabledGlyph = temp; 
                        } 
                    }
                } 
                return _commonDisabledGlyph;
            }
        }
 
        private static SolidColorBrush CommonArrowGlyphNC
        { 
            get 
            {
                if (_commonArrowGlyphNC == null) 
                {
                    lock (_resourceAccess)
                    {
                        if (_commonArrowGlyphNC == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x4D, 0x61, 0x85)); 
                            temp.Freeze(); 

                            _commonArrowGlyphNC = temp; 
                        }
                    }
                }
                return _commonArrowGlyphNC; 
            }
        } 
 
        private static SolidColorBrush CommonArrowGlyphHS
        { 
            get
            {
                return Brushes.White;
            } 
        }
 
        private static SolidColorBrush CommonArrowGlyphM 
        {
            get 
            {
                if (_commonArrowGlyphM == null)
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonArrowGlyphM == null) 
                        { 
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x3F, 0x3D, 0x3D));
                            temp.Freeze(); 

                            _commonArrowGlyphM = temp;
                        }
                    } 
                }
                return _commonArrowGlyphM; 
            } 
        }
 
        private static SolidColorBrush CommonHoverArrowGlyphM
        {
            get
            { 
                if (_commonHoverArrowGlyphM == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonHoverArrowGlyphM == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x20, 0x20, 0x20));
                            temp.Freeze();
 
                            _commonHoverArrowGlyphM = temp;
                        } 
                    } 
                }
                return _commonHoverArrowGlyphM; 
            }
        }

        private static SolidColorBrush CommonGripperGlyphNC 
        {
            get 
            { 
                if (_commonGripperGlyphNC == null)
                { 
                    lock (_resourceAccess)
                    {
                        if (_commonGripperGlyphNC == null)
                        { 
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xEE, 0xF4, 0xFE));
                            temp.Freeze(); 
 
                            _commonGripperGlyphNC = temp;
                        } 
                    }
                }
                return _commonGripperGlyphNC;
            } 
        }
 
        private static SolidColorBrush CommonHoverGripperGlyphNC 
        {
            get 
            {
                if (_commonHoverGripperGlyphNC == null)
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonHoverGripperGlyphNC == null) 
                        { 
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xFC, 0xFD, 0xFF));
                            temp.Freeze(); 

                            _commonHoverGripperGlyphNC = temp;
                        }
                    } 
                }
                return _commonHoverGripperGlyphNC; 
            } 
        }
 
        private static SolidColorBrush CommonPressedGripperGlyphNC
        {
            get
            { 
                if (_commonPressedGripperGlyphNC == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonPressedGripperGlyphNC == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xCF, 0xDD, 0xFD));
                            temp.Freeze();
 
                            _commonPressedGripperGlyphNC = temp;
                        } 
                    } 
                }
                return _commonPressedGripperGlyphNC; 
            }
        }

        private static SolidColorBrush CommonGripperGlyphHS 
        {
            get 
            { 
                if (_commonGripperGlyphHS == null)
                { 
                    lock (_resourceAccess)
                    {
                        if (_commonGripperGlyphHS == null)
                        { 
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xD0, 0xDF, 0xAC));
                            temp.Freeze(); 
 
                            _commonGripperGlyphHS = temp;
                        } 
                    }
                }
                return _commonGripperGlyphHS;
            } 
        }
 
        private static SolidColorBrush CommonHoverGripperGlyphHS 
        {
            get 
            {
                if (_commonHoverGripperGlyphHS == null)
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonHoverGripperGlyphHS == null) 
                        { 
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xEB, 0xF5, 0xD4));
                            temp.Freeze(); 

                            _commonHoverGripperGlyphHS = temp;
                        }
                    } 
                }
                return _commonHoverGripperGlyphHS; 
            } 
        }
 
        private static SolidColorBrush CommonPressedGripperGlyphHS
        {
            get
            { 
                if (_commonPressedGripperGlyphHS == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonPressedGripperGlyphHS == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xB9, 0xD0, 0x97));
                            temp.Freeze();
 
                            _commonPressedGripperGlyphHS = temp;
                        } 
                    } 
                }
                return _commonPressedGripperGlyphHS; 
            }
        }

        private static SolidColorBrush CommonGripperGlyphM 
        {
            get 
            { 
                if (_commonGripperGlyphM == null)
                { 
                    lock (_resourceAccess)
                    {
                        if (_commonGripperGlyphM == null)
                        { 
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF));
                            temp.Freeze(); 
 
                            _commonGripperGlyphM = temp;
                        } 
                    }
                }
                return _commonGripperGlyphM;
            } 
        }
 
        private Brush Glyph 
        {
            get 
            {
                if (!IsEnabled)
                    return CommonDisabledGlyph;
 
                ThemeColor themeColor = ThemeColor;
                ScrollGlyph scrollGlyph = ScrollGlyph; 
 
                if (scrollGlyph == ScrollGlyph.HorizontalGripper || scrollGlyph == ScrollGlyph.VerticalGripper)
                { 
                    if (themeColor == ThemeColor.NormalColor)
                    {
                        if (RenderPressed)
                            return CommonPressedGripperGlyphNC; 
                        else if (RenderMouseOver)
                            return CommonHoverGripperGlyphNC; 
                        else 
                            return CommonGripperGlyphNC;
                    } 
                    else if (themeColor == ThemeColor.Homestead)
                    {
                        if (RenderPressed)
                            return CommonPressedGripperGlyphHS; 
                        else if (RenderMouseOver)
                            return CommonHoverGripperGlyphHS; 
                        else 
                            return CommonGripperGlyphHS;
                    } 
                    else
                    {
                        return CommonGripperGlyphM;
                    } 
                }
                else 
                { 
                    if (themeColor == ThemeColor.NormalColor)
                        return CommonArrowGlyphNC; 
                    else if (themeColor == ThemeColor.Homestead)
                        return CommonArrowGlyphHS;
                    else
                    { 
                        if (RenderMouseOver || RenderPressed)
                            return CommonHoverArrowGlyphM; 
                        else 
                            return CommonArrowGlyphM;
                    } 
                }
            }
        }
 

 
 
        private static SolidColorBrush CommonDisabledGripperGlyphShadow
        { 
            get
            {
                if (_commonDisabledGripperGlyphShadow == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonDisabledGripperGlyphShadow == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xB9, 0xB9, 0xB2)); 
                            temp.Freeze();

                            _commonDisabledGripperGlyphShadow = temp;
                        } 
                    }
                } 
                return _commonDisabledGripperGlyphShadow; 
            }
        } 

        private static SolidColorBrush CommonGripperGlyphShadowNC
        {
            get 
            {
                if (_commonGripperGlyphShadowNC == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonGripperGlyphShadowNC == null)
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x8C, 0xB0, 0xF8));
                            temp.Freeze(); 

                            _commonGripperGlyphShadowNC = temp; 
                        } 
                    }
                } 
                return _commonGripperGlyphShadowNC;
            }
        }
 
        private static SolidColorBrush CommonHoverGripperGlyphShadowNC
        { 
            get 
            {
                if (_commonHoverGripperGlyphShadowNC == null) 
                {
                    lock (_resourceAccess)
                    {
                        if (_commonHoverGripperGlyphShadowNC == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x9C, 0xC5, 0xFF)); 
                            temp.Freeze(); 

                            _commonHoverGripperGlyphShadowNC = temp; 
                        }
                    }
                }
                return _commonHoverGripperGlyphShadowNC; 
            }
        } 
 
        private static SolidColorBrush CommonPressedGripperGlyphShadowNC
        { 
            get
            {
                if (_commonPressedGripperGlyphShadowNC == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonPressedGripperGlyphShadowNC == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x83, 0x9E, 0xD8)); 
                            temp.Freeze();

                            _commonPressedGripperGlyphShadowNC = temp;
                        } 
                    }
                } 
                return _commonPressedGripperGlyphShadowNC; 
            }
        } 

        private static SolidColorBrush CommonGripperGlyphShadowHS
        {
            get 
            {
                if (_commonGripperGlyphShadowHS == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonGripperGlyphShadowHS == null)
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x8C, 0x9D, 0x73));
                            temp.Freeze(); 

                            _commonGripperGlyphShadowHS = temp; 
                        } 
                    }
                } 
                return _commonGripperGlyphShadowHS;
            }
        }
 
        private static SolidColorBrush CommonHoverGripperGlyphShadowHS
        { 
            get 
            {
                if (_commonHoverGripperGlyphShadowHS == null) 
                {
                    lock (_resourceAccess)
                    {
                        if (_commonHoverGripperGlyphShadowHS == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xB6, 0xC6, 0x8E)); 
                            temp.Freeze(); 

                            _commonHoverGripperGlyphShadowHS = temp; 
                        }
                    }
                }
                return _commonHoverGripperGlyphShadowHS; 
            }
        } 
 
        private static SolidColorBrush CommonPressedGripperGlyphShadowHS
        { 
            get
            {
                if (_commonPressedGripperGlyphShadowHS == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonPressedGripperGlyphShadowHS == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x7A, 0x8B, 0x63)); 
                            temp.Freeze();

                            _commonPressedGripperGlyphShadowHS = temp;
                        } 
                    }
                } 
                return _commonPressedGripperGlyphShadowHS; 
            }
        } 

        private static SolidColorBrush CommonGripperGlyphShadowM
        {
            get 
            {
                if (_commonGripperGlyphShadowM == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonGripperGlyphShadowM == null)
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x8E, 0x95, 0xA2));
                            temp.Freeze(); 

                            _commonGripperGlyphShadowM = temp; 
                        } 
                    }
                } 
                return _commonGripperGlyphShadowM;
            }
        }
 

        private Brush GlyphShadow 
        { 
            get
            { 
                ScrollGlyph scrollGlyph = ScrollGlyph;

                if (scrollGlyph == ScrollGlyph.HorizontalGripper || scrollGlyph == ScrollGlyph.VerticalGripper)
                { 
                    if (!IsEnabled)
                        return CommonDisabledGripperGlyphShadow; 
 
                    ThemeColor themeColor = ThemeColor;
 
                    if (themeColor == ThemeColor.NormalColor)
                    {
                        if (RenderPressed)
                            return CommonPressedGripperGlyphShadowNC; 
                        else if (RenderMouseOver)
                            return CommonHoverGripperGlyphShadowNC; 
                        else 
                            return CommonGripperGlyphShadowNC;
                    } 
                    else if (themeColor == ThemeColor.Homestead)
                    {
                        if (RenderPressed)
                            return CommonPressedGripperGlyphShadowHS; 
                        else if (RenderMouseOver)
                            return CommonHoverGripperGlyphShadowHS; 
                        else 
                            return CommonGripperGlyphShadowHS;
                    } 
                    else
                    {
                        return CommonGripperGlyphShadowM;
                    } 
                }
                return null; 
            } 
        }
 
        private static Pen CommonOuterBorderPenNC
        {
            get
            { 
                if (_commonOuterBorderPenNC == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonOuterBorderPenNC == null) 
                        {
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF));
                            temp.Freeze(); 

                            _commonOuterBorderPenNC = temp; 
                        } 
                    }
                } 
                return _commonOuterBorderPenNC;
            }
        }
 
        private static Pen CommonOuterBorderPenHS
        { 
            get 
            {
                if (_commonOuterBorderPenHS == null) 
                {
                    lock (_resourceAccess)
                    {
                        if (_commonOuterBorderPenHS == null) 
                        {
                            Pen temp = new Pen(); 
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF)); 
                            temp.Freeze();
 
                            _commonOuterBorderPenHS = temp;
                        }
                    }
                } 
                return _commonOuterBorderPenHS;
            } 
        } 

        private static Pen CommonOuterBorderPenM 
        {
            get
            {
                if (_commonOuterBorderPenM == null) 
                {
                    lock (_resourceAccess) 
                    { 
                        if (_commonOuterBorderPenM == null)
                        { 
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0x94, 0x95, 0xA2));
                            temp.Freeze();
 
                            _commonOuterBorderPenM = temp;
                        } 
                    } 
                }
                return _commonOuterBorderPenM; 
            }
        }

        private static Pen CommonHoverOuterBorderPenM 
        {
            get 
            { 
                if (_commonHoverOuterBorderPenM == null)
                { 
                    lock (_resourceAccess)
                    {
                        if (_commonHoverOuterBorderPenM == null)
                        { 
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0x5B, 0x66, 0x65)); 
                            temp.Freeze(); 

                            _commonHoverOuterBorderPenM = temp; 
                        }
                    }
                }
                return _commonHoverOuterBorderPenM; 
            }
        } 
 
        private static Pen CommonPressedOuterBorderPenM
        { 
            get
            {
                if (_commonPressedOuterBorderPenM == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonPressedOuterBorderPenM == null) 
                        {
                            Pen temp = new Pen(); 
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0x43, 0x48, 0x48));
                            temp.Freeze();

                            _commonPressedOuterBorderPenM = temp; 
                        }
                    } 
                } 
                return _commonPressedOuterBorderPenM;
            } 
        }


        private Pen OuterBorder 
        {
            get 
            { 
                ThemeColor themeColor = ThemeColor;
 
                if (themeColor == ThemeColor.Metallic)
                {
                    ScrollGlyph glyph = ScrollGlyph;
                    if (!IsEnabled) 
                        return CommonOuterBorderPenNC;
                    else if (RenderPressed && (glyph == ScrollGlyph.HorizontalGripper || glyph == ScrollGlyph.VerticalGripper) ) 
                        return CommonPressedOuterBorderPenM; 
                    else if (RenderPressed || RenderMouseOver)
                        return CommonHoverOuterBorderPenM; 
                    else
                        return CommonOuterBorderPenM;
                }
                else 
                {
                    if (HasOuterBorder) 
                    { 
                        if (themeColor == ThemeColor.NormalColor)
                            return CommonOuterBorderPenNC; 
                        else // themeColor == ThemeColor.Homestead
                            return CommonOuterBorderPenHS;
                    }
                    else 
                        return null;
                } 
            } 
        }
 

        private static Pen CommonDisabledInnerBorderPen
        {
            get 
            {
                if (_commonDisabledInnerBorderPen == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonDisabledInnerBorderPen == null)
                        {
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xE8, 0xE8, 0xDF)); 
                            temp.Freeze();
 
                            _commonDisabledInnerBorderPen = temp; 
                        }
                    } 
                }
                return _commonDisabledInnerBorderPen;
            }
        } 

        private static Pen CommonInnerBorderPenNC 
        { 
            get
            { 
                if (_commonInnerBorderPenNC == null)
                {
                    lock (_resourceAccess)
                    { 
                        if (_commonInnerBorderPenNC == null)
                        { 
                            Pen temp = new Pen(); 
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xB4, 0xC8, 0xF6));
                            temp.Freeze(); 

                            _commonInnerBorderPenNC = temp;
                        }
                    } 
                }
                return _commonInnerBorderPenNC; 
            } 
        }
 


        private static Pen CommonHoverInnerBorderPenNC
        { 
            get
            { 
                if (_commonHoverInnerBorderPenNC == null) 
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonHoverInnerBorderPenNC == null)
                        {
                            Pen temp = new Pen(); 
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0x98, 0xB1, 0xE4));
                            temp.Freeze(); 
 
                            _commonHoverInnerBorderPenNC = temp;
                        } 
                    }
                }
                return _commonHoverInnerBorderPenNC;
            } 
        }
 
        private static Pen CommonHoverThumbInnerBorderPenNC 
        {
            get 
            {
                if (_commonHoverThumbInnerBorderPenNC == null)
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonHoverThumbInnerBorderPenNC == null) 
                        { 
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xAC, 0xCE, 0xFF)); 
                            temp.Freeze();

                            _commonHoverThumbInnerBorderPenNC = temp;
                        } 
                    }
                } 
                return _commonHoverThumbInnerBorderPenNC; 
            }
        } 

        private static Pen CommonPressedInnerBorderPenNC
        {
            get 
            {
                if (_commonPressedInnerBorderPenNC == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonPressedInnerBorderPenNC == null)
                        {
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0x83, 0x8F, 0xDA)); 
                            temp.Freeze();
 
                            _commonPressedInnerBorderPenNC = temp; 
                        }
                    } 
                }
                return _commonPressedInnerBorderPenNC;
            }
        } 

        private static Pen CommonInnerBorderPenHS 
        { 
            get
            { 
                if (_commonInnerBorderPenHS == null)
                {
                    lock (_resourceAccess)
                    { 
                        if (_commonInnerBorderPenHS == null)
                        { 
                            Pen temp = new Pen(); 
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0x8E, 0x99, 0x7D));
                            temp.Freeze(); 

                            _commonInnerBorderPenHS = temp;
                        }
                    } 
                }
                return _commonInnerBorderPenHS; 
            } 
        }
 
        private static Pen CommonHoverInnerBorderPenHS
        {
            get
            { 
                if (_commonHoverInnerBorderPenHS == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonHoverInnerBorderPenHS == null) 
                        {
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xBD, 0xCB, 0x96));
                            temp.Freeze(); 

                            _commonHoverInnerBorderPenHS = temp; 
                        } 
                    }
                } 
                return _commonHoverInnerBorderPenHS;
            }
        }
 

        private static Pen CommonPressedInnerBorderPenHS 
        { 
            get
            { 
                if (_commonPressedInnerBorderPenHS == null)
                {
                    lock (_resourceAccess)
                    { 
                        if (_commonPressedInnerBorderPenHS == null)
                        { 
                            Pen temp = new Pen(); 
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0x7A, 0x8B, 0x63));
                            temp.Freeze(); 

                            _commonPressedInnerBorderPenHS = temp;
                        }
                    } 
                }
                return _commonPressedInnerBorderPenHS; 
            } 
        }
 
        private static Pen CommonInnerBorderPenM
        {
            get
            { 
                if (_commonInnerBorderPenM == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonInnerBorderPenM == null) 
                        {
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF));
                            temp.Freeze(); 

                            _commonInnerBorderPenM = temp; 
                        } 
                    }
                } 
                return _commonInnerBorderPenM;
            }
        }
 
        private static Pen CommonHoverInnerBorderPenM
        { 
            get 
            {
                if (_commonHoverInnerBorderPenM == null) 
                {
                    lock (_resourceAccess)
                    {
                        if (_commonHoverInnerBorderPenM == null) 
                        {
                            Pen temp = new Pen(); 
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF)); 
                            temp.Freeze();
 
                            _commonHoverInnerBorderPenM = temp;
                        }
                    }
                } 
                return _commonHoverInnerBorderPenM;
            } 
        } 

 
        private static Pen CommonPressedInnerBorderPenM
        {
            get
            { 
                if (_commonPressedInnerBorderPenM == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonPressedInnerBorderPenM == null) 
                        {
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF));
                            temp.Freeze(); 

                            _commonPressedInnerBorderPenM = temp; 
                        } 
                    }
                } 
                return _commonPressedInnerBorderPenM;
            }
        }
 

 
        private Pen InnerBorder 
        {
            get 
            {
                ScrollGlyph scrollGlyph = ScrollGlyph;

 
                if (!IsEnabled)
                    return CommonDisabledInnerBorderPen; 
 
                ThemeColor themeColor = ThemeColor;
 
                if (RenderPressed)
                {
                    if (themeColor == ThemeColor.NormalColor)
                        return CommonPressedInnerBorderPenNC; 
                    else if (themeColor == ThemeColor.Homestead)
                        return CommonPressedInnerBorderPenHS; 
                    else 
                        return CommonPressedInnerBorderPenM;
                } 

                if (RenderMouseOver)
                {
                    if (themeColor == ThemeColor.NormalColor) 
                    {
                        if (scrollGlyph == ScrollGlyph.HorizontalGripper || scrollGlyph == ScrollGlyph.VerticalGripper) 
                            return CommonHoverThumbInnerBorderPenNC; 
                        else
                            return CommonHoverInnerBorderPenNC; 
                    }
                    else if (themeColor == ThemeColor.Homestead)
                        return CommonHoverInnerBorderPenHS;
                    else 
                        return CommonHoverInnerBorderPenM;
                } 
 
                if (themeColor == ThemeColor.NormalColor)
                    return CommonInnerBorderPenNC; 
                else if (themeColor == ThemeColor.Homestead)
                    return CommonInnerBorderPenHS;
                else
                    return CommonInnerBorderPenM; 
            }
        } 
 
        private static Pen CommonDisabledShadowPen
        { 
            get
            {
                if (_commonDisabledShadowPen == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonDisabledShadowPen == null) 
                        {
                            Pen temp = new Pen(); 

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

                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0x00, 0xCC, 0xCC, 0xBA), 0)); 
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCC, 0xCC, 0xBA), 0.5)); 
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC4, 0xC4, 0xAF), 1));
                            brush.Freeze(); 

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

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

                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0x00, 0xA0, 0xB5, 0xD3), 0));
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA0, 0xB5, 0xD3), 0.5));
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x7C, 0x9F, 0xD3), 1)); 
                            brush.Freeze();
 
                            temp.Brush = brush; 
                            temp.Freeze();
 
                            _commonShadowPenNC = temp;
                        }
                    }
                } 
                return _commonShadowPenNC;
            } 
        } 

        private static Pen CommonShadowPenHS 
        {
            get
            {
                if (_commonShadowPenHS == null) 
                {
                    lock (_resourceAccess) 
                    { 
                        if (_commonShadowPenHS == null)
                        { 
                            Pen temp = new Pen();

                            LinearGradientBrush brush = new LinearGradientBrush();
                            brush.StartPoint = new Point(0, 0); 
                            brush.EndPoint = new Point(0, 1);
 
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0x00, 0xB6, 0xC1, 0xA6), 0)); 
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x9B, 0xB1, 0x81), 0.5));
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x8B, 0x93, 0x77), 1)); 
                            brush.Freeze();

                            temp.Brush = brush;
                            temp.Freeze(); 

                            _commonShadowPenHS = temp; 
                        } 
                    }
                } 
                return _commonShadowPenHS;
            }
        }
 
        private Pen Shadow
        { 
            get 
            {
                if (HasOuterBorder) 
                {
                    if (!IsEnabled)
                        return CommonDisabledShadowPen;
 
                    ThemeColor themeColor = ThemeColor;
 
                    if (themeColor == ThemeColor.NormalColor) 
                        return CommonShadowPenNC;
                    else if (themeColor == ThemeColor.Homestead) 
                        return CommonShadowPenHS;
                    else
                        return null;
                } 
                return null;
            } 
        } 

        #endregion 

        #region Data

        private static LinearGradientBrush _commonLineButtonFillNC; 
        private static LinearGradientBrush _commonVerticalFillNC;
        private static LinearGradientBrush _commonHorizontalFillNC; 
 
        private static LinearGradientBrush _commonVerticalFillHS;
        private static LinearGradientBrush _commonHorizontalFillHS; 

        private static LinearGradientBrush _commonVerticalFillM;
        private static LinearGradientBrush _commonHorizontalFillM;
 

        private static LinearGradientBrush _commonHoverLineButtonFillNC; 
        private static LinearGradientBrush _commonHoverVerticalFillNC; 
        private static LinearGradientBrush _commonHoverHorizontalFillNC;
 
        private static LinearGradientBrush _commonHoverVerticalFillHS;
        private static LinearGradientBrush _commonHoverHorizontalFillHS;

        private static LinearGradientBrush _commonHoverVerticalFillM; 
        private static LinearGradientBrush _commonHoverHorizontalFillM;
 
 
        private static LinearGradientBrush _commonPressedLineButtonFillNC;
        private static LinearGradientBrush _commonPressedVerticalFillNC; 
        private static LinearGradientBrush _commonPressedHorizontalFillNC;

        private static LinearGradientBrush _commonPressedVerticalFillHS;
        private static LinearGradientBrush _commonPressedHorizontalFillHS; 

        private static LinearGradientBrush _commonPressedVerticalFillM; 
        private static LinearGradientBrush _commonPressedHorizontalFillM; 

        private static LinearGradientBrush _commonDisabledFill; 


        private static SolidColorBrush _commonDisabledGlyph;
 
        private static SolidColorBrush _commonArrowGlyphNC;
        private static SolidColorBrush _commonArrowGlyphM; 
 
        private static SolidColorBrush _commonHoverArrowGlyphM;
 
        private static SolidColorBrush _commonGripperGlyphNC;
        private static SolidColorBrush _commonHoverGripperGlyphNC;
        private static SolidColorBrush _commonPressedGripperGlyphNC;
 
        private static SolidColorBrush _commonGripperGlyphHS;
        private static SolidColorBrush _commonHoverGripperGlyphHS; 
        private static SolidColorBrush _commonPressedGripperGlyphHS; 

        private static SolidColorBrush _commonGripperGlyphM; 

        private static SolidColorBrush _commonDisabledGripperGlyphShadow;

        private static SolidColorBrush _commonGripperGlyphShadowNC; 
        private static SolidColorBrush _commonHoverGripperGlyphShadowNC;
        private static SolidColorBrush _commonPressedGripperGlyphShadowNC; 
 
        private static SolidColorBrush _commonGripperGlyphShadowHS;
        private static SolidColorBrush _commonHoverGripperGlyphShadowHS; 
        private static SolidColorBrush _commonPressedGripperGlyphShadowHS;

        private static SolidColorBrush _commonGripperGlyphShadowM;
 
        private static Pen _commonOuterBorderPenNC;
 
        private static Pen _commonOuterBorderPenHS; 

        private static Pen _commonOuterBorderPenM; 
        private static Pen _commonHoverOuterBorderPenM;
        private static Pen _commonPressedOuterBorderPenM;

 
        private static Pen _commonDisabledInnerBorderPen;
 
        private static Pen _commonInnerBorderPenNC; 
        private static Pen _commonInnerBorderPenHS;
        private static Pen _commonInnerBorderPenM; 

        private static Pen _commonHoverInnerBorderPenNC;
        private static Pen _commonHoverThumbInnerBorderPenNC;
 
        private static Pen _commonHoverInnerBorderPenHS;
        private static Pen _commonHoverInnerBorderPenM; 
 
        private static Pen _commonPressedInnerBorderPenNC;
        private static Pen _commonPressedInnerBorderPenHS; 
        private static Pen _commonPressedInnerBorderPenM;

        private static Pen _commonDisabledShadowPen;
 
        private static Pen _commonShadowPenNC;
        private static Pen _commonShadowPenHS; 
 

        private static object _resourceAccess = new object(); 


        private MatrixTransform _transform;
 
        #endregion
    } 
} 


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//---------------------------------------------------------------------------- 
// File: ScrollChrome.cs
//
// Description:
// Implementation of chrome for scrollbar and combobox buttons and thumbs in Luna. 
//
// Copyright (C) 2004 by Microsoft Corporation.  All rights reserved. 
// 
//---------------------------------------------------------------------------
 
using System;
using System.Windows.Shapes;
using System.Windows.Controls;
using System.Diagnostics; 
using System.Threading;
 
using System.Windows; 
using System.Windows.Media;
using MS.Internal; 

namespace Microsoft.Windows.Themes
{
    ///  
    ///     The ScrollChrome element
    ///     This element is a theme-specific type that is used as an optimization 
    ///     for a common complex rendering used in Luna 
    /// 
    public sealed class ScrollChrome : FrameworkElement 
    {

        #region Constructors
 
        static ScrollChrome()
        { 
            IsEnabledProperty.OverrideMetadata(typeof(ScrollChrome), new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.AffectsRender)); 
        }
 
        /// 
        ///     Instantiates a new instance of a ScrollChrome with no parent element.
        /// 
        public ScrollChrome() 
        {
        } 
 
        #endregion Constructors
 
        #region Dynamic Properties

        /// 
        ///     Attached DependencyProperty to assign the orientation and type of the glyph 
        /// 
        public static readonly DependencyProperty ThemeColorProperty 
            = ButtonChrome.ThemeColorProperty.AddOwner(typeof(ScrollChrome), 
                                new FrameworkPropertyMetadata(
                                ThemeColor.NormalColor, 
                                FrameworkPropertyMetadataOptions.AffectsRender));

        /// 
        /// The color variation of the button. 
        /// 
        public ThemeColor ThemeColor 
        { 
            get { return (ThemeColor)GetValue(ThemeColorProperty); }
            set { SetValue(ThemeColorProperty, value); } 
        }

        /// 
        /// DependencyProperty for  property. 
        /// 
        public static readonly DependencyProperty HasOuterBorderProperty = 
                 DependencyProperty.Register("HasOuterBorder", 
                         typeof(bool),
                         typeof(ScrollChrome), 
                         new FrameworkPropertyMetadata(
                                true,
                                FrameworkPropertyMetadataOptions.AffectsRender));
 
        /// 
        /// When true the chrome renders with a white outer border. 
        ///  
        public bool HasOuterBorder
        { 
            get { return (bool)GetValue(HasOuterBorderProperty); }
            set { SetValue(HasOuterBorderProperty, value); }
        }
 

        ///  
        ///     Attached DependencyProperty to assign the orientation and type of the glyph 
        /// 
        public static readonly DependencyProperty ScrollGlyphProperty = 
                DependencyProperty.RegisterAttached(
                        "ScrollGlyph",
                        typeof(ScrollGlyph),
                        typeof(ScrollChrome), 
                        new FrameworkPropertyMetadata(
                                ScrollGlyph.None, 
                                FrameworkPropertyMetadataOptions.AffectsRender), 
                        new ValidateValueCallback(IsValidScrollGlyph));
 
        /// 
        ///     Gets the value of the ScrollGlyph property on the object.
        /// 
        /// The object to which the property is attached. 
        /// The value of the property.
        public static ScrollGlyph GetScrollGlyph(DependencyObject element) 
        { 
            if (element == null) { throw new ArgumentNullException("element"); }
 
            return (ScrollGlyph)element.GetValue(ScrollGlyphProperty);
        }

        ///  
        ///     Attachs the value to the object.
        ///  
        /// The object on which the value will be attached. 
        /// The value to attach.
        public static void SetScrollGlyph(DependencyObject element, ScrollGlyph value) 
        {
            if (element == null) { throw new ArgumentNullException("element"); }

            element.SetValue(ScrollGlyphProperty, value); 
        }
 
        private ScrollGlyph ScrollGlyph 
        {
            get { return (ScrollGlyph)GetValue(ScrollGlyphProperty); } 
        }

        private static bool IsValidScrollGlyph(object o)
        { 
            ScrollGlyph glyph = (ScrollGlyph)o;
            return glyph == ScrollGlyph.None || 
                glyph == ScrollGlyph.LeftArrow || 
                glyph == ScrollGlyph.RightArrow ||
                glyph == ScrollGlyph.UpArrow || 
                glyph == ScrollGlyph.DownArrow ||
                glyph == ScrollGlyph.VerticalGripper ||
                glyph == ScrollGlyph.HorizontalGripper;
        } 

        ///  
        ///     DependencyProperty for  property. 
        /// 
        public static readonly DependencyProperty PaddingProperty = Control.PaddingProperty.AddOwner(typeof(ScrollChrome)); 

        /// 
        ///     Insets the border of the element.
        ///  
        public Thickness Padding
        { 
            get { return (Thickness)GetValue(PaddingProperty); } 
            set { SetValue(PaddingProperty, value); }
        } 

        /// 
        /// DependencyProperty for  property.
        ///  
        public static readonly DependencyProperty RenderMouseOverProperty
            = ButtonChrome.RenderMouseOverProperty.AddOwner(typeof(ScrollChrome), 
                                new FrameworkPropertyMetadata( 
                                false,
                                FrameworkPropertyMetadataOptions.AffectsRender)); 

        /// 
        /// When true the chrome renders with a mouse over look.
        ///  
        public bool RenderMouseOver
        { 
            get { return (bool)GetValue(RenderMouseOverProperty); } 
            set { SetValue(RenderMouseOverProperty, value); }
        } 


        /// 
        /// DependencyProperty for  property. 
        /// 
        public static readonly DependencyProperty RenderPressedProperty 
            = ButtonChrome.RenderPressedProperty.AddOwner(typeof(ScrollChrome), 
                                new FrameworkPropertyMetadata(
                                false, 
                                FrameworkPropertyMetadataOptions.AffectsRender));

        /// 
        /// When true the chrome renders with a pressed look. 
        /// 
        public bool RenderPressed 
        { 
            get { return (bool)GetValue(RenderPressedProperty); }
            set { SetValue(RenderPressedProperty, value); } 
        }

        #endregion Dynamic Properties
 
        #region Protected Methods
 
        ///  
        ///     Updates DesiredSize of the ScrollChrome.  Called by parent UIElement.  This is the first pass of layout.
        ///  
        /// 
        ///     ScrollChrome basically constrains the value of its Width and Height properties.
        /// 
        /// Available size is an "upper limit" that the return value should not exceed. 
        /// The ScrollChrome's desired size.
        protected override Size MeasureOverride(Size availableSize) 
        { 
            _transform = null;
 
            return new Size(0, 0);
        }

        ///  
        ///     ScrollChrome does no work here and returns arrangeSize.
        ///  
        /// Size the ContentPresenter will assume. 
        protected override Size ArrangeOverride(Size finalSize)
        { 
            _transform = null;
            return finalSize;
        }
 
        /// 
        /// Render callback. 
        /// Note: Assumes all borders are 1 unit. 
        /// 
        protected override void OnRender(DrawingContext drawingContext) 
        {
            Rect bounds = new Rect(0, 0, ActualWidth, ActualHeight);
            ScrollGlyph glyph = ScrollGlyph;
            bool hasModifiers; 

            // Padding will be used to inset the border - used by ComboBox buttons 
            if (GetValueSource(PaddingProperty, null, out hasModifiers) != BaseValueSourceInternal.Default || hasModifiers) 
            {
                Thickness padding = Padding; 

                double totalPadding = padding.Left + padding.Right;
                if (totalPadding >= bounds.Width)
                { 
                    bounds.Width = 0.0;
                } 
                else 
                {
                    bounds.X += padding.Left; 
                    bounds.Width -= totalPadding;
                }

                totalPadding = padding.Top + padding.Bottom; 
                if (totalPadding >= bounds.Height)
                { 
                    bounds.Height = 0.0; 
                }
                else 
                {
                    bounds.Y += padding.Top;
                    bounds.Height -= totalPadding;
                } 
            }
 
            if ((bounds.Width >= 1.0) && (bounds.Height >= 1.0)) 
            {
                bounds.X += 0.5; 
                bounds.Y += 0.5;
                bounds.Width -= 1.0;
                bounds.Height -= 1.0;
            } 

            switch (glyph) 
            { 
                case ScrollGlyph.LeftArrow:
                case ScrollGlyph.RightArrow: 
                case ScrollGlyph.HorizontalGripper:
                    if (bounds.Height >= 1.0)
                    {
                        bounds.Y += 1.0; 
                        bounds.Height -= 1.0;
                    } 
                    break; 

                case ScrollGlyph.UpArrow: 
                case ScrollGlyph.DownArrow:
                case ScrollGlyph.VerticalGripper:
                    if (bounds.Width >= 1.0)
                    { 
                        bounds.X += 1.0;
                        bounds.Width -= 1.0; 
                    } 
                    break;
            } 

            DrawShadow(drawingContext, ref bounds);
            DrawBorders(drawingContext, ref bounds);
            DrawGlyph(drawingContext, glyph, ref bounds); 
        }
 
        #endregion 

        #region Private Methods 



        private void DrawShadow(DrawingContext dc, ref Rect bounds) 
        {
            if ((bounds.Width > 0.0) && (bounds.Height > 2.0)) 
            { 
                Pen pen = Shadow;
                if (pen != null) 
                {
                    dc.DrawRoundedRectangle(
                        null,
                        pen, 
                        new Rect(bounds.X, bounds.Y + 2.0, bounds.Width, bounds.Height - 2.0),
                        3.0, 3.0); 
 
                    bounds.Height -= 1.0;
                    bounds.Width = Math.Max(0.0, bounds.Width - 1.0); 
                }
            }
        }
 
        private void DrawBorders(DrawingContext dc, ref Rect bounds)
        { 
            if ((bounds.Width >= 2.0) && (bounds.Height >= 2.0)) 
            {
                Brush brush = Fill; 
                Pen pen = OuterBorder;
                if (pen != null)
                {
                    dc.DrawRoundedRectangle( 
                        brush,
                        pen, 
                        new Rect(bounds.X, bounds.Y, bounds.Width, bounds.Height), 
                        2.0, 2.0);
                    brush = null; // Done with the fill 
                    bounds.Inflate(-1.0, -1.0);
                }

                if ((bounds.Width >= 2.0) && (bounds.Height >= 2.0)) 
                {
                    pen = InnerBorder; 
                    if ((pen != null) || (brush != null)) 
                    {
                        dc.DrawRoundedRectangle( 
                            brush,
                            pen,
                            new Rect(bounds.X, bounds.Y, bounds.Width, bounds.Height),
                            1.5, 1.5); 
                        bounds.Inflate(-1.0, -1.0);
                    } 
                } 
            }
        } 

        private void DrawGlyph(DrawingContext dc, ScrollGlyph glyph, ref Rect bounds)
        {
 
            if ((bounds.Width > 0.0) && (bounds.Height > 0.0))
            { 
                Brush brush = Glyph; 

                if ((brush != null) && (glyph != ScrollGlyph.None)) 
                {
                    switch (glyph)
                    {
                        case ScrollGlyph.HorizontalGripper: 
                            DrawHorizontalGripper(dc, brush, bounds);
                            break; 
 
                        case ScrollGlyph.VerticalGripper:
                            DrawVerticalGripper(dc, brush, bounds); 
                            break;

                        case ScrollGlyph.LeftArrow:
                        case ScrollGlyph.RightArrow: 
                        case ScrollGlyph.UpArrow:
                        case ScrollGlyph.DownArrow: 
                            DrawArrow(dc, brush, bounds, glyph); 
                            break;
                    } 
                }
            }
        }
 
        private void DrawHorizontalGripper(DrawingContext dc, Brush brush, Rect bounds)
        { 
            if ((bounds.Width > 8.0) && (bounds.Height > 2.0)) 
            {
                Brush glyphShadow = GlyphShadow; 

                double height = Math.Min(6.0, bounds.Height);
                double x = bounds.X + ((bounds.Width * 0.5) - 4.0);
                double y = bounds.Y + ((bounds.Height - height) * 0.5); 

                height -= 1.0; 
                for (int i = 0; i < 8; i += 2) 
                {
                    dc.DrawRectangle(brush, null, new Rect(x + i, y, 1.0, height)); 
                    if (glyphShadow != null)
                    {
                        dc.DrawRectangle(glyphShadow, null, new Rect(x + i + 1, y + 1, 1.0, height));
                    } 
                }
            } 
        } 

        private void DrawVerticalGripper(DrawingContext dc, Brush brush, Rect bounds) 
        {
            if ((bounds.Width > 2.0) && (bounds.Height > 8.0))
            {
                Brush glyphShadow = GlyphShadow; 

                double width = Math.Min(6.0, bounds.Width); 
                double x = bounds.X + ((bounds.Width - width) * 0.5); 
                double y = bounds.Y + ((bounds.Height * 0.5) - 4.0);
 
                width -= 1.0;
                for (int i = 0; i < 8; i += 2)
                {
                    dc.DrawRectangle(brush, null, new Rect(x, y + i, width, 1.0)); 
                    if (glyphShadow != null)
                    { 
                        dc.DrawRectangle(glyphShadow, null, new Rect(x + 1, y + i + 1, width, 1.0)); 
                    }
                } 
            }
        }

        #region Arrow Geometry Generation 

        // Geometries for arrows don't change so use static versions to reduce working set 
        private static object _glyphAccess = new object(); 
        private static Geometry _leftArrowGeometry;
        private static Geometry _rightArrowGeometry; 
        private static Geometry _upArrowGeometry;
        private static Geometry _downArrowGeometry;

        private static Geometry LeftArrowGeometry 
        {
            get 
            { 
                if (_leftArrowGeometry == null)
                { 
                    lock (_glyphAccess)
                    {
                        if (_leftArrowGeometry == null)
                        { 
                            PathFigure figure = new PathFigure();
                            figure.StartPoint = new Point(4.5, 0.0); 
                            figure.Segments.Add(new LineSegment(new Point(0.0, 4.5), true)); 
                            figure.Segments.Add(new LineSegment(new Point(4.5, 9.0), true));
                            figure.Segments.Add(new LineSegment(new Point(6.0, 7.5), true)); 
                            figure.Segments.Add(new LineSegment(new Point(3.0, 4.5), true));
                            figure.Segments.Add(new LineSegment(new Point(6.0, 1.5), true));
                            figure.IsClosed = true;
                            figure.Freeze(); 

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

                return _leftArrowGeometry; 
            } 
        }
 
        private static Geometry RightArrowGeometry
        {
            get
            { 
                if (_rightArrowGeometry == null)
                { 
                    lock (_glyphAccess) 
                    {
                        if (_rightArrowGeometry == null) 
                        {
                            PathFigure figure = new PathFigure();
                            figure.StartPoint = new Point(3.5, 0.0);
                            figure.Segments.Add(new LineSegment(new Point(8.0, 4.5), true)); 
                            figure.Segments.Add(new LineSegment(new Point(3.5, 9.0), true));
                            figure.Segments.Add(new LineSegment(new Point(2.0, 7.5), true)); 
                            figure.Segments.Add(new LineSegment(new Point(5.0, 4.5), true)); 
                            figure.Segments.Add(new LineSegment(new Point(2.0, 1.5), true));
                            figure.IsClosed = true; 
                            figure.Freeze();

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

                return _rightArrowGeometry;
            } 
        }
 
        private static Geometry UpArrowGeometry 
        {
            get 
            {
                if (_upArrowGeometry == null)
                {
                    lock (_glyphAccess) 
                    {
                        if (_upArrowGeometry == null) 
                        { 
                            PathFigure figure = new PathFigure();
                            figure.StartPoint = new Point(0.0, 4.5); 
                            figure.Segments.Add(new LineSegment(new Point(4.5, 0.0), true));
                            figure.Segments.Add(new LineSegment(new Point(9.0, 4.5), true));
                            figure.Segments.Add(new LineSegment(new Point(7.5, 6.0), true));
                            figure.Segments.Add(new LineSegment(new Point(4.5, 3.0), true)); 
                            figure.Segments.Add(new LineSegment(new Point(1.5, 6.0), true));
                            figure.IsClosed = true; 
                            figure.Freeze(); 

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

                            _upArrowGeometry = path; 
                        }
                    } 
                } 

                return _upArrowGeometry; 
            }
        }

        private static Geometry DownArrowGeometry 
        {
            get 
            { 
                if (_downArrowGeometry == null)
                { 
                    lock (_glyphAccess)
                    {
                        if (_downArrowGeometry == null)
                        { 
                            PathFigure figure = new PathFigure();
                            figure.StartPoint = new Point(0.0, 3.5); 
                            figure.Segments.Add(new LineSegment(new Point(4.5, 8.0), true)); 
                            figure.Segments.Add(new LineSegment(new Point(9.0, 3.5), true));
                            figure.Segments.Add(new LineSegment(new Point(7.5, 2.0), true)); 
                            figure.Segments.Add(new LineSegment(new Point(4.5, 5.0), true));
                            figure.Segments.Add(new LineSegment(new Point(1.5, 2.0), true));
                            figure.IsClosed = true;
                            figure.Freeze(); 

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

                return _downArrowGeometry; 
            } 
        }
 

        #endregion

        private void DrawArrow(DrawingContext dc, Brush brush, Rect bounds, ScrollGlyph glyph) 
        {
            if (_transform == null) 
            { 
                double glyphWidth = 9.0;
                double glyphHeight = 9.0; 
                switch (glyph)
                {
                    case ScrollGlyph.LeftArrow:
                    case ScrollGlyph.RightArrow: 
                        glyphWidth = 8.0;
                        break; 
 
                    case ScrollGlyph.UpArrow:
                    case ScrollGlyph.DownArrow: 
                        glyphHeight = 8.0;
                        break;
                }
                Matrix matrix = new Matrix(); 

                if ((bounds.Width < glyphWidth) || (bounds.Height < glyphHeight)) 
                { 
                    double widthScale = Math.Min(glyphWidth, bounds.Width) / glyphWidth;
                    double heightScale = Math.Min(glyphHeight, bounds.Height) / glyphHeight; 

                    double x = (bounds.X + (bounds.Width * 0.5)) / widthScale - (glyphWidth * 0.5);
                    double y = (bounds.Y + (bounds.Height * 0.5)) / heightScale - (glyphHeight * 0.5);
 
                    if (double.IsNaN(widthScale) || double.IsInfinity(widthScale) || double.IsNaN(heightScale) || double.IsInfinity(heightScale) ||
                        double.IsNaN(x) || double.IsInfinity(x) || double.IsNaN(y) || double.IsInfinity(y)) 
                    { 
                        return;
                    } 

                    matrix.Translate(x, y);
                    matrix.Scale(widthScale, heightScale);
                } 
                else
                { 
                    double x = bounds.X + (bounds.Width * 0.5) - (glyphWidth * 0.5); 
                    double y = bounds.Y + (bounds.Height * 0.5) - (glyphHeight * 0.5);
                    matrix.Translate(x, y); 
                }

                _transform = new MatrixTransform();
                _transform.Matrix = matrix; 
            }
 
            dc.PushTransform(_transform); 

            switch (glyph) 
            {
                case ScrollGlyph.LeftArrow:
                    dc.DrawGeometry(brush, null, LeftArrowGeometry);
                    break; 

                case ScrollGlyph.RightArrow: 
                    dc.DrawGeometry(brush, null, RightArrowGeometry); 
                    break;
 
                case ScrollGlyph.UpArrow:
                    dc.DrawGeometry(brush, null, UpArrowGeometry);
                    break;
 
                case ScrollGlyph.DownArrow:
                    dc.DrawGeometry(brush, null, DownArrowGeometry); 
                    break; 
            }
 
            dc.Pop(); // Center and scaling transform
        }

        // 
        //  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 static LinearGradientBrush CommonLineButtonFillNC 
        {
            get 
            {
                if (_commonLineButtonFillNC == null)
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonLineButtonFillNC == null) 
                        { 
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0); 
                            temp.EndPoint = new Point(1, 1);

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xE1, 0xEA, 0xFE), 0));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC3, 0xD3, 0xFD), 0.3)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC3, 0xD3, 0xFD), 0.6));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xBB, 0xCD, 0xF9), 1)); 
                            temp.Freeze(); 

                            _commonLineButtonFillNC = temp; 
                        }
                    }
                }
                return _commonLineButtonFillNC; 
            }
        } 
 
        private static LinearGradientBrush CommonVerticalFillNC
        { 
            get
            {
                if (_commonVerticalFillNC == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonVerticalFillNC == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(1, 0);

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC9, 0xD8, 0xFC), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC2, 0xD3, 0xFC), 0.65));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xB6, 0xCD, 0xFB), 1)); 
                            temp.Freeze(); 

                            _commonVerticalFillNC = temp; 
                        }
                    }
                }
                return _commonVerticalFillNC; 
            }
        } 
 
        private static LinearGradientBrush CommonHorizontalFillNC
        { 
            get
            {
                if (_commonHorizontalFillNC == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonHorizontalFillNC == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(0, 1);

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC9, 0xD8, 0xFC), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC2, 0xD3, 0xFC), 0.65));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xB6, 0xCD, 0xFB), 1)); 
                            temp.Freeze(); 

                            _commonHorizontalFillNC = temp; 
                        }
                    }
                }
                return _commonHorizontalFillNC; 
            }
        } 
 
        private static LinearGradientBrush CommonHoverLineButtonFillNC
        { 
            get
            {
                if (_commonHoverLineButtonFillNC == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonHoverLineButtonFillNC == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(1, 1);

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFD, 0xFF, 0xFF), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xE2, 0xF3, 0xFD), 0.25));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xB9, 0xDA, 0xFB), 1)); 
                            temp.Freeze(); 

                            _commonHoverLineButtonFillNC = temp; 
                        }
                    }
                }
                return _commonHoverLineButtonFillNC; 
            }
        } 
 
        private static LinearGradientBrush CommonHoverVerticalFillNC
        { 
            get
            {
                if (_commonHoverVerticalFillNC == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonHoverVerticalFillNC == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(1, 0);

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDA, 0xE9, 0xFF), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xD4, 0xE6, 0xFF), 0.65));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCA, 0xE0, 0xFF), 1)); 
                            temp.Freeze(); 

                            _commonHoverVerticalFillNC = temp; 
                        }
                    }
                }
                return _commonHoverVerticalFillNC; 
            }
        } 
 
        private static LinearGradientBrush CommonHoverHorizontalFillNC
        { 
            get
            {
                if (_commonHoverHorizontalFillNC == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonHoverHorizontalFillNC == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(0, 1);

 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDA, 0xE9, 0xFF), 0));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xD4, 0xE6, 0xFF), 0.65)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCA, 0xE0, 0xFF), 1)); 
                            temp.Freeze();
 
                            _commonHoverHorizontalFillNC = temp;
                        }
                    }
                } 
                return _commonHoverHorizontalFillNC;
            } 
        } 

        private static LinearGradientBrush CommonPressedLineButtonFillNC 
        {
            get
            {
                if (_commonPressedLineButtonFillNC == null) 
                {
                    lock (_resourceAccess) 
                    { 
                        if (_commonPressedLineButtonFillNC == null)
                        { 
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(1, 1);
 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x6E, 0x8E, 0xF1), 0));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x80, 0x9D, 0xF1), 0.3)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xAF, 0xBF, 0xED), 0.7)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xD2, 0xDE, 0xEB), 1));
                            temp.Freeze(); 

                            _commonPressedLineButtonFillNC = temp;
                        }
                    } 
                }
                return _commonPressedLineButtonFillNC; 
            } 
        }
 
        private static LinearGradientBrush CommonPressedVerticalFillNC
        {
            get
            { 
                if (_commonPressedVerticalFillNC == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonPressedVerticalFillNC == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(1, 0); 

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA8, 0xBE, 0xF5), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA1, 0xBD, 0xFA), 0.65)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x98, 0xB0, 0xEE), 1));
                            temp.Freeze(); 

                            _commonPressedVerticalFillNC = temp;
                        }
                    } 
                }
                return _commonPressedVerticalFillNC; 
            } 
        }
 
        private static LinearGradientBrush CommonPressedHorizontalFillNC
        {
            get
            { 
                if (_commonPressedHorizontalFillNC == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonPressedHorizontalFillNC == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(0, 1); 

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA8, 0xBE, 0xF5), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA1, 0xBD, 0xFA), 0.65)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x98, 0xB0, 0xEE), 1));
                            temp.Freeze(); 

                            _commonPressedHorizontalFillNC = temp;
                        }
                    } 
                }
                return _commonPressedHorizontalFillNC; 
            } 
        }
 
        private static LinearGradientBrush CommonVerticalFillHS
        {
            get
            { 
                if (_commonVerticalFillHS == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonVerticalFillHS == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(1, 0); 

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA2, 0xB3, 0x8D), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA5, 0xB7, 0x8E), 0.25)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA5, 0xB7, 0x8E), 0.4));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x95, 0xA7, 0x75), .82)); 
                            temp.Freeze();

                            _commonVerticalFillHS = temp;
                        } 
                    }
                } 
                return _commonVerticalFillHS; 
            }
        } 

        private static LinearGradientBrush CommonHorizontalFillHS
        {
            get 
            {
                if (_commonHorizontalFillHS == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonHorizontalFillHS == null)
                        {
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0); 
                            temp.EndPoint = new Point(0, 1);
 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA2, 0xB3, 0x8D), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA5, 0xB7, 0x8E), 0.25));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA5, 0xB7, 0x8E), 0.4)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x95, 0xA7, 0x75), .82));
                            temp.Freeze();

                            _commonHorizontalFillHS = temp; 
                        }
                    } 
                } 
                return _commonHorizontalFillHS;
            } 
        }

        private static LinearGradientBrush CommonHoverVerticalFillHS
        { 
            get
            { 
                if (_commonHoverVerticalFillHS == null) 
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonHoverVerticalFillHS == null)
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(1, 0); 
 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCA, 0xD7, 0xA7), 0));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCB, 0xD9, 0xA9), 0.25)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCB, 0xD9, 0xA9), 0.4));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC3, 0xD0, 0x96), .82));
                            temp.Freeze();
 
                            _commonHoverVerticalFillHS = temp;
                        } 
                    } 
                }
                return _commonHoverVerticalFillHS; 
            }
        }

 
        private static LinearGradientBrush CommonHoverHorizontalFillHS
        { 
            get 
            {
                if (_commonHoverHorizontalFillHS == null) 
                {
                    lock (_resourceAccess)
                    {
                        if (_commonHoverHorizontalFillHS == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0); 
                            temp.EndPoint = new Point(0, 1);
 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCA, 0xD7, 0xA7), 0));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCB, 0xD9, 0xA9), 0.25));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCB, 0xD9, 0xA9), 0.4));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC3, 0xD0, 0x96), .82)); 
                            temp.Freeze();
 
                            _commonHoverHorizontalFillHS = temp; 
                        }
                    } 
                }
                return _commonHoverHorizontalFillHS;
            }
        } 

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

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x92, 0xA4, 0x7A), 0));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x9A, 0xAD, 0x80), 0.25));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x9A, 0xAD, 0x80), 0.4)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x95, 0xAA, 0x72), 0.8));
                            temp.Freeze(); 
 
                            _commonPressedVerticalFillHS = temp;
                        } 
                    }
                }
                return _commonPressedVerticalFillHS;
            } 
        }
 
        private static LinearGradientBrush CommonPressedHorizontalFillHS 
        {
            get 
            {
                if (_commonPressedHorizontalFillHS == null)
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonPressedHorizontalFillHS == null) 
                        { 
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0); 
                            temp.EndPoint = new Point(0, 1);

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x92, 0xA4, 0x7A), 0));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x9A, 0xAD, 0x80), 0.25)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x9A, 0xAD, 0x80), 0.4));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x95, 0xAA, 0x72), 0.8)); 
                            temp.Freeze(); 

                            _commonPressedHorizontalFillHS = temp; 
                        }
                    }
                }
                return _commonPressedHorizontalFillHS; 
            }
        } 
 
        private static LinearGradientBrush CommonVerticalFillM
        { 
            get
            {
                if (_commonVerticalFillM == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonVerticalFillM == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0);
                            temp.EndPoint = new Point(1, 0);

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xE9, 0xE9, 0xEE), 0.25));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xE9, 0xE9, 0xEE), 0.4)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDB, 0xDB, 0xE6), 0.6)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC7, 0xC8, 0xD6), 0.9));
                            temp.Freeze(); 

                            _commonVerticalFillM = temp;
                        }
                    } 
                }
                return _commonVerticalFillM; 
            } 
        }
 
        private static LinearGradientBrush CommonHorizontalFillM
        {
            get
            { 
                if (_commonHorizontalFillM == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonHorizontalFillM == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0.5, 0);
                            temp.EndPoint = new Point(0.5, 1); 

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), 0)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xE9, 0xE9, 0xEE), 0.25)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xE9, 0xE9, 0xEE), 0.4));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDB, 0xDB, 0xE6), 0.6)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC7, 0xC8, 0xD6), 0.9));
                            temp.Freeze();

                            _commonHorizontalFillM = temp; 
                        }
                    } 
                } 
                return _commonHorizontalFillM;
            } 
        }


 
        private static LinearGradientBrush CommonHoverVerticalFillM
        { 
            get 
            {
                if (_commonHoverVerticalFillM == null) 
                {
                    lock (_resourceAccess)
                    {
                        if (_commonHoverVerticalFillM == null) 
                        {
                            LinearGradientBrush temp = new LinearGradientBrush(); 
                            temp.StartPoint = new Point(0, 0); 
                            temp.EndPoint = new Point(1, 0);
 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), 0.18));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xED, 0xF4), 0.3));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xED, 0xF4), 0.45));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDC, 0xDD, 0xE8), 0.6)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC3, 0xC5, 0xD6), 1));
                            temp.Freeze(); 
 
                            _commonHoverVerticalFillM = temp;
                        } 
                    }
                }
                return _commonHoverVerticalFillM;
            } 
        }
 
        private static LinearGradientBrush CommonHoverHorizontalFillM 
        {
            get 
            {
                if (_commonHoverHorizontalFillM == null)
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonHoverHorizontalFillM == null) 
                        { 
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0.5, 0); 
                            temp.EndPoint = new Point(0.5, 1);

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), 0.18));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xED, 0xF4), 0.3)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xED, 0xF4), 0.45));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDC, 0xDD, 0xE8), 0.6)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC3, 0xC5, 0xD6), 1)); 
                            temp.Freeze();
 
                            _commonHoverHorizontalFillM = temp;
                        }
                    }
                } 
                return _commonHoverHorizontalFillM;
            } 
        } 

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

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), 0.12)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC3, 0xC5, 0xD6), 0.12)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDC, 0xDD, 0xE8), 0.48));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xED, 0xF4), 0.58)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xED, 0xF4), 0.7));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), 0.9));
                            temp.Freeze();
 
                            _commonPressedVerticalFillM = temp;
                        } 
                    } 
                }
                return _commonPressedVerticalFillM; 
            }
        }

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

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), 0.12)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC3, 0xC5, 0xD6), 0.12));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDC, 0xDD, 0xE8), 0.48));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xED, 0xF4), 0.58));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xED, 0xF4), 0.7)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), 0.9));
                            temp.Freeze(); 
 
                            _commonPressedHorizontalFillM = temp;
                        } 
                    }
                }
                return _commonPressedHorizontalFillM;
            } 
        }
 
        private static LinearGradientBrush CommonDisabledFill 
        {
            get 
            {
                if (_commonDisabledFill == null)
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonDisabledFill == null) 
                        { 
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 0); 
                            temp.EndPoint = new Point(1, 1);

                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xF7, 0xF7, 0xF7), 0));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xF0, 0xF0, 0xF0), 0.3)); 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xEC, 0xEC), 0.6));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xE3, 0xE3, 0xE3), 1)); 
                            temp.Freeze(); 

                            _commonDisabledFill = temp; 
                        }
                    }
                }
                return _commonDisabledFill; 
            }
        } 
 

        private Brush Fill 
        {
            get
            {
                if (!IsEnabled) 
                    return CommonDisabledFill;
 
                ScrollGlyph glyph = ScrollGlyph; 
                ThemeColor themeColor = ThemeColor;
 
                if (glyph == ScrollGlyph.VerticalGripper)
                {
                    if (RenderPressed)
                    { 
                        if (themeColor == ThemeColor.NormalColor)
                            return CommonPressedVerticalFillNC; 
                        else if (themeColor == ThemeColor.Homestead) 
                            return CommonPressedVerticalFillHS;
                        else 
                            return CommonPressedVerticalFillM;
                    }

                    if (RenderMouseOver) 
                    {
                        if (themeColor == ThemeColor.NormalColor) 
                            return CommonHoverVerticalFillNC; 
                        else if (themeColor == ThemeColor.Homestead)
                            return CommonHoverVerticalFillHS; 
                        else
                            return CommonHoverVerticalFillM;
                    }
 
                    if (themeColor == ThemeColor.NormalColor)
                        return CommonVerticalFillNC; 
                    else if (themeColor == ThemeColor.Homestead) 
                        return CommonVerticalFillHS;
                    else 
                        return CommonVerticalFillM;
                }
                else if (glyph == ScrollGlyph.HorizontalGripper)
                { 
                    if (RenderPressed)
                    { 
                        if (themeColor == ThemeColor.NormalColor) 
                            return CommonPressedHorizontalFillNC;
                        else if (themeColor == ThemeColor.Homestead) 
                            return CommonPressedHorizontalFillHS;
                        else
                            return CommonPressedHorizontalFillM;
                    } 

                    if (RenderMouseOver) 
                    { 
                        if (themeColor == ThemeColor.NormalColor)
                            return CommonHoverHorizontalFillNC; 
                        else if (themeColor == ThemeColor.Homestead)
                            return CommonHoverHorizontalFillHS;
                        else
                            return CommonHoverHorizontalFillM; 
                    }
 
                    if (themeColor == ThemeColor.NormalColor) 
                        return CommonHorizontalFillNC;
                    else if (themeColor == ThemeColor.Homestead) 
                        return CommonHorizontalFillHS;
                    else
                        return CommonHorizontalFillM;
                } 
                else
                { 
                    if (RenderPressed) 
                    {
                        if (themeColor == ThemeColor.NormalColor) 
                            return CommonPressedLineButtonFillNC;
                        else if (themeColor == ThemeColor.Homestead)
                            return CommonPressedHorizontalFillHS;
                        else 
                            return CommonPressedHorizontalFillM;
                    } 
 
                    if (RenderMouseOver)
                    { 
                        if (themeColor == ThemeColor.NormalColor)
                            return CommonHoverLineButtonFillNC;
                        else if (themeColor == ThemeColor.Homestead)
                            return CommonHoverHorizontalFillHS; 
                        else
                            return CommonHoverHorizontalFillM; 
                    } 

                    if (themeColor == ThemeColor.NormalColor) 
                        return CommonLineButtonFillNC;
                    else if (themeColor == ThemeColor.Homestead)
                        return CommonHorizontalFillHS;
                    else 
                        return CommonHorizontalFillM;
                } 
            } 
        }
 

        private static SolidColorBrush CommonDisabledGlyph
        {
            get 
            {
                if (_commonDisabledGlyph == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonDisabledGlyph == null)
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xC9, 0xC9, 0xC2));
                            temp.Freeze(); 

                            _commonDisabledGlyph = temp; 
                        } 
                    }
                } 
                return _commonDisabledGlyph;
            }
        }
 
        private static SolidColorBrush CommonArrowGlyphNC
        { 
            get 
            {
                if (_commonArrowGlyphNC == null) 
                {
                    lock (_resourceAccess)
                    {
                        if (_commonArrowGlyphNC == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x4D, 0x61, 0x85)); 
                            temp.Freeze(); 

                            _commonArrowGlyphNC = temp; 
                        }
                    }
                }
                return _commonArrowGlyphNC; 
            }
        } 
 
        private static SolidColorBrush CommonArrowGlyphHS
        { 
            get
            {
                return Brushes.White;
            } 
        }
 
        private static SolidColorBrush CommonArrowGlyphM 
        {
            get 
            {
                if (_commonArrowGlyphM == null)
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonArrowGlyphM == null) 
                        { 
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x3F, 0x3D, 0x3D));
                            temp.Freeze(); 

                            _commonArrowGlyphM = temp;
                        }
                    } 
                }
                return _commonArrowGlyphM; 
            } 
        }
 
        private static SolidColorBrush CommonHoverArrowGlyphM
        {
            get
            { 
                if (_commonHoverArrowGlyphM == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonHoverArrowGlyphM == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x20, 0x20, 0x20));
                            temp.Freeze();
 
                            _commonHoverArrowGlyphM = temp;
                        } 
                    } 
                }
                return _commonHoverArrowGlyphM; 
            }
        }

        private static SolidColorBrush CommonGripperGlyphNC 
        {
            get 
            { 
                if (_commonGripperGlyphNC == null)
                { 
                    lock (_resourceAccess)
                    {
                        if (_commonGripperGlyphNC == null)
                        { 
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xEE, 0xF4, 0xFE));
                            temp.Freeze(); 
 
                            _commonGripperGlyphNC = temp;
                        } 
                    }
                }
                return _commonGripperGlyphNC;
            } 
        }
 
        private static SolidColorBrush CommonHoverGripperGlyphNC 
        {
            get 
            {
                if (_commonHoverGripperGlyphNC == null)
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonHoverGripperGlyphNC == null) 
                        { 
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xFC, 0xFD, 0xFF));
                            temp.Freeze(); 

                            _commonHoverGripperGlyphNC = temp;
                        }
                    } 
                }
                return _commonHoverGripperGlyphNC; 
            } 
        }
 
        private static SolidColorBrush CommonPressedGripperGlyphNC
        {
            get
            { 
                if (_commonPressedGripperGlyphNC == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonPressedGripperGlyphNC == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xCF, 0xDD, 0xFD));
                            temp.Freeze();
 
                            _commonPressedGripperGlyphNC = temp;
                        } 
                    } 
                }
                return _commonPressedGripperGlyphNC; 
            }
        }

        private static SolidColorBrush CommonGripperGlyphHS 
        {
            get 
            { 
                if (_commonGripperGlyphHS == null)
                { 
                    lock (_resourceAccess)
                    {
                        if (_commonGripperGlyphHS == null)
                        { 
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xD0, 0xDF, 0xAC));
                            temp.Freeze(); 
 
                            _commonGripperGlyphHS = temp;
                        } 
                    }
                }
                return _commonGripperGlyphHS;
            } 
        }
 
        private static SolidColorBrush CommonHoverGripperGlyphHS 
        {
            get 
            {
                if (_commonHoverGripperGlyphHS == null)
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonHoverGripperGlyphHS == null) 
                        { 
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xEB, 0xF5, 0xD4));
                            temp.Freeze(); 

                            _commonHoverGripperGlyphHS = temp;
                        }
                    } 
                }
                return _commonHoverGripperGlyphHS; 
            } 
        }
 
        private static SolidColorBrush CommonPressedGripperGlyphHS
        {
            get
            { 
                if (_commonPressedGripperGlyphHS == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonPressedGripperGlyphHS == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xB9, 0xD0, 0x97));
                            temp.Freeze();
 
                            _commonPressedGripperGlyphHS = temp;
                        } 
                    } 
                }
                return _commonPressedGripperGlyphHS; 
            }
        }

        private static SolidColorBrush CommonGripperGlyphM 
        {
            get 
            { 
                if (_commonGripperGlyphM == null)
                { 
                    lock (_resourceAccess)
                    {
                        if (_commonGripperGlyphM == null)
                        { 
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF));
                            temp.Freeze(); 
 
                            _commonGripperGlyphM = temp;
                        } 
                    }
                }
                return _commonGripperGlyphM;
            } 
        }
 
        private Brush Glyph 
        {
            get 
            {
                if (!IsEnabled)
                    return CommonDisabledGlyph;
 
                ThemeColor themeColor = ThemeColor;
                ScrollGlyph scrollGlyph = ScrollGlyph; 
 
                if (scrollGlyph == ScrollGlyph.HorizontalGripper || scrollGlyph == ScrollGlyph.VerticalGripper)
                { 
                    if (themeColor == ThemeColor.NormalColor)
                    {
                        if (RenderPressed)
                            return CommonPressedGripperGlyphNC; 
                        else if (RenderMouseOver)
                            return CommonHoverGripperGlyphNC; 
                        else 
                            return CommonGripperGlyphNC;
                    } 
                    else if (themeColor == ThemeColor.Homestead)
                    {
                        if (RenderPressed)
                            return CommonPressedGripperGlyphHS; 
                        else if (RenderMouseOver)
                            return CommonHoverGripperGlyphHS; 
                        else 
                            return CommonGripperGlyphHS;
                    } 
                    else
                    {
                        return CommonGripperGlyphM;
                    } 
                }
                else 
                { 
                    if (themeColor == ThemeColor.NormalColor)
                        return CommonArrowGlyphNC; 
                    else if (themeColor == ThemeColor.Homestead)
                        return CommonArrowGlyphHS;
                    else
                    { 
                        if (RenderMouseOver || RenderPressed)
                            return CommonHoverArrowGlyphM; 
                        else 
                            return CommonArrowGlyphM;
                    } 
                }
            }
        }
 

 
 
        private static SolidColorBrush CommonDisabledGripperGlyphShadow
        { 
            get
            {
                if (_commonDisabledGripperGlyphShadow == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonDisabledGripperGlyphShadow == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xB9, 0xB9, 0xB2)); 
                            temp.Freeze();

                            _commonDisabledGripperGlyphShadow = temp;
                        } 
                    }
                } 
                return _commonDisabledGripperGlyphShadow; 
            }
        } 

        private static SolidColorBrush CommonGripperGlyphShadowNC
        {
            get 
            {
                if (_commonGripperGlyphShadowNC == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonGripperGlyphShadowNC == null)
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x8C, 0xB0, 0xF8));
                            temp.Freeze(); 

                            _commonGripperGlyphShadowNC = temp; 
                        } 
                    }
                } 
                return _commonGripperGlyphShadowNC;
            }
        }
 
        private static SolidColorBrush CommonHoverGripperGlyphShadowNC
        { 
            get 
            {
                if (_commonHoverGripperGlyphShadowNC == null) 
                {
                    lock (_resourceAccess)
                    {
                        if (_commonHoverGripperGlyphShadowNC == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x9C, 0xC5, 0xFF)); 
                            temp.Freeze(); 

                            _commonHoverGripperGlyphShadowNC = temp; 
                        }
                    }
                }
                return _commonHoverGripperGlyphShadowNC; 
            }
        } 
 
        private static SolidColorBrush CommonPressedGripperGlyphShadowNC
        { 
            get
            {
                if (_commonPressedGripperGlyphShadowNC == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonPressedGripperGlyphShadowNC == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x83, 0x9E, 0xD8)); 
                            temp.Freeze();

                            _commonPressedGripperGlyphShadowNC = temp;
                        } 
                    }
                } 
                return _commonPressedGripperGlyphShadowNC; 
            }
        } 

        private static SolidColorBrush CommonGripperGlyphShadowHS
        {
            get 
            {
                if (_commonGripperGlyphShadowHS == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonGripperGlyphShadowHS == null)
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x8C, 0x9D, 0x73));
                            temp.Freeze(); 

                            _commonGripperGlyphShadowHS = temp; 
                        } 
                    }
                } 
                return _commonGripperGlyphShadowHS;
            }
        }
 
        private static SolidColorBrush CommonHoverGripperGlyphShadowHS
        { 
            get 
            {
                if (_commonHoverGripperGlyphShadowHS == null) 
                {
                    lock (_resourceAccess)
                    {
                        if (_commonHoverGripperGlyphShadowHS == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xB6, 0xC6, 0x8E)); 
                            temp.Freeze(); 

                            _commonHoverGripperGlyphShadowHS = temp; 
                        }
                    }
                }
                return _commonHoverGripperGlyphShadowHS; 
            }
        } 
 
        private static SolidColorBrush CommonPressedGripperGlyphShadowHS
        { 
            get
            {
                if (_commonPressedGripperGlyphShadowHS == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonPressedGripperGlyphShadowHS == null) 
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x7A, 0x8B, 0x63)); 
                            temp.Freeze();

                            _commonPressedGripperGlyphShadowHS = temp;
                        } 
                    }
                } 
                return _commonPressedGripperGlyphShadowHS; 
            }
        } 

        private static SolidColorBrush CommonGripperGlyphShadowM
        {
            get 
            {
                if (_commonGripperGlyphShadowM == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonGripperGlyphShadowM == null)
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x8E, 0x95, 0xA2));
                            temp.Freeze(); 

                            _commonGripperGlyphShadowM = temp; 
                        } 
                    }
                } 
                return _commonGripperGlyphShadowM;
            }
        }
 

        private Brush GlyphShadow 
        { 
            get
            { 
                ScrollGlyph scrollGlyph = ScrollGlyph;

                if (scrollGlyph == ScrollGlyph.HorizontalGripper || scrollGlyph == ScrollGlyph.VerticalGripper)
                { 
                    if (!IsEnabled)
                        return CommonDisabledGripperGlyphShadow; 
 
                    ThemeColor themeColor = ThemeColor;
 
                    if (themeColor == ThemeColor.NormalColor)
                    {
                        if (RenderPressed)
                            return CommonPressedGripperGlyphShadowNC; 
                        else if (RenderMouseOver)
                            return CommonHoverGripperGlyphShadowNC; 
                        else 
                            return CommonGripperGlyphShadowNC;
                    } 
                    else if (themeColor == ThemeColor.Homestead)
                    {
                        if (RenderPressed)
                            return CommonPressedGripperGlyphShadowHS; 
                        else if (RenderMouseOver)
                            return CommonHoverGripperGlyphShadowHS; 
                        else 
                            return CommonGripperGlyphShadowHS;
                    } 
                    else
                    {
                        return CommonGripperGlyphShadowM;
                    } 
                }
                return null; 
            } 
        }
 
        private static Pen CommonOuterBorderPenNC
        {
            get
            { 
                if (_commonOuterBorderPenNC == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonOuterBorderPenNC == null) 
                        {
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF));
                            temp.Freeze(); 

                            _commonOuterBorderPenNC = temp; 
                        } 
                    }
                } 
                return _commonOuterBorderPenNC;
            }
        }
 
        private static Pen CommonOuterBorderPenHS
        { 
            get 
            {
                if (_commonOuterBorderPenHS == null) 
                {
                    lock (_resourceAccess)
                    {
                        if (_commonOuterBorderPenHS == null) 
                        {
                            Pen temp = new Pen(); 
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF)); 
                            temp.Freeze();
 
                            _commonOuterBorderPenHS = temp;
                        }
                    }
                } 
                return _commonOuterBorderPenHS;
            } 
        } 

        private static Pen CommonOuterBorderPenM 
        {
            get
            {
                if (_commonOuterBorderPenM == null) 
                {
                    lock (_resourceAccess) 
                    { 
                        if (_commonOuterBorderPenM == null)
                        { 
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0x94, 0x95, 0xA2));
                            temp.Freeze();
 
                            _commonOuterBorderPenM = temp;
                        } 
                    } 
                }
                return _commonOuterBorderPenM; 
            }
        }

        private static Pen CommonHoverOuterBorderPenM 
        {
            get 
            { 
                if (_commonHoverOuterBorderPenM == null)
                { 
                    lock (_resourceAccess)
                    {
                        if (_commonHoverOuterBorderPenM == null)
                        { 
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0x5B, 0x66, 0x65)); 
                            temp.Freeze(); 

                            _commonHoverOuterBorderPenM = temp; 
                        }
                    }
                }
                return _commonHoverOuterBorderPenM; 
            }
        } 
 
        private static Pen CommonPressedOuterBorderPenM
        { 
            get
            {
                if (_commonPressedOuterBorderPenM == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonPressedOuterBorderPenM == null) 
                        {
                            Pen temp = new Pen(); 
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0x43, 0x48, 0x48));
                            temp.Freeze();

                            _commonPressedOuterBorderPenM = temp; 
                        }
                    } 
                } 
                return _commonPressedOuterBorderPenM;
            } 
        }


        private Pen OuterBorder 
        {
            get 
            { 
                ThemeColor themeColor = ThemeColor;
 
                if (themeColor == ThemeColor.Metallic)
                {
                    ScrollGlyph glyph = ScrollGlyph;
                    if (!IsEnabled) 
                        return CommonOuterBorderPenNC;
                    else if (RenderPressed && (glyph == ScrollGlyph.HorizontalGripper || glyph == ScrollGlyph.VerticalGripper) ) 
                        return CommonPressedOuterBorderPenM; 
                    else if (RenderPressed || RenderMouseOver)
                        return CommonHoverOuterBorderPenM; 
                    else
                        return CommonOuterBorderPenM;
                }
                else 
                {
                    if (HasOuterBorder) 
                    { 
                        if (themeColor == ThemeColor.NormalColor)
                            return CommonOuterBorderPenNC; 
                        else // themeColor == ThemeColor.Homestead
                            return CommonOuterBorderPenHS;
                    }
                    else 
                        return null;
                } 
            } 
        }
 

        private static Pen CommonDisabledInnerBorderPen
        {
            get 
            {
                if (_commonDisabledInnerBorderPen == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonDisabledInnerBorderPen == null)
                        {
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xE8, 0xE8, 0xDF)); 
                            temp.Freeze();
 
                            _commonDisabledInnerBorderPen = temp; 
                        }
                    } 
                }
                return _commonDisabledInnerBorderPen;
            }
        } 

        private static Pen CommonInnerBorderPenNC 
        { 
            get
            { 
                if (_commonInnerBorderPenNC == null)
                {
                    lock (_resourceAccess)
                    { 
                        if (_commonInnerBorderPenNC == null)
                        { 
                            Pen temp = new Pen(); 
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xB4, 0xC8, 0xF6));
                            temp.Freeze(); 

                            _commonInnerBorderPenNC = temp;
                        }
                    } 
                }
                return _commonInnerBorderPenNC; 
            } 
        }
 


        private static Pen CommonHoverInnerBorderPenNC
        { 
            get
            { 
                if (_commonHoverInnerBorderPenNC == null) 
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonHoverInnerBorderPenNC == null)
                        {
                            Pen temp = new Pen(); 
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0x98, 0xB1, 0xE4));
                            temp.Freeze(); 
 
                            _commonHoverInnerBorderPenNC = temp;
                        } 
                    }
                }
                return _commonHoverInnerBorderPenNC;
            } 
        }
 
        private static Pen CommonHoverThumbInnerBorderPenNC 
        {
            get 
            {
                if (_commonHoverThumbInnerBorderPenNC == null)
                {
                    lock (_resourceAccess) 
                    {
                        if (_commonHoverThumbInnerBorderPenNC == null) 
                        { 
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xAC, 0xCE, 0xFF)); 
                            temp.Freeze();

                            _commonHoverThumbInnerBorderPenNC = temp;
                        } 
                    }
                } 
                return _commonHoverThumbInnerBorderPenNC; 
            }
        } 

        private static Pen CommonPressedInnerBorderPenNC
        {
            get 
            {
                if (_commonPressedInnerBorderPenNC == null) 
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonPressedInnerBorderPenNC == null)
                        {
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0x83, 0x8F, 0xDA)); 
                            temp.Freeze();
 
                            _commonPressedInnerBorderPenNC = temp; 
                        }
                    } 
                }
                return _commonPressedInnerBorderPenNC;
            }
        } 

        private static Pen CommonInnerBorderPenHS 
        { 
            get
            { 
                if (_commonInnerBorderPenHS == null)
                {
                    lock (_resourceAccess)
                    { 
                        if (_commonInnerBorderPenHS == null)
                        { 
                            Pen temp = new Pen(); 
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0x8E, 0x99, 0x7D));
                            temp.Freeze(); 

                            _commonInnerBorderPenHS = temp;
                        }
                    } 
                }
                return _commonInnerBorderPenHS; 
            } 
        }
 
        private static Pen CommonHoverInnerBorderPenHS
        {
            get
            { 
                if (_commonHoverInnerBorderPenHS == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonHoverInnerBorderPenHS == null) 
                        {
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xBD, 0xCB, 0x96));
                            temp.Freeze(); 

                            _commonHoverInnerBorderPenHS = temp; 
                        } 
                    }
                } 
                return _commonHoverInnerBorderPenHS;
            }
        }
 

        private static Pen CommonPressedInnerBorderPenHS 
        { 
            get
            { 
                if (_commonPressedInnerBorderPenHS == null)
                {
                    lock (_resourceAccess)
                    { 
                        if (_commonPressedInnerBorderPenHS == null)
                        { 
                            Pen temp = new Pen(); 
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0x7A, 0x8B, 0x63));
                            temp.Freeze(); 

                            _commonPressedInnerBorderPenHS = temp;
                        }
                    } 
                }
                return _commonPressedInnerBorderPenHS; 
            } 
        }
 
        private static Pen CommonInnerBorderPenM
        {
            get
            { 
                if (_commonInnerBorderPenM == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonInnerBorderPenM == null) 
                        {
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF));
                            temp.Freeze(); 

                            _commonInnerBorderPenM = temp; 
                        } 
                    }
                } 
                return _commonInnerBorderPenM;
            }
        }
 
        private static Pen CommonHoverInnerBorderPenM
        { 
            get 
            {
                if (_commonHoverInnerBorderPenM == null) 
                {
                    lock (_resourceAccess)
                    {
                        if (_commonHoverInnerBorderPenM == null) 
                        {
                            Pen temp = new Pen(); 
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF)); 
                            temp.Freeze();
 
                            _commonHoverInnerBorderPenM = temp;
                        }
                    }
                } 
                return _commonHoverInnerBorderPenM;
            } 
        } 

 
        private static Pen CommonPressedInnerBorderPenM
        {
            get
            { 
                if (_commonPressedInnerBorderPenM == null)
                { 
                    lock (_resourceAccess) 
                    {
                        if (_commonPressedInnerBorderPenM == null) 
                        {
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF));
                            temp.Freeze(); 

                            _commonPressedInnerBorderPenM = temp; 
                        } 
                    }
                } 
                return _commonPressedInnerBorderPenM;
            }
        }
 

 
        private Pen InnerBorder 
        {
            get 
            {
                ScrollGlyph scrollGlyph = ScrollGlyph;

 
                if (!IsEnabled)
                    return CommonDisabledInnerBorderPen; 
 
                ThemeColor themeColor = ThemeColor;
 
                if (RenderPressed)
                {
                    if (themeColor == ThemeColor.NormalColor)
                        return CommonPressedInnerBorderPenNC; 
                    else if (themeColor == ThemeColor.Homestead)
                        return CommonPressedInnerBorderPenHS; 
                    else 
                        return CommonPressedInnerBorderPenM;
                } 

                if (RenderMouseOver)
                {
                    if (themeColor == ThemeColor.NormalColor) 
                    {
                        if (scrollGlyph == ScrollGlyph.HorizontalGripper || scrollGlyph == ScrollGlyph.VerticalGripper) 
                            return CommonHoverThumbInnerBorderPenNC; 
                        else
                            return CommonHoverInnerBorderPenNC; 
                    }
                    else if (themeColor == ThemeColor.Homestead)
                        return CommonHoverInnerBorderPenHS;
                    else 
                        return CommonHoverInnerBorderPenM;
                } 
 
                if (themeColor == ThemeColor.NormalColor)
                    return CommonInnerBorderPenNC; 
                else if (themeColor == ThemeColor.Homestead)
                    return CommonInnerBorderPenHS;
                else
                    return CommonInnerBorderPenM; 
            }
        } 
 
        private static Pen CommonDisabledShadowPen
        { 
            get
            {
                if (_commonDisabledShadowPen == null)
                { 
                    lock (_resourceAccess)
                    { 
                        if (_commonDisabledShadowPen == null) 
                        {
                            Pen temp = new Pen(); 

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

                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0x00, 0xCC, 0xCC, 0xBA), 0)); 
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCC, 0xCC, 0xBA), 0.5)); 
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC4, 0xC4, 0xAF), 1));
                            brush.Freeze(); 

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

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

                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0x00, 0xA0, 0xB5, 0xD3), 0));
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xA0, 0xB5, 0xD3), 0.5));
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x7C, 0x9F, 0xD3), 1)); 
                            brush.Freeze();
 
                            temp.Brush = brush; 
                            temp.Freeze();
 
                            _commonShadowPenNC = temp;
                        }
                    }
                } 
                return _commonShadowPenNC;
            } 
        } 

        private static Pen CommonShadowPenHS 
        {
            get
            {
                if (_commonShadowPenHS == null) 
                {
                    lock (_resourceAccess) 
                    { 
                        if (_commonShadowPenHS == null)
                        { 
                            Pen temp = new Pen();

                            LinearGradientBrush brush = new LinearGradientBrush();
                            brush.StartPoint = new Point(0, 0); 
                            brush.EndPoint = new Point(0, 1);
 
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0x00, 0xB6, 0xC1, 0xA6), 0)); 
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x9B, 0xB1, 0x81), 0.5));
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x8B, 0x93, 0x77), 1)); 
                            brush.Freeze();

                            temp.Brush = brush;
                            temp.Freeze(); 

                            _commonShadowPenHS = temp; 
                        } 
                    }
                } 
                return _commonShadowPenHS;
            }
        }
 
        private Pen Shadow
        { 
            get 
            {
                if (HasOuterBorder) 
                {
                    if (!IsEnabled)
                        return CommonDisabledShadowPen;
 
                    ThemeColor themeColor = ThemeColor;
 
                    if (themeColor == ThemeColor.NormalColor) 
                        return CommonShadowPenNC;
                    else if (themeColor == ThemeColor.Homestead) 
                        return CommonShadowPenHS;
                    else
                        return null;
                } 
                return null;
            } 
        } 

        #endregion 

        #region Data

        private static LinearGradientBrush _commonLineButtonFillNC; 
        private static LinearGradientBrush _commonVerticalFillNC;
        private static LinearGradientBrush _commonHorizontalFillNC; 
 
        private static LinearGradientBrush _commonVerticalFillHS;
        private static LinearGradientBrush _commonHorizontalFillHS; 

        private static LinearGradientBrush _commonVerticalFillM;
        private static LinearGradientBrush _commonHorizontalFillM;
 

        private static LinearGradientBrush _commonHoverLineButtonFillNC; 
        private static LinearGradientBrush _commonHoverVerticalFillNC; 
        private static LinearGradientBrush _commonHoverHorizontalFillNC;
 
        private static LinearGradientBrush _commonHoverVerticalFillHS;
        private static LinearGradientBrush _commonHoverHorizontalFillHS;

        private static LinearGradientBrush _commonHoverVerticalFillM; 
        private static LinearGradientBrush _commonHoverHorizontalFillM;
 
 
        private static LinearGradientBrush _commonPressedLineButtonFillNC;
        private static LinearGradientBrush _commonPressedVerticalFillNC; 
        private static LinearGradientBrush _commonPressedHorizontalFillNC;

        private static LinearGradientBrush _commonPressedVerticalFillHS;
        private static LinearGradientBrush _commonPressedHorizontalFillHS; 

        private static LinearGradientBrush _commonPressedVerticalFillM; 
        private static LinearGradientBrush _commonPressedHorizontalFillM; 

        private static LinearGradientBrush _commonDisabledFill; 


        private static SolidColorBrush _commonDisabledGlyph;
 
        private static SolidColorBrush _commonArrowGlyphNC;
        private static SolidColorBrush _commonArrowGlyphM; 
 
        private static SolidColorBrush _commonHoverArrowGlyphM;
 
        private static SolidColorBrush _commonGripperGlyphNC;
        private static SolidColorBrush _commonHoverGripperGlyphNC;
        private static SolidColorBrush _commonPressedGripperGlyphNC;
 
        private static SolidColorBrush _commonGripperGlyphHS;
        private static SolidColorBrush _commonHoverGripperGlyphHS; 
        private static SolidColorBrush _commonPressedGripperGlyphHS; 

        private static SolidColorBrush _commonGripperGlyphM; 

        private static SolidColorBrush _commonDisabledGripperGlyphShadow;

        private static SolidColorBrush _commonGripperGlyphShadowNC; 
        private static SolidColorBrush _commonHoverGripperGlyphShadowNC;
        private static SolidColorBrush _commonPressedGripperGlyphShadowNC; 
 
        private static SolidColorBrush _commonGripperGlyphShadowHS;
        private static SolidColorBrush _commonHoverGripperGlyphShadowHS; 
        private static SolidColorBrush _commonPressedGripperGlyphShadowHS;

        private static SolidColorBrush _commonGripperGlyphShadowM;
 
        private static Pen _commonOuterBorderPenNC;
 
        private static Pen _commonOuterBorderPenHS; 

        private static Pen _commonOuterBorderPenM; 
        private static Pen _commonHoverOuterBorderPenM;
        private static Pen _commonPressedOuterBorderPenM;

 
        private static Pen _commonDisabledInnerBorderPen;
 
        private static Pen _commonInnerBorderPenNC; 
        private static Pen _commonInnerBorderPenHS;
        private static Pen _commonInnerBorderPenM; 

        private static Pen _commonHoverInnerBorderPenNC;
        private static Pen _commonHoverThumbInnerBorderPenNC;
 
        private static Pen _commonHoverInnerBorderPenHS;
        private static Pen _commonHoverInnerBorderPenM; 
 
        private static Pen _commonPressedInnerBorderPenNC;
        private static Pen _commonPressedInnerBorderPenHS; 
        private static Pen _commonPressedInnerBorderPenM;

        private static Pen _commonDisabledShadowPen;
 
        private static Pen _commonShadowPenNC;
        private static Pen _commonShadowPenHS; 
 

        private static object _resourceAccess = new object(); 


        private MatrixTransform _transform;
 
        #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