File: Microsoft\Windows\Themes\ScrollChrome.cs
Project: wpf\src\Themes\Royale\PresentationFramework.Royale.csproj (PresentationFramework.Royale)
//---------------------------------------------------------------------------
// 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
{
    /// <summary>
    ///     The ScrollChrome element
    ///     This element is a theme-specific type that is used as an optimization
    ///     for a common complex rendering used in Luna
    /// </summary>
    public sealed class ScrollChrome : FrameworkElement
    {
 
        #region Constructors
 
        static ScrollChrome()
        {
            IsEnabledProperty.OverrideMetadata(typeof(ScrollChrome), new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.AffectsRender));
        }
 
        /// <summary>
        ///     Instantiates a new instance of a ScrollChrome with no parent element.
        /// </summary>
        public ScrollChrome()
        {
        }
 
        #endregion Constructors
 
        #region Dynamic Properties
 
        /// <summary>
        /// DependencyProperty for <see cref="HasOuterBorder" /> property.
        /// </summary>
        public static readonly DependencyProperty HasOuterBorderProperty =
                 DependencyProperty.Register("HasOuterBorder",
                         typeof(bool),
                         typeof(ScrollChrome),
                         new FrameworkPropertyMetadata(
                                true,
                                FrameworkPropertyMetadataOptions.AffectsRender));
 
        /// <summary>
        /// When true the chrome renders with a white outer border.
        /// </summary>
        public bool HasOuterBorder
        {
            get { return (bool)GetValue(HasOuterBorderProperty); }
            set { SetValue(HasOuterBorderProperty, value); }
        }
 
 
        /// <summary>
        ///     Attached DependencyProperty to assign the orientation and type of the glyph
        /// </summary>
        public static readonly DependencyProperty ScrollGlyphProperty =
                DependencyProperty.RegisterAttached(
                        "ScrollGlyph",
                        typeof(ScrollGlyph),
                        typeof(ScrollChrome),
                        new FrameworkPropertyMetadata(
                                ScrollGlyph.None,
                                FrameworkPropertyMetadataOptions.AffectsRender),
                        new ValidateValueCallback(IsValidScrollGlyph));
 
        /// <summary>
        ///     Gets the value of the ScrollGlyph property on the object.
        /// </summary>
        /// <param name="element">The object to which the property is attached.</param>
        /// <returns>The value of the property.</returns>
        public static ScrollGlyph GetScrollGlyph(DependencyObject element)
        {
            if (element == null) { throw new ArgumentNullException("element"); }
 
            return (ScrollGlyph)element.GetValue(ScrollGlyphProperty);
        }
 
        /// <summary>
        ///     Attachs the value to the object.
        /// </summary>
        /// <param name="element">The object on which the value will be attached.</param>
        /// <param name="value">The value to attach.</param>
        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;
        }
 
        /// <summary>
        ///     DependencyProperty for <see cref="Padding" /> property.
        /// </summary>
        public static readonly DependencyProperty PaddingProperty = Control.PaddingProperty.AddOwner(typeof(ScrollChrome));
 
        /// <summary>
        ///     Insets the border of the element.
        /// </summary>
        public Thickness Padding
        {
            get { return (Thickness) GetValue(PaddingProperty); }
            set { SetValue(PaddingProperty, value); }
        }
 
        /// <summary>
        /// DependencyProperty for <see cref="RenderMouseOver" /> property.
        /// </summary>
        public static readonly DependencyProperty RenderMouseOverProperty
            = ButtonChrome.RenderMouseOverProperty.AddOwner(typeof(ScrollChrome),
                                new FrameworkPropertyMetadata(
                                false,
                                FrameworkPropertyMetadataOptions.AffectsRender));
 
        /// <summary>
        /// When true the chrome renders with a mouse over look.
        /// </summary>
        public bool RenderMouseOver
        {
            get { return (bool)GetValue(RenderMouseOverProperty); }
            set { SetValue(RenderMouseOverProperty, value); }
        }
 
 
        /// <summary>
        /// DependencyProperty for <see cref="RenderPressed" /> property.
        /// </summary>
        public static readonly DependencyProperty RenderPressedProperty
            = ButtonChrome.RenderPressedProperty.AddOwner(typeof(ScrollChrome),
                                new FrameworkPropertyMetadata(
                                false,
                                FrameworkPropertyMetadataOptions.AffectsRender));
 
        /// <summary>
        /// When true the chrome renders with a pressed look.
        /// </summary>
        public bool RenderPressed
        {
            get { return (bool)GetValue(RenderPressedProperty); }
            set { SetValue(RenderPressedProperty, value); }
        }
 
        #endregion Dynamic Properties
 
        #region Protected Methods
 
        /// <summary>
        ///     Updates DesiredSize of the ScrollChrome.  Called by parent UIElement.  This is the first pass of layout.
        /// </summary>
        /// <remarks>
        ///     ScrollChrome basically constrains the value of its Width and Height properties.
        /// </remarks>
        /// <param name="availableSize">Available size is an "upper limit" that the return value should not exceed.</param>
        /// <returns>The ScrollChrome's desired size.</returns>
        protected override Size MeasureOverride(Size availableSize)
        {
            _transform = null;
 
            return new Size(0,0);
        }
 
        /// <summary>
        ///     ScrollChrome does no work here and returns arrangeSize.
        /// </summary>
        /// <param name="finalSize">Size the ContentPresenter will assume.</param>
        protected override Size ArrangeOverride(Size finalSize)
        {
            _transform = null;
            return finalSize;
        }
 
        /// <summary>
        /// Render callback.
        /// Note: Assumes all borders are 1 unit.
        /// </summary>
        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;
            }
 
            DrawBorders(drawingContext, ref bounds);
            DrawGlyph(drawingContext, glyph, ref bounds);
        }
 
        #endregion
 
        #region Private Methods
 
        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 CommonVerticalFill
        {
            get
            {
                if (_commonVerticalFill == null)
                {
                    lock (_resourceAccess)
                    {
                        if (_commonVerticalFill == 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, 0xBD, 0xD1, 0xE9), 0.8));
                            temp.Freeze();
 
                            _commonVerticalFill = temp;
                        }
                    }
                }
                return _commonVerticalFill;
            }
        }
 
        private static LinearGradientBrush CommonHorizontalFill
        {
            get
            {
                if (_commonHorizontalFill == null)
                {
                    lock (_resourceAccess)
                    {
                        if (_commonHorizontalFill == 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, 0xC1, 0xD5, 0xED), 0.7));
                            temp.Freeze();
 
                            _commonHorizontalFill = temp;
                        }
                    }
                }
                return _commonHorizontalFill;
            }
        }
 
 
        private static LinearGradientBrush CommonHoverVerticalFill
        {
            get
            {
                if (_commonHoverVerticalFill == null)
                {
                    lock (_resourceAccess)
                    {
                        if (_commonHoverVerticalFill == 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.2));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xBD, 0xD1, 0xE9), 1));
                            temp.Freeze();
 
                            _commonHoverVerticalFill = temp;
                        }
                    }
                }
                return _commonHoverVerticalFill;
            }
        }
 
        private static LinearGradientBrush CommonHoverHorizontalFill
        {
            get
            {
                if (_commonHoverHorizontalFill == null)
                {
                    lock (_resourceAccess)
                    {
                        if (_commonHoverHorizontalFill == 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.3));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC1, 0xD5, 0xED), 1));
                            temp.Freeze();
 
                            _commonHoverHorizontalFill = temp;
                        }
                    }
                }
                return _commonHoverHorizontalFill;
            }
        }
 
        private static LinearGradientBrush CommonPressedVerticalFill
        {
            get
            {
                if (_commonPressedVerticalFill == null)
                {
                    lock (_resourceAccess)
                    {
                        if (_commonPressedVerticalFill == null)
                        {
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(1, 0);
                            temp.EndPoint = new Point(0, 0);
 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), 0.2));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC1, 0xD5, 0xED), 0.7));
                            temp.Freeze();
 
                            _commonPressedVerticalFill = temp;
                        }
                    }
                }
                return _commonPressedVerticalFill;
            }
        }
 
        private static LinearGradientBrush CommonPressedHorizontalFill
        {
            get
            {
                if (_commonPressedHorizontalFill == null)
                {
                    lock (_resourceAccess)
                    {
                        if (_commonPressedHorizontalFill == null)
                        {
                            LinearGradientBrush temp = new LinearGradientBrush();
                            temp.StartPoint = new Point(0, 1);
                            temp.EndPoint = new Point(0, 0);
 
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF), 0.3));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC1, 0xD5, 0xED), 0.7));
                            temp.Freeze();
 
                            _commonPressedHorizontalFill = temp;
                        }
                    }
                }
                return _commonPressedHorizontalFill;
            }
        }
 
        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, 0xF2, 0xF7, 0xFF), 0));
                            temp.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xD5, 0xE7, 0xFF), 1));
                            temp.Freeze();
 
                            _commonDisabledFill = temp;
                        }
                    }
                }
                return _commonDisabledFill;
            }
        }
 
 
        private Brush Fill
        {
            get
            {
                if (!IsEnabled)
                    return CommonDisabledFill;
 
                if (RenderPressed)
                {
                    if (ScrollGlyph == ScrollGlyph.VerticalGripper)
                        return CommonPressedVerticalFill;
                    else
                        return CommonPressedHorizontalFill;
                }
 
                if (RenderMouseOver)
                {
                    if (ScrollGlyph == ScrollGlyph.VerticalGripper)
                        return CommonHoverVerticalFill;
                    else
                        return CommonHoverHorizontalFill;
                }
 
                if (ScrollGlyph == ScrollGlyph.VerticalGripper)
                    return CommonVerticalFill;
                else
                    return CommonHorizontalFill;
            }
        }
 
 
        private static SolidColorBrush CommonDisabledGlyph
        {
            get
            {
                if (_commonDisabledGlyph == null)
                {
                    lock (_resourceAccess)
                    {
                        if (_commonDisabledGlyph == null)
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xB7, 0xCB, 0xE3));
                            temp.Freeze();
 
                            _commonDisabledGlyph = temp;
                        }
                    }
                }
                return _commonDisabledGlyph;
            }
        }
 
 
        private static SolidColorBrush CommonArrowGlyph
        {
            get
            {
                if (_commonArrowGlyph == null)
                {
                    lock (_resourceAccess)
                    {
                        if (_commonArrowGlyph == null)
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x5B, 0x64, 0x73));
                            temp.Freeze();
 
                            _commonArrowGlyph = temp;
                        }
                    }
                }
                return _commonArrowGlyph;
            }
        }
 
        private static SolidColorBrush CommonHoverArrowGlyph
        {
            get
            {
                if (_commonHoverArrowGlyph == null)
                {
                    lock (_resourceAccess)
                    {
                        if (_commonHoverArrowGlyph == null)
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x6B, 0x7B, 0x84));
                            temp.Freeze();
 
                            _commonHoverArrowGlyph = temp;
                        }
                    }
                }
                return _commonHoverArrowGlyph;
            }
        }
 
        private static SolidColorBrush CommonGripperGlyph
        {
            get
            {
                if (_commonGripperGlyph == null)
                {
                    lock (_resourceAccess)
                    {
                        if (_commonGripperGlyph == null)
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF));
                            temp.Freeze();
 
                            _commonGripperGlyph = temp;
                        }
                    }
                }
                return _commonGripperGlyph;
            }
        }
 
        private Brush Glyph
        {
            get
            {
                if (!IsEnabled)
                    return CommonDisabledGlyph;
 
                ScrollGlyph scrollGlyph = ScrollGlyph;
 
                if (scrollGlyph == ScrollGlyph.HorizontalGripper || scrollGlyph == ScrollGlyph.VerticalGripper)
                {
                    return CommonGripperGlyph;
                }
                else
                {
                    if (RenderMouseOver || RenderPressed)
                        return CommonHoverArrowGlyph;
                    else
                        return CommonArrowGlyph;
                }
            }
        }
 
 
 
 
        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 CommonGripperGlyphShadow
        {
            get
            {
                if (_commonGripperGlyphShadow == null)
                {
                    lock (_resourceAccess)
                    {
                        if (_commonGripperGlyphShadow == null)
                        {
                            SolidColorBrush temp = new SolidColorBrush(Color.FromArgb(0xFF, 0x83, 0x97, 0xAF));
                            temp.Freeze();
 
                            _commonGripperGlyphShadow = temp;
                        }
                    }
                }
                return _commonGripperGlyphShadow;
            }
        }
 
        private Brush GlyphShadow
        {
            get
            {
                ScrollGlyph scrollGlyph = ScrollGlyph;
 
                if (scrollGlyph == ScrollGlyph.HorizontalGripper || scrollGlyph == ScrollGlyph.VerticalGripper)
                {
                    if (!IsEnabled)
                        return CommonDisabledGripperGlyphShadow;
 
                    return CommonGripperGlyphShadow;
                }
                return null;
            }
        }
 
        private static Pen CommonDisabledOuterBorderPen
        {
            get
            {
                if (_commonDisabledOuterBorderPen == null)
                {
                    lock (_resourceAccess)
                    {
                        if (_commonDisabledOuterBorderPen == null)
                        {
                            Pen temp = new Pen();
 
                            LinearGradientBrush brush = new LinearGradientBrush();
                            brush.StartPoint = new Point(0, 0);
                            brush.EndPoint = new Point(1, 1);
 
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xE1, 0xEE, 0xFF), 0.5));
                            brush.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xB1, 0xC5, 0xDD), 1));
                           
                            temp.Brush = brush;
                            temp.Freeze();
 
                            _commonDisabledOuterBorderPen = temp;
                        }
                    }
                }
                return _commonDisabledOuterBorderPen;
            }
        }
 
        private static Pen CommonOuterBorderPen
        {
            get
            {
                if (_commonOuterBorderPen == null)
                {
                    lock (_resourceAccess)
                    {
                        if (_commonOuterBorderPen == null)
                        {
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0x85, 0x99, 0xB1));
                            temp.Freeze();
 
                            _commonOuterBorderPen = temp;
                        }
                    }
                }
                return _commonOuterBorderPen;
            }
        }
 
        private static Pen CommonHoverOuterBorderPen
        {
            get
            {
                if (_commonHoverOuterBorderPen == null)
                {
                    lock (_resourceAccess)
                    {
                        if (_commonHoverOuterBorderPen == null)
                        {
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0x52, 0x66, 0x7E));
                            temp.Freeze();
 
                            _commonHoverOuterBorderPen = temp;
                        }
                    }
                }
                return _commonHoverOuterBorderPen;
            }
        }
 
 
        private Pen OuterBorder
        {
            get
            {
                if (!IsEnabled)
                    return CommonDisabledOuterBorderPen;
                else if (RenderMouseOver || RenderPressed)
                    return CommonHoverOuterBorderPen;
                else
                    return CommonOuterBorderPen;
            }
        }
 
        
 
        private static Pen CommonInnerBorderPen
        {
            get
            {
                if (_commonInnerBorderPen == null)
                {
                    lock (_resourceAccess)
                    {
                        if (_commonInnerBorderPen == null)
                        {
                            Pen temp = new Pen();
                            temp.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF));
                            temp.Freeze();
 
                            _commonInnerBorderPen = temp;
                        }
                    }
                }
                return _commonInnerBorderPen;
            }
        }
 
        private Pen InnerBorder
        {
            get
            {
                return CommonInnerBorderPen;
            }
        }
 
        #endregion
 
        #region Data
 
        private static LinearGradientBrush _commonVerticalFill;
        private static LinearGradientBrush _commonHorizontalFill;
 
        private static LinearGradientBrush _commonHoverVerticalFill;
        private static LinearGradientBrush _commonHoverHorizontalFill;
 
        private static LinearGradientBrush _commonPressedVerticalFill;
        private static LinearGradientBrush _commonPressedHorizontalFill;
 
        private static LinearGradientBrush _commonDisabledFill;
 
 
        private static SolidColorBrush _commonDisabledGlyph;
 
        private static SolidColorBrush _commonArrowGlyph;
 
        private static SolidColorBrush _commonHoverArrowGlyph;
        
        private static SolidColorBrush _commonGripperGlyph;
 
 
        private static SolidColorBrush _commonDisabledGripperGlyphShadow;
 
        private static SolidColorBrush _commonGripperGlyphShadow;
 
 
        private static Pen _commonDisabledOuterBorderPen;
        private static Pen _commonOuterBorderPen;
 
        private static Pen _commonHoverOuterBorderPen;
 
        private static Pen _commonInnerBorderPen;
 
        private static object _resourceAccess = new object();
 
       
        private MatrixTransform _transform;
 
        #endregion
    }
}