brushes.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Core / CSharp / System / Windows / Media / brushes.cs / 1305600 / brushes.cs
                        

                        
                            //---------------------------------------------------------------------------- 
//
// Copyright (C) Microsoft Corporation.  All rights reserved.
//
// File: Brushes.cs 
//
// Description: A static class which contains well-known SolidColorBrushes. 
// 
// History:
//  04/29/2003 : [....] - Created it 
//
//---------------------------------------------------------------------------

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

namespace System.Windows.Media 
{
    /// 
    /// Brushes - A collection of well-known SolidColorBrushes
    ///  
    public sealed class Brushes
    { 
        #region Constructors 

        ///  
        /// Private constructor - prevents instantiation.
        /// 
        private Brushes() {}
 
        #endregion Constructors
 
        #region static Known SolidColorBrushes 

        ///  
        /// Well-known SolidColorBrush: AliceBlue
        /// 
        public static SolidColorBrush AliceBlue
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.AliceBlue); 
            }
        } 

        /// 
        /// Well-known SolidColorBrush: AntiqueWhite
        ///  
        public static SolidColorBrush AntiqueWhite
        { 
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.AntiqueWhite); 
            }
        }

        ///  
        /// Well-known SolidColorBrush: Aqua
        ///  
        public static SolidColorBrush Aqua 
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Aqua);
            }
        } 

        ///  
        /// Well-known SolidColorBrush: Aquamarine 
        /// 
        public static SolidColorBrush Aquamarine 
        {
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Aquamarine); 
            }
        } 
 
        /// 
        /// Well-known SolidColorBrush: Azure 
        /// 
        public static SolidColorBrush Azure
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Azure); 
            } 
        }
 
        /// 
        /// Well-known SolidColorBrush: Beige
        /// 
        public static SolidColorBrush Beige 
        {
            get 
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Beige);
            } 
        }

        /// 
        /// Well-known SolidColorBrush: Bisque 
        /// 
        public static SolidColorBrush Bisque 
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Bisque);
            }
        }
 
        /// 
        /// Well-known SolidColorBrush: Black 
        ///  
        public static SolidColorBrush Black
        { 
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Black);
            } 
        }
 
        ///  
        /// Well-known SolidColorBrush: BlanchedAlmond
        ///  
        public static SolidColorBrush BlanchedAlmond
        {
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.BlanchedAlmond);
            } 
        } 

        ///  
        /// Well-known SolidColorBrush: Blue
        /// 
        public static SolidColorBrush Blue
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Blue); 
            }
        } 

        /// 
        /// Well-known SolidColorBrush: BlueViolet
        ///  
        public static SolidColorBrush BlueViolet
        { 
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.BlueViolet); 
            }
        }

        ///  
        /// Well-known SolidColorBrush: Brown
        ///  
        public static SolidColorBrush Brown 
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Brown);
            }
        } 

        ///  
        /// Well-known SolidColorBrush: BurlyWood 
        /// 
        public static SolidColorBrush BurlyWood 
        {
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.BurlyWood); 
            }
        } 
 
        /// 
        /// Well-known SolidColorBrush: CadetBlue 
        /// 
        public static SolidColorBrush CadetBlue
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.CadetBlue); 
            } 
        }
 
        /// 
        /// Well-known SolidColorBrush: Chartreuse
        /// 
        public static SolidColorBrush Chartreuse 
        {
            get 
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Chartreuse);
            } 
        }

        /// 
        /// Well-known SolidColorBrush: Chocolate 
        /// 
        public static SolidColorBrush Chocolate 
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Chocolate);
            }
        }
 
        /// 
        /// Well-known SolidColorBrush: Coral 
        ///  
        public static SolidColorBrush Coral
        { 
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Coral);
            } 
        }
 
        ///  
        /// Well-known SolidColorBrush: CornflowerBlue
        ///  
        public static SolidColorBrush CornflowerBlue
        {
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.CornflowerBlue);
            } 
        } 

        ///  
        /// Well-known SolidColorBrush: Cornsilk
        /// 
        public static SolidColorBrush Cornsilk
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Cornsilk); 
            }
        } 

        /// 
        /// Well-known SolidColorBrush: Crimson
        ///  
        public static SolidColorBrush Crimson
        { 
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Crimson); 
            }
        }

        ///  
        /// Well-known SolidColorBrush: Cyan
        ///  
        public static SolidColorBrush Cyan 
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Cyan);
            }
        } 

        ///  
        /// Well-known SolidColorBrush: DarkBlue 
        /// 
        public static SolidColorBrush DarkBlue 
        {
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DarkBlue); 
            }
        } 
 
        /// 
        /// Well-known SolidColorBrush: DarkCyan 
        /// 
        public static SolidColorBrush DarkCyan
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DarkCyan); 
            } 
        }
 
        /// 
        /// Well-known SolidColorBrush: DarkGoldenrod
        /// 
        public static SolidColorBrush DarkGoldenrod 
        {
            get 
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DarkGoldenrod);
            } 
        }

        /// 
        /// Well-known SolidColorBrush: DarkGray 
        /// 
        public static SolidColorBrush DarkGray 
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DarkGray);
            }
        }
 
        /// 
        /// Well-known SolidColorBrush: DarkGreen 
        ///  
        public static SolidColorBrush DarkGreen
        { 
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DarkGreen);
            } 
        }
 
        ///  
        /// Well-known SolidColorBrush: DarkKhaki
        ///  
        public static SolidColorBrush DarkKhaki
        {
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DarkKhaki);
            } 
        } 

        ///  
        /// Well-known SolidColorBrush: DarkMagenta
        /// 
        public static SolidColorBrush DarkMagenta
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DarkMagenta); 
            }
        } 

        /// 
        /// Well-known SolidColorBrush: DarkOliveGreen
        ///  
        public static SolidColorBrush DarkOliveGreen
        { 
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DarkOliveGreen); 
            }
        }

        ///  
        /// Well-known SolidColorBrush: DarkOrange
        ///  
        public static SolidColorBrush DarkOrange 
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DarkOrange);
            }
        } 

        ///  
        /// Well-known SolidColorBrush: DarkOrchid 
        /// 
        public static SolidColorBrush DarkOrchid 
        {
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DarkOrchid); 
            }
        } 
 
        /// 
        /// Well-known SolidColorBrush: DarkRed 
        /// 
        public static SolidColorBrush DarkRed
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DarkRed); 
            } 
        }
 
        /// 
        /// Well-known SolidColorBrush: DarkSalmon
        /// 
        public static SolidColorBrush DarkSalmon 
        {
            get 
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DarkSalmon);
            } 
        }

        /// 
        /// Well-known SolidColorBrush: DarkSeaGreen 
        /// 
        public static SolidColorBrush DarkSeaGreen 
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DarkSeaGreen);
            }
        }
 
        /// 
        /// Well-known SolidColorBrush: DarkSlateBlue 
        ///  
        public static SolidColorBrush DarkSlateBlue
        { 
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DarkSlateBlue);
            } 
        }
 
        ///  
        /// Well-known SolidColorBrush: DarkSlateGray
        ///  
        public static SolidColorBrush DarkSlateGray
        {
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DarkSlateGray);
            } 
        } 

        ///  
        /// Well-known SolidColorBrush: DarkTurquoise
        /// 
        public static SolidColorBrush DarkTurquoise
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DarkTurquoise); 
            }
        } 

        /// 
        /// Well-known SolidColorBrush: DarkViolet
        ///  
        public static SolidColorBrush DarkViolet
        { 
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DarkViolet); 
            }
        }

        ///  
        /// Well-known SolidColorBrush: DeepPink
        ///  
        public static SolidColorBrush DeepPink 
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DeepPink);
            }
        } 

        ///  
        /// Well-known SolidColorBrush: DeepSkyBlue 
        /// 
        public static SolidColorBrush DeepSkyBlue 
        {
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DeepSkyBlue); 
            }
        } 
 
        /// 
        /// Well-known SolidColorBrush: DimGray 
        /// 
        public static SolidColorBrush DimGray
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DimGray); 
            } 
        }
 
        /// 
        /// Well-known SolidColorBrush: DodgerBlue
        /// 
        public static SolidColorBrush DodgerBlue 
        {
            get 
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.DodgerBlue);
            } 
        }

        /// 
        /// Well-known SolidColorBrush: Firebrick 
        /// 
        public static SolidColorBrush Firebrick 
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Firebrick);
            }
        }
 
        /// 
        /// Well-known SolidColorBrush: FloralWhite 
        ///  
        public static SolidColorBrush FloralWhite
        { 
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.FloralWhite);
            } 
        }
 
        ///  
        /// Well-known SolidColorBrush: ForestGreen
        ///  
        public static SolidColorBrush ForestGreen
        {
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.ForestGreen);
            } 
        } 

        ///  
        /// Well-known SolidColorBrush: Fuchsia
        /// 
        public static SolidColorBrush Fuchsia
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Fuchsia); 
            }
        } 

        /// 
        /// Well-known SolidColorBrush: Gainsboro
        ///  
        public static SolidColorBrush Gainsboro
        { 
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Gainsboro); 
            }
        }

        ///  
        /// Well-known SolidColorBrush: GhostWhite
        ///  
        public static SolidColorBrush GhostWhite 
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.GhostWhite);
            }
        } 

        ///  
        /// Well-known SolidColorBrush: Gold 
        /// 
        public static SolidColorBrush Gold 
        {
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Gold); 
            }
        } 
 
        /// 
        /// Well-known SolidColorBrush: Goldenrod 
        /// 
        public static SolidColorBrush Goldenrod
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Goldenrod); 
            } 
        }
 
        /// 
        /// Well-known SolidColorBrush: Gray
        /// 
        public static SolidColorBrush Gray 
        {
            get 
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Gray);
            } 
        }

        /// 
        /// Well-known SolidColorBrush: Green 
        /// 
        public static SolidColorBrush Green 
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Green);
            }
        }
 
        /// 
        /// Well-known SolidColorBrush: GreenYellow 
        ///  
        public static SolidColorBrush GreenYellow
        { 
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.GreenYellow);
            } 
        }
 
        ///  
        /// Well-known SolidColorBrush: Honeydew
        ///  
        public static SolidColorBrush Honeydew
        {
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Honeydew);
            } 
        } 

        ///  
        /// Well-known SolidColorBrush: HotPink
        /// 
        public static SolidColorBrush HotPink
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.HotPink); 
            }
        } 

        /// 
        /// Well-known SolidColorBrush: IndianRed
        ///  
        public static SolidColorBrush IndianRed
        { 
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.IndianRed); 
            }
        }

        ///  
        /// Well-known SolidColorBrush: Indigo
        ///  
        public static SolidColorBrush Indigo 
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Indigo);
            }
        } 

        ///  
        /// Well-known SolidColorBrush: Ivory 
        /// 
        public static SolidColorBrush Ivory 
        {
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Ivory); 
            }
        } 
 
        /// 
        /// Well-known SolidColorBrush: Khaki 
        /// 
        public static SolidColorBrush Khaki
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Khaki); 
            } 
        }
 
        /// 
        /// Well-known SolidColorBrush: Lavender
        /// 
        public static SolidColorBrush Lavender 
        {
            get 
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Lavender);
            } 
        }

        /// 
        /// Well-known SolidColorBrush: LavenderBlush 
        /// 
        public static SolidColorBrush LavenderBlush 
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.LavenderBlush);
            }
        }
 
        /// 
        /// Well-known SolidColorBrush: LawnGreen 
        ///  
        public static SolidColorBrush LawnGreen
        { 
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.LawnGreen);
            } 
        }
 
        ///  
        /// Well-known SolidColorBrush: LemonChiffon
        ///  
        public static SolidColorBrush LemonChiffon
        {
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.LemonChiffon);
            } 
        } 

        ///  
        /// Well-known SolidColorBrush: LightBlue
        /// 
        public static SolidColorBrush LightBlue
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.LightBlue); 
            }
        } 

        /// 
        /// Well-known SolidColorBrush: LightCoral
        ///  
        public static SolidColorBrush LightCoral
        { 
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.LightCoral); 
            }
        }

        ///  
        /// Well-known SolidColorBrush: LightCyan
        ///  
        public static SolidColorBrush LightCyan 
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.LightCyan);
            }
        } 

        ///  
        /// Well-known SolidColorBrush: LightGoldenrodYellow 
        /// 
        public static SolidColorBrush LightGoldenrodYellow 
        {
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.LightGoldenrodYellow); 
            }
        } 
 
        /// 
        /// Well-known SolidColorBrush: LightGray 
        /// 
        public static SolidColorBrush LightGray
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.LightGray); 
            } 
        }
 
        /// 
        /// Well-known SolidColorBrush: LightGreen
        /// 
        public static SolidColorBrush LightGreen 
        {
            get 
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.LightGreen);
            } 
        }

        /// 
        /// Well-known SolidColorBrush: LightPink 
        /// 
        public static SolidColorBrush LightPink 
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.LightPink);
            }
        }
 
        /// 
        /// Well-known SolidColorBrush: LightSalmon 
        ///  
        public static SolidColorBrush LightSalmon
        { 
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.LightSalmon);
            } 
        }
 
        ///  
        /// Well-known SolidColorBrush: LightSeaGreen
        ///  
        public static SolidColorBrush LightSeaGreen
        {
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.LightSeaGreen);
            } 
        } 

        ///  
        /// Well-known SolidColorBrush: LightSkyBlue
        /// 
        public static SolidColorBrush LightSkyBlue
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.LightSkyBlue); 
            }
        } 

        /// 
        /// Well-known SolidColorBrush: LightSlateGray
        ///  
        public static SolidColorBrush LightSlateGray
        { 
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.LightSlateGray); 
            }
        }

        ///  
        /// Well-known SolidColorBrush: LightSteelBlue
        ///  
        public static SolidColorBrush LightSteelBlue 
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.LightSteelBlue);
            }
        } 

        ///  
        /// Well-known SolidColorBrush: LightYellow 
        /// 
        public static SolidColorBrush LightYellow 
        {
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.LightYellow); 
            }
        } 
 
        /// 
        /// Well-known SolidColorBrush: Lime 
        /// 
        public static SolidColorBrush Lime
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Lime); 
            } 
        }
 
        /// 
        /// Well-known SolidColorBrush: LimeGreen
        /// 
        public static SolidColorBrush LimeGreen 
        {
            get 
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.LimeGreen);
            } 
        }

        /// 
        /// Well-known SolidColorBrush: Linen 
        /// 
        public static SolidColorBrush Linen 
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Linen);
            }
        }
 
        /// 
        /// Well-known SolidColorBrush: Magenta 
        ///  
        public static SolidColorBrush Magenta
        { 
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Magenta);
            } 
        }
 
        ///  
        /// Well-known SolidColorBrush: Maroon
        ///  
        public static SolidColorBrush Maroon
        {
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Maroon);
            } 
        } 

        ///  
        /// Well-known SolidColorBrush: MediumAquamarine
        /// 
        public static SolidColorBrush MediumAquamarine
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.MediumAquamarine); 
            }
        } 

        /// 
        /// Well-known SolidColorBrush: MediumBlue
        ///  
        public static SolidColorBrush MediumBlue
        { 
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.MediumBlue); 
            }
        }

        ///  
        /// Well-known SolidColorBrush: MediumOrchid
        ///  
        public static SolidColorBrush MediumOrchid 
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.MediumOrchid);
            }
        } 

        ///  
        /// Well-known SolidColorBrush: MediumPurple 
        /// 
        public static SolidColorBrush MediumPurple 
        {
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.MediumPurple); 
            }
        } 
 
        /// 
        /// Well-known SolidColorBrush: MediumSeaGreen 
        /// 
        public static SolidColorBrush MediumSeaGreen
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.MediumSeaGreen); 
            } 
        }
 
        /// 
        /// Well-known SolidColorBrush: MediumSlateBlue
        /// 
        public static SolidColorBrush MediumSlateBlue 
        {
            get 
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.MediumSlateBlue);
            } 
        }

        /// 
        /// Well-known SolidColorBrush: MediumSpringGreen 
        /// 
        public static SolidColorBrush MediumSpringGreen 
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.MediumSpringGreen);
            }
        }
 
        /// 
        /// Well-known SolidColorBrush: MediumTurquoise 
        ///  
        public static SolidColorBrush MediumTurquoise
        { 
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.MediumTurquoise);
            } 
        }
 
        ///  
        /// Well-known SolidColorBrush: MediumVioletRed
        ///  
        public static SolidColorBrush MediumVioletRed
        {
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.MediumVioletRed);
            } 
        } 

        ///  
        /// Well-known SolidColorBrush: MidnightBlue
        /// 
        public static SolidColorBrush MidnightBlue
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.MidnightBlue); 
            }
        } 

        /// 
        /// Well-known SolidColorBrush: MintCream
        ///  
        public static SolidColorBrush MintCream
        { 
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.MintCream); 
            }
        }

        ///  
        /// Well-known SolidColorBrush: MistyRose
        ///  
        public static SolidColorBrush MistyRose 
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.MistyRose);
            }
        } 

        ///  
        /// Well-known SolidColorBrush: Moccasin 
        /// 
        public static SolidColorBrush Moccasin 
        {
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Moccasin); 
            }
        } 
 
        /// 
        /// Well-known SolidColorBrush: NavajoWhite 
        /// 
        public static SolidColorBrush NavajoWhite
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.NavajoWhite); 
            } 
        }
 
        /// 
        /// Well-known SolidColorBrush: Navy
        /// 
        public static SolidColorBrush Navy 
        {
            get 
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Navy);
            } 
        }

        /// 
        /// Well-known SolidColorBrush: OldLace 
        /// 
        public static SolidColorBrush OldLace 
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.OldLace);
            }
        }
 
        /// 
        /// Well-known SolidColorBrush: Olive 
        ///  
        public static SolidColorBrush Olive
        { 
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Olive);
            } 
        }
 
        ///  
        /// Well-known SolidColorBrush: OliveDrab
        ///  
        public static SolidColorBrush OliveDrab
        {
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.OliveDrab);
            } 
        } 

        ///  
        /// Well-known SolidColorBrush: Orange
        /// 
        public static SolidColorBrush Orange
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Orange); 
            }
        } 

        /// 
        /// Well-known SolidColorBrush: OrangeRed
        ///  
        public static SolidColorBrush OrangeRed
        { 
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.OrangeRed); 
            }
        }

        ///  
        /// Well-known SolidColorBrush: Orchid
        ///  
        public static SolidColorBrush Orchid 
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Orchid);
            }
        } 

        ///  
        /// Well-known SolidColorBrush: PaleGoldenrod 
        /// 
        public static SolidColorBrush PaleGoldenrod 
        {
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.PaleGoldenrod); 
            }
        } 
 
        /// 
        /// Well-known SolidColorBrush: PaleGreen 
        /// 
        public static SolidColorBrush PaleGreen
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.PaleGreen); 
            } 
        }
 
        /// 
        /// Well-known SolidColorBrush: PaleTurquoise
        /// 
        public static SolidColorBrush PaleTurquoise 
        {
            get 
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.PaleTurquoise);
            } 
        }

        /// 
        /// Well-known SolidColorBrush: PaleVioletRed 
        /// 
        public static SolidColorBrush PaleVioletRed 
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.PaleVioletRed);
            }
        }
 
        /// 
        /// Well-known SolidColorBrush: PapayaWhip 
        ///  
        public static SolidColorBrush PapayaWhip
        { 
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.PapayaWhip);
            } 
        }
 
        ///  
        /// Well-known SolidColorBrush: PeachPuff
        ///  
        public static SolidColorBrush PeachPuff
        {
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.PeachPuff);
            } 
        } 

        ///  
        /// Well-known SolidColorBrush: Peru
        /// 
        public static SolidColorBrush Peru
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Peru); 
            }
        } 

        /// 
        /// Well-known SolidColorBrush: Pink
        ///  
        public static SolidColorBrush Pink
        { 
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Pink); 
            }
        }

        ///  
        /// Well-known SolidColorBrush: Plum
        ///  
        public static SolidColorBrush Plum 
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Plum);
            }
        } 

        ///  
        /// Well-known SolidColorBrush: PowderBlue 
        /// 
        public static SolidColorBrush PowderBlue 
        {
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.PowderBlue); 
            }
        } 
 
        /// 
        /// Well-known SolidColorBrush: Purple 
        /// 
        public static SolidColorBrush Purple
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Purple); 
            } 
        }
 
        /// 
        /// Well-known SolidColorBrush: Red
        /// 
        public static SolidColorBrush Red 
        {
            get 
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Red);
            } 
        }

        /// 
        /// Well-known SolidColorBrush: RosyBrown 
        /// 
        public static SolidColorBrush RosyBrown 
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.RosyBrown);
            }
        }
 
        /// 
        /// Well-known SolidColorBrush: RoyalBlue 
        ///  
        public static SolidColorBrush RoyalBlue
        { 
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.RoyalBlue);
            } 
        }
 
        ///  
        /// Well-known SolidColorBrush: SaddleBrown
        ///  
        public static SolidColorBrush SaddleBrown
        {
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.SaddleBrown);
            } 
        } 

        ///  
        /// Well-known SolidColorBrush: Salmon
        /// 
        public static SolidColorBrush Salmon
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Salmon); 
            }
        } 

        /// 
        /// Well-known SolidColorBrush: SandyBrown
        ///  
        public static SolidColorBrush SandyBrown
        { 
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.SandyBrown); 
            }
        }

        ///  
        /// Well-known SolidColorBrush: SeaGreen
        ///  
        public static SolidColorBrush SeaGreen 
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.SeaGreen);
            }
        } 

        ///  
        /// Well-known SolidColorBrush: SeaShell 
        /// 
        public static SolidColorBrush SeaShell 
        {
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.SeaShell); 
            }
        } 
 
        /// 
        /// Well-known SolidColorBrush: Sienna 
        /// 
        public static SolidColorBrush Sienna
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Sienna); 
            } 
        }
 
        /// 
        /// Well-known SolidColorBrush: Silver
        /// 
        public static SolidColorBrush Silver 
        {
            get 
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Silver);
            } 
        }

        /// 
        /// Well-known SolidColorBrush: SkyBlue 
        /// 
        public static SolidColorBrush SkyBlue 
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.SkyBlue);
            }
        }
 
        /// 
        /// Well-known SolidColorBrush: SlateBlue 
        ///  
        public static SolidColorBrush SlateBlue
        { 
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.SlateBlue);
            } 
        }
 
        ///  
        /// Well-known SolidColorBrush: SlateGray
        ///  
        public static SolidColorBrush SlateGray
        {
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.SlateGray);
            } 
        } 

        ///  
        /// Well-known SolidColorBrush: Snow
        /// 
        public static SolidColorBrush Snow
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Snow); 
            }
        } 

        /// 
        /// Well-known SolidColorBrush: SpringGreen
        ///  
        public static SolidColorBrush SpringGreen
        { 
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.SpringGreen); 
            }
        }

        ///  
        /// Well-known SolidColorBrush: SteelBlue
        ///  
        public static SolidColorBrush SteelBlue 
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.SteelBlue);
            }
        } 

        ///  
        /// Well-known SolidColorBrush: Tan 
        /// 
        public static SolidColorBrush Tan 
        {
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Tan); 
            }
        } 
 
        /// 
        /// Well-known SolidColorBrush: Teal 
        /// 
        public static SolidColorBrush Teal
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Teal); 
            } 
        }
 
        /// 
        /// Well-known SolidColorBrush: Thistle
        /// 
        public static SolidColorBrush Thistle 
        {
            get 
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Thistle);
            } 
        }

        /// 
        /// Well-known SolidColorBrush: Tomato 
        /// 
        public static SolidColorBrush Tomato 
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Tomato);
            }
        }
 
        /// 
        /// Well-known SolidColorBrush: Transparent 
        ///  
        public static SolidColorBrush Transparent
        { 
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Transparent);
            } 
        }
 
        ///  
        /// Well-known SolidColorBrush: Turquoise
        ///  
        public static SolidColorBrush Turquoise
        {
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Turquoise);
            } 
        } 

        ///  
        /// Well-known SolidColorBrush: Violet
        /// 
        public static SolidColorBrush Violet
        { 
            get
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Violet); 
            }
        } 

        /// 
        /// Well-known SolidColorBrush: Wheat
        ///  
        public static SolidColorBrush Wheat
        { 
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Wheat); 
            }
        }

        ///  
        /// Well-known SolidColorBrush: White
        ///  
        public static SolidColorBrush White 
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.White);
            }
        } 

        ///  
        /// Well-known SolidColorBrush: WhiteSmoke 
        /// 
        public static SolidColorBrush WhiteSmoke 
        {
            get
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.WhiteSmoke); 
            }
        } 
 
        /// 
        /// Well-known SolidColorBrush: Yellow 
        /// 
        public static SolidColorBrush Yellow
        {
            get 
            {
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.Yellow); 
            } 
        }
 
        /// 
        /// Well-known SolidColorBrush: YellowGreen
        /// 
        public static SolidColorBrush YellowGreen 
        {
            get 
            { 
                return KnownColors.SolidColorBrushFromUint((uint)KnownColor.YellowGreen);
            } 
        }

        #endregion static Known SolidColorBrushes
    } 
}

// 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