//
// System.Windows.Drawing.Brushes.cs
//
// Authors:
//   Dennis Hayes (dennish@Raytek.com)
//	Suesan Chaney
//	  Peter Bartok (pbartok@novell.com)
//
// (C) Ximian, Inc., 2002 http://www.ximian.com
// (C) Novell, Inc., 2004 http://www.novell.com
//

//
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System;

namespace System.Drawing 
{
	public sealed class Brushes 
	{
		static SolidBrush aliceBlue;
		static SolidBrush antiqueWhite;
		static SolidBrush aqua;
		static SolidBrush aquamarine;
		static SolidBrush azure;
		static SolidBrush beige;
		static SolidBrush bisque;
		static SolidBrush black;
		static SolidBrush blanchedAlmond;
		static SolidBrush blue;
		static SolidBrush blueViolet;
		static SolidBrush brown;
		static SolidBrush burlyWood;
		static SolidBrush cadetBlue;
		static SolidBrush chartreuse;
		static SolidBrush chocolate;
		static SolidBrush coral;
		static SolidBrush cornflowerBlue;
		static SolidBrush cornsilk;
		static SolidBrush crimson;
		static SolidBrush cyan;
		static SolidBrush darkBlue;
		static SolidBrush darkCyan;
		static SolidBrush darkGoldenrod;
		static SolidBrush darkGray;
		static SolidBrush darkGreen;
		static SolidBrush darkKhaki;
		static SolidBrush darkMagenta;
		static SolidBrush darkOliveGreen;
		static SolidBrush darkOrange;
		static SolidBrush darkOrchid;
		static SolidBrush darkRed;
		static SolidBrush darkSalmon;
		static SolidBrush darkSeaGreen;
		static SolidBrush darkSlateBlue;
		static SolidBrush darkSlateGray;
		static SolidBrush darkTurquoise;
		static SolidBrush darkViolet;
		static SolidBrush deepPink;
		static SolidBrush deepSkyBlue;
		static SolidBrush dimGray;
		static SolidBrush dodgerBlue;
		static SolidBrush firebrick;
		static SolidBrush floralWhite;
		static SolidBrush forestGreen;
		static SolidBrush fuchsia;
		static SolidBrush gainsboro;
		static SolidBrush ghostWhite;
		static SolidBrush gold;
		static SolidBrush goldenrod;
		static SolidBrush gray;
		static SolidBrush green;
		static SolidBrush greenYellow;
		static SolidBrush honeydew;
		static SolidBrush hotPink;
		static SolidBrush indianRed;
		static SolidBrush indigo;
		static SolidBrush ivory;
		static SolidBrush khaki;
		static SolidBrush lavender;
		static SolidBrush lavenderBlush;
		static SolidBrush lawnGreen;
		static SolidBrush lemonChiffon;
		static SolidBrush lightBlue;
		static SolidBrush lightCoral;
		static SolidBrush lightCyan;
		static SolidBrush lightGoldenrodYellow;
		static SolidBrush lightGray;
		static SolidBrush lightGreen;
		static SolidBrush lightPink;
		static SolidBrush lightSalmon;
		static SolidBrush lightSeaGreen;
		static SolidBrush lightSkyBlue;
		static SolidBrush lightSlateGray;
		static SolidBrush lightSteelBlue;
		static SolidBrush lightYellow;
		static SolidBrush lime;
		static SolidBrush limeGreen;
		static SolidBrush linen;
		static SolidBrush magenta;
		static SolidBrush maroon;
		static SolidBrush mediumAquamarine;
		static SolidBrush mediumBlue;
		static SolidBrush mediumOrchid;
		static SolidBrush mediumPurple;
		static SolidBrush mediumSeaGreen;
		static SolidBrush mediumSlateBlue;
		static SolidBrush mediumSpringGreen;
		static SolidBrush mediumTurquoise;
		static SolidBrush mediumVioletRed;
		static SolidBrush midnightBlue;
		static SolidBrush mintCream;
		static SolidBrush mistyRose;
		static SolidBrush moccasin;
		static SolidBrush navajoWhite;
		static SolidBrush navy;
		static SolidBrush oldLace;
		static SolidBrush olive;
		static SolidBrush oliveDrab;
		static SolidBrush orange;
		static SolidBrush orangeRed;
		static SolidBrush orchid;
		static SolidBrush paleGoldenrod;
		static SolidBrush paleGreen;
		static SolidBrush paleTurquoise;
		static SolidBrush paleVioletRed;
		static SolidBrush papayaWhip;
		static SolidBrush peachPuff;
		static SolidBrush peru;
		static SolidBrush pink;
		static SolidBrush plum;
		static SolidBrush powderBlue;
		static SolidBrush purple;
		static SolidBrush red;
		static SolidBrush rosyBrown;
		static SolidBrush royalBlue;
		static SolidBrush saddleBrown;
		static SolidBrush salmon;
		static SolidBrush sandyBrown;
		static SolidBrush seaGreen;
		static SolidBrush seaShell;
		static SolidBrush sienna;
		static SolidBrush silver;
		static SolidBrush skyBlue;
		static SolidBrush slateBlue;
		static SolidBrush slateGray;
		static SolidBrush snow;
		static SolidBrush springGreen;
		static SolidBrush steelBlue;
		static SolidBrush tan;
		static SolidBrush teal;
		static SolidBrush thistle;
		static SolidBrush tomato;
		static SolidBrush transparent;
		static SolidBrush turquoise;
		static SolidBrush violet;
		static SolidBrush wheat;
		static SolidBrush white;
		static SolidBrush whiteSmoke;
		static SolidBrush yellow;
		static SolidBrush yellowGreen;

		// We intentionally do not set the is_modifiable=false flag on
		// the brushes, to stay Microsoft compatible

		private Brushes () { }
	
		public static Brush AliceBlue {
			get {
				if (aliceBlue==null) {
					aliceBlue=new SolidBrush(Color.AliceBlue);
				}
				return(aliceBlue);
			}
		}

		public static Brush AntiqueWhite {
			get {
				if (antiqueWhite==null) {
					antiqueWhite=new SolidBrush(Color.AntiqueWhite);
				}
				return(antiqueWhite);
			}
		}

		public static Brush Aqua {
			get {
				if (aqua==null) {
					aqua=new SolidBrush(Color.Aqua);
				}
				return(aqua);
			}
		}

		public static Brush Aquamarine {
			get {
				if (aquamarine==null) {
					aquamarine=new SolidBrush(Color.Aquamarine);
				}
				return(aquamarine);
			}
		}

		public static Brush Azure {
			get {
				if (azure==null) {
					azure=new SolidBrush(Color.Azure);
				}
				return(azure);
			}
		}

		public static Brush Beige {
			get {
				if (beige==null) {
					beige=new SolidBrush(Color.Beige);
				}
				return(beige);
			}
		}

		public static Brush Bisque {
			get {
				if (bisque==null) {
					bisque=new SolidBrush(Color.Bisque);
				}
				return(bisque);
			}
		}

		public static Brush Black {
			get {
				if (black==null) {
					black=new SolidBrush(Color.Black);
				}
				return(black);
			}
		}

		public static Brush BlanchedAlmond {
			get {
				if (blanchedAlmond==null) {
					blanchedAlmond=new SolidBrush(Color.BlanchedAlmond);
				}
				return(blanchedAlmond);
			}
		}

		public static Brush Blue {
			get {
				if (blue==null) {
					blue=new SolidBrush(Color.Blue);
				}
				return(blue);
			}
		}

		public static Brush BlueViolet {
			get {
				if (blueViolet==null) {
					blueViolet=new SolidBrush(Color.BlueViolet);
				}
				return(blueViolet);
			}
		}

		public static Brush Brown {
			get {
				if (brown==null) {
					brown=new SolidBrush(Color.Brown);
				}
				return(brown);
			}
		}

		public static Brush BurlyWood {
			get {
				if (burlyWood==null) {
					burlyWood=new SolidBrush(Color.BurlyWood);
				}
				return(burlyWood);
			}
		}

		public static Brush CadetBlue {
			get {
				if (cadetBlue==null) {
					cadetBlue=new SolidBrush(Color.CadetBlue);
				}
				return(cadetBlue);
			}
		}

		public static Brush Chartreuse {
			get {
				if (chartreuse==null) {
					chartreuse=new SolidBrush(Color.Chartreuse);
				}
				return(chartreuse);
			}
		}

		public static Brush Chocolate {
			get {
				if (chocolate==null) {
					chocolate=new SolidBrush(Color.Chocolate);
				}
				return(chocolate);
			}
		}

		public static Brush Coral {
			get {
				if (coral==null) {
					coral=new SolidBrush(Color.Coral);
				}
				return(coral);
			}
		}

		public static Brush CornflowerBlue {
			get {
				if (cornflowerBlue==null) {
					cornflowerBlue=new SolidBrush(Color.CornflowerBlue);
				}
				return(cornflowerBlue);
			}
		}

		public static Brush Cornsilk {
			get {
				if (cornsilk==null) {
					cornsilk=new SolidBrush(Color.Cornsilk);
				}
				return(cornsilk);
			}
		}

		public static Brush Crimson {
			get {
				if (crimson==null) {
					crimson=new SolidBrush(Color.Crimson);
				}
				return(crimson);
			}
		}

		public static Brush Cyan {
			get {
				if (cyan==null) {
					cyan=new SolidBrush(Color.Cyan);
				}
				return(cyan);
			}
		}

		public static Brush DarkBlue {
			get {
				if (darkBlue==null) {
					darkBlue=new SolidBrush(Color.DarkBlue);
				}
				return(darkBlue);
			}
		}

		public static Brush DarkCyan {
			get {
				if (darkCyan==null) {
					darkCyan=new SolidBrush(Color.DarkCyan);
				}
				return(darkCyan);
			}
		}

		public static Brush DarkGoldenrod {
			get {
				if (darkGoldenrod==null) {
					darkGoldenrod=new SolidBrush(Color.DarkGoldenrod);
				}
				return(darkGoldenrod);
			}
		}

		public static Brush DarkGray {
			get {
				if (darkGray==null) {
					darkGray=new SolidBrush(Color.DarkGray);
				}
				return(darkGray);
			}
		}

		public static Brush DarkGreen {
			get {
				if (darkGreen==null) {
					darkGreen=new SolidBrush(Color.DarkGreen);
				}
				return(darkGreen);
			}
		}

		public static Brush DarkKhaki {
			get {
				if (darkKhaki==null) {
					darkKhaki=new SolidBrush(Color.DarkKhaki);
				}
				return(darkKhaki);
			}
		}

		public static Brush DarkMagenta {
			get {
				if (darkMagenta==null) {
					darkMagenta=new SolidBrush(Color.DarkMagenta);
				}
				return(darkMagenta);
			}
		}

		public static Brush DarkOliveGreen {
			get {
				if (darkOliveGreen==null) {
					darkOliveGreen=new SolidBrush(Color.DarkOliveGreen);
				}
				return(darkOliveGreen);
			}
		}

		public static Brush DarkOrange {
			get {
				if (darkOrange==null) {
					darkOrange=new SolidBrush(Color.DarkOrange);
				}
				return(darkOrange);
			}
		}

		public static Brush DarkOrchid {
			get {
				if (darkOrchid==null) {
					darkOrchid=new SolidBrush(Color.DarkOrchid);
				}
				return(darkOrchid);
			}
		}

		public static Brush DarkRed {
			get {
				if (darkRed==null) {
					darkRed=new SolidBrush(Color.DarkRed);
				}
				return(darkRed);
			}
		}

		public static Brush DarkSalmon {
			get {
				if (darkSalmon==null) {
					darkSalmon=new SolidBrush(Color.DarkSalmon);
				}
				return(darkSalmon);
			}
		}

		public static Brush DarkSeaGreen {
			get {
				if (darkSeaGreen==null) {
					darkSeaGreen=new SolidBrush(Color.DarkSeaGreen);
				}
				return(darkSeaGreen);
			}
		}

		public static Brush DarkSlateBlue {
			get {
				if (darkSlateBlue==null) {
					darkSlateBlue=new SolidBrush(Color.DarkSlateBlue);
				}
				return(darkSlateBlue);
			}
		}

		public static Brush DarkSlateGray {
			get {
				if (darkSlateGray==null) {
					darkSlateGray=new SolidBrush(Color.DarkSlateGray);
				}
				return(darkSlateGray);
			}
		}

		public static Brush DarkTurquoise {
			get {
				if (darkTurquoise==null) {
					darkTurquoise=new SolidBrush(Color.DarkTurquoise);
				}
				return(darkTurquoise);
			}
		}

		public static Brush DarkViolet {
			get {
				if (darkViolet==null) {
					darkViolet=new SolidBrush(Color.DarkViolet);
				}
				return(darkViolet);
			}
		}

		public static Brush DeepPink {
			get {
				if (deepPink==null) {
					deepPink=new SolidBrush(Color.DeepPink);
				}
				return(deepPink);
			}
		}

		public static Brush DeepSkyBlue {
			get {
				if (deepSkyBlue==null) {
					deepSkyBlue=new SolidBrush(Color.DeepSkyBlue);
				}
				return(deepSkyBlue);
			}
		}

		public static Brush DimGray {
			get {
				if (dimGray==null) {
					dimGray=new SolidBrush(Color.DimGray);
				}
				return(dimGray);
			}
		}

		public static Brush DodgerBlue {
			get {
				if (dodgerBlue==null) {
					dodgerBlue=new SolidBrush(Color.DodgerBlue);
				}
				return(dodgerBlue);
			}
		}

		public static Brush Firebrick {
			get {
				if (firebrick==null) {
					firebrick=new SolidBrush(Color.Firebrick);
				}
				return(firebrick);
			}
		}

		public static Brush FloralWhite {
			get {
				if (floralWhite==null) {
					floralWhite=new SolidBrush(Color.FloralWhite);
				}
				return(floralWhite);
			}
		}

		public static Brush ForestGreen {
			get {
				if (forestGreen==null) {
					forestGreen=new SolidBrush(Color.ForestGreen);
				}
				return(forestGreen);
			}
		}

		public static Brush Fuchsia {
			get {
				if (fuchsia==null) {
					fuchsia=new SolidBrush(Color.Fuchsia);
				}
				return(fuchsia);
			}
		}

		public static Brush Gainsboro {
			get {
				if (gainsboro==null) {
					gainsboro=new SolidBrush(Color.Gainsboro);
				}
				return(gainsboro);
			}
		}

		public static Brush GhostWhite {
			get {
				if (ghostWhite==null) {
					ghostWhite=new SolidBrush(Color.GhostWhite);
				}
				return(ghostWhite);
			}
		}

		public static Brush Gold {
			get {
				if (gold==null) {
					gold=new SolidBrush(Color.Gold);
				}
				return(gold);
			}
		}

		public static Brush Goldenrod {
			get {
				if (goldenrod==null) {
					goldenrod=new SolidBrush(Color.Goldenrod);
				}
				return(goldenrod);
			}
		}

		public static Brush Gray {
			get {
				if (gray==null) {
					gray=new SolidBrush(Color.Gray);
				}
				return(gray);
			}
		}

		public static Brush Green {
			get {
				if (green==null) {
					green=new SolidBrush(Color.Green);
				}
				return(green);
			}
		}

		public static Brush GreenYellow {
			get {
				if (greenYellow==null) {
					greenYellow=new SolidBrush(Color.GreenYellow);
				}
				return(greenYellow);
			}
		}

		public static Brush Honeydew {
			get {
				if (honeydew==null) {
					honeydew=new SolidBrush(Color.Honeydew);
				}
				return(honeydew);
			}
		}

		public static Brush HotPink {
			get {
				if (hotPink==null) {
					hotPink=new SolidBrush(Color.HotPink);
				}
				return(hotPink);
			}
		}

		public static Brush IndianRed {
			get {
				if (indianRed==null) {
					indianRed=new SolidBrush(Color.IndianRed);
				}
				return(indianRed);
			}
		}

		public static Brush Indigo {
			get {
				if (indigo==null) {
					indigo=new SolidBrush(Color.Indigo);
				}
				return(indigo);
			}
		}

		public static Brush Ivory {
			get {
				if (ivory==null) {
					ivory=new SolidBrush(Color.Ivory);
				}
				return(ivory);
			}
		}

		public static Brush Khaki {
			get {
				if (khaki==null) {
					khaki=new SolidBrush(Color.Khaki);
				}
				return(khaki);
			}
		}

		public static Brush Lavender {
			get {
				if (lavender==null) {
					lavender=new SolidBrush(Color.Lavender);
				}
				return(lavender);
			}
		}

		public static Brush LavenderBlush {
			get {
				if (lavenderBlush==null) {
					lavenderBlush=new SolidBrush(Color.LavenderBlush);
				}
				return(lavenderBlush);
			}
		}

		public static Brush LawnGreen {
			get {
				if (lawnGreen==null) {
					lawnGreen=new SolidBrush(Color.LawnGreen);
				}
				return(lawnGreen);
			}
		}

		public static Brush LemonChiffon {
			get {
				if (lemonChiffon==null) {
					lemonChiffon=new SolidBrush(Color.LemonChiffon);
				}
				return(lemonChiffon);
			}
		}

		public static Brush LightBlue {
			get {
				if (lightBlue==null) {
					lightBlue=new SolidBrush(Color.LightBlue);
				}
				return(lightBlue);
			}
		}

		public static Brush LightCoral {
			get {
				if (lightCoral==null) {
					lightCoral=new SolidBrush(Color.LightCoral);
				}
				return(lightCoral);
			}
		}

		public static Brush LightCyan {
			get {
				if (lightCyan==null) {
					lightCyan=new SolidBrush(Color.LightCyan);
				}
				return(lightCyan);
			}
		}

		public static Brush LightGoldenrodYellow {
			get {
				if (lightGoldenrodYellow==null) {
					lightGoldenrodYellow=new SolidBrush(Color.LightGoldenrodYellow);
				}
				return(lightGoldenrodYellow);
			}
		}

		public static Brush LightGray {
			get {
				if (lightGray==null) {
					lightGray=new SolidBrush(Color.LightGray);
				}
				return(lightGray);
			}
		}

		public static Brush LightGreen {
			get {
				if (lightGreen==null) {
					lightGreen=new SolidBrush(Color.LightGreen);
				}
				return(lightGreen);
			}
		}

		public static Brush LightPink {
			get {
				if (lightPink==null) {
					lightPink=new SolidBrush(Color.LightPink);
				}
				return(lightPink);
			}
		}

		public static Brush LightSalmon {
			get {
				if (lightSalmon==null) {
					lightSalmon=new SolidBrush(Color.LightSalmon);
				}
				return(lightSalmon);
			}
		}

		public static Brush LightSeaGreen {
			get {
				if (lightSeaGreen==null) {
					lightSeaGreen=new SolidBrush(Color.LightSeaGreen);
				}
				return(lightSeaGreen);
			}
		}

		public static Brush LightSkyBlue {
			get {
				if (lightSkyBlue==null) {
					lightSkyBlue=new SolidBrush(Color.LightSkyBlue);
				}
				return(lightSkyBlue);
			}
		}

		public static Brush LightSlateGray {
			get {
				if (lightSlateGray==null) {
					lightSlateGray=new SolidBrush(Color.LightSlateGray);
				}
				return(lightSlateGray);
			}
		}

		public static Brush LightSteelBlue {
			get {
				if (lightSteelBlue==null) {
					lightSteelBlue=new SolidBrush(Color.LightSteelBlue);
				}
				return(lightSteelBlue);
			}
		}

		public static Brush LightYellow {
			get {
				if (lightYellow==null) {
					lightYellow=new SolidBrush(Color.LightYellow);
				}
				return(lightYellow);
			}
		}

		public static Brush Lime {
			get {
				if (lime==null) {
					lime=new SolidBrush(Color.Lime);
				}
				return(lime);
			}
		}

		public static Brush LimeGreen {
			get {
				if (limeGreen==null) {
					limeGreen=new SolidBrush(Color.LimeGreen);
				}
				return(limeGreen);
			}
		}

		public static Brush Linen {
			get {
				if (linen==null) {
					linen=new SolidBrush(Color.Linen);
				}
				return(linen);
			}
		}

		public static Brush Magenta {
			get {
				if (magenta==null) {
					magenta=new SolidBrush(Color.Magenta);
				}
				return(magenta);
			}
		}

		public static Brush Maroon {
			get {
				if (maroon==null) {
					maroon=new SolidBrush(Color.Maroon);
				}
				return(maroon);
			}
		}

		public static Brush MediumAquamarine {
			get {
				if (mediumAquamarine==null) {
					mediumAquamarine=new SolidBrush(Color.MediumAquamarine);
				}
				return(mediumAquamarine);
			}
		}

		public static Brush MediumBlue {
			get {
				if (mediumBlue==null) {
					mediumBlue=new SolidBrush(Color.MediumBlue);
				}
				return(mediumBlue);
			}
		}

		public static Brush MediumOrchid {
			get {
				if (mediumOrchid==null) {
					mediumOrchid=new SolidBrush(Color.MediumOrchid);
				}
				return(mediumOrchid);
			}
		}

		public static Brush MediumPurple {
			get {
				if (mediumPurple==null) {
					mediumPurple=new SolidBrush(Color.MediumPurple);
				}
				return(mediumPurple);
			}
		}

		public static Brush MediumSeaGreen {
			get {
				if (mediumSeaGreen==null) {
					mediumSeaGreen=new SolidBrush(Color.MediumSeaGreen);
				}
				return(mediumSeaGreen);
			}
		}

		public static Brush MediumSlateBlue {
			get {
				if (mediumSlateBlue==null) {
					mediumSlateBlue=new SolidBrush(Color.MediumSlateBlue);
				}
				return(mediumSlateBlue);
			}
		}

		public static Brush MediumSpringGreen {
			get {
				if (mediumSpringGreen==null) {
					mediumSpringGreen=new SolidBrush(Color.MediumSpringGreen);
				}
				return(mediumSpringGreen);
			}
		}

		public static Brush MediumTurquoise {
			get {
				if (mediumTurquoise==null) {
					mediumTurquoise=new SolidBrush(Color.MediumTurquoise);
				}
				return(mediumTurquoise);
			}
		}

		public static Brush MediumVioletRed {
			get {
				if (mediumVioletRed==null) {
					mediumVioletRed=new SolidBrush(Color.MediumVioletRed);
				}
				return(mediumVioletRed);
			}
		}

		public static Brush MidnightBlue {
			get {
				if (midnightBlue==null) {
					midnightBlue=new SolidBrush(Color.MidnightBlue);
				}
				return(midnightBlue);
			}
		}

		public static Brush MintCream {
			get {
				if (mintCream==null) {
					mintCream=new SolidBrush(Color.MintCream);
				}
				return(mintCream);
			}
		}

		public static Brush MistyRose {
			get {
				if (mistyRose==null) {
					mistyRose=new SolidBrush(Color.MistyRose);
				}
				return(mistyRose);
			}
		}

		public static Brush Moccasin {
			get {
				if (moccasin==null) {
					moccasin=new SolidBrush(Color.Moccasin);
				}
				return(moccasin);
			}
		}

		public static Brush NavajoWhite {
			get {
				if (navajoWhite==null) {
					navajoWhite=new SolidBrush(Color.NavajoWhite);
				}
				return(navajoWhite);
			}
		}

		public static Brush Navy {
			get {
				if (navy==null) {
					navy=new SolidBrush(Color.Navy);
				}
				return(navy);
			}
		}

		public static Brush OldLace {
			get {
				if (oldLace==null) {
					oldLace=new SolidBrush(Color.OldLace);
				}
				return(oldLace);
			}
		}

		public static Brush Olive {
			get {
				if (olive==null) {
					olive=new SolidBrush(Color.Olive);
				}
				return(olive);
			}
		}

		public static Brush OliveDrab {
			get {
				if (oliveDrab==null) {
					oliveDrab=new SolidBrush(Color.OliveDrab);
				}
				return(oliveDrab);
			}
		}

		public static Brush Orange {
			get {
				if (orange==null) {
					orange=new SolidBrush(Color.Orange);
				}
				return(orange);
			}
		}

		public static Brush OrangeRed {
			get {
				if (orangeRed==null) {
					orangeRed=new SolidBrush(Color.OrangeRed);
				}
				return(orangeRed);
			}
		}

		public static Brush Orchid {
			get {
				if (orchid==null) {
					orchid=new SolidBrush(Color.Orchid);
				}
				return(orchid);
			}
		}

		public static Brush PaleGoldenrod {
			get {
				if (paleGoldenrod==null) {
					paleGoldenrod=new SolidBrush(Color.PaleGoldenrod);
				}
				return(paleGoldenrod);
			}
		}

		public static Brush PaleGreen {
			get {
				if (paleGreen==null) {
					paleGreen=new SolidBrush(Color.PaleGreen);
				}
				return(paleGreen);
			}
		}

		public static Brush PaleTurquoise {
			get {
				if (paleTurquoise==null) {
					paleTurquoise=new SolidBrush(Color.PaleTurquoise);
				}
				return(paleTurquoise);
			}
		}

		public static Brush PaleVioletRed {
			get {
				if (paleVioletRed==null) {
					paleVioletRed=new SolidBrush(Color.PaleVioletRed);
				}
				return(paleVioletRed);
			}
		}

		public static Brush PapayaWhip {
			get {
				if (papayaWhip==null) {
					papayaWhip=new SolidBrush(Color.PapayaWhip);
				}
				return(papayaWhip);
			}
		}

		public static Brush PeachPuff {
			get {
				if (peachPuff==null) {
					peachPuff=new SolidBrush(Color.PeachPuff);
				}
				return(peachPuff);
			}
		}

		public static Brush Peru {
			get {
				if (peru==null) {
					peru=new SolidBrush(Color.Peru);
				}
				return(peru);
			}
		}

		public static Brush Pink {
			get {
				if (pink==null) {
					pink=new SolidBrush(Color.Pink);
				}
				return(pink);
			}
		}

		public static Brush Plum {
			get {
				if (plum==null) {
					plum=new SolidBrush(Color.Plum);
				}
				return(plum);
			}
		}

		public static Brush PowderBlue {
			get {
				if (powderBlue==null) {
					powderBlue=new SolidBrush(Color.PowderBlue);
				}
				return(powderBlue);
			}
		}

		public static Brush Purple {
			get {
				if (purple==null) {
					purple=new SolidBrush(Color.Purple);
				}
				return(purple);
			}
		}

		public static Brush Red {
			get {
				if (red==null) {
					red=new SolidBrush(Color.Red);
				}
				return(red);
			}
		}

		public static Brush RosyBrown {
			get {
				if (rosyBrown==null) {
					rosyBrown=new SolidBrush(Color.RosyBrown);
				}
				return(rosyBrown);
			}
		}

		public static Brush RoyalBlue {
			get {
				if (royalBlue==null) {
					royalBlue=new SolidBrush(Color.RoyalBlue);
				}
				return(royalBlue);
			}
		}

		public static Brush SaddleBrown {
			get {
				if (saddleBrown==null) {
					saddleBrown=new SolidBrush(Color.SaddleBrown);
				}
				return(saddleBrown);
			}
		}

		public static Brush Salmon {
			get {
				if (salmon==null) {
					salmon=new SolidBrush(Color.Salmon);
				}
				return(salmon);
			}
		}

		public static Brush SandyBrown {
			get {
				if (sandyBrown==null) {
					sandyBrown=new SolidBrush(Color.SandyBrown);
				}
				return(sandyBrown);
			}
		}

		public static Brush SeaGreen {
			get {
				if (seaGreen==null) {
					seaGreen=new SolidBrush(Color.SeaGreen);
				}
				return(seaGreen);
			}
		}

		public static Brush SeaShell {
			get {
				if (seaShell==null) {
					seaShell=new SolidBrush(Color.SeaShell);
				}
				return(seaShell);
			}
		}

		public static Brush Sienna {
			get {
				if (sienna==null) {
					sienna=new SolidBrush(Color.Sienna);
				}
				return(sienna);
			}
		}

		public static Brush Silver {
			get {
				if (silver==null) {
					silver=new SolidBrush(Color.Silver);
				}
				return(silver);
			}
		}

		public static Brush SkyBlue {
			get {
				if (skyBlue==null) {
					skyBlue=new SolidBrush(Color.SkyBlue);
				}
				return(skyBlue);
			}
		}

		public static Brush SlateBlue {
			get {
				if (slateBlue==null) {
					slateBlue=new SolidBrush(Color.SlateBlue);
				}
				return(slateBlue);
			}
		}

		public static Brush SlateGray {
			get {
				if (slateGray==null) {
					slateGray=new SolidBrush(Color.SlateGray);
				}
				return(slateGray);
			}
		}

		public static Brush Snow {
			get {
				if (snow==null) {
					snow=new SolidBrush(Color.Snow);
				}
				return(snow);
			}
		}

		public static Brush SpringGreen {
			get {
				if (springGreen==null) {
					springGreen=new SolidBrush(Color.SpringGreen);
				}
				return(springGreen);
			}
		}

		public static Brush SteelBlue {
			get {
				if (steelBlue==null) {
					steelBlue=new SolidBrush(Color.SteelBlue);
				}
				return(steelBlue);
			}
		}

		public static Brush Tan {
			get {
				if (tan==null) {
					tan=new SolidBrush(Color.Tan);
				}
				return(tan);
			}
		}

		public static Brush Teal {
			get {
				if (teal==null) {
					teal=new SolidBrush(Color.Teal);
				}
				return(teal);
			}
		}

		public static Brush Thistle {
			get {
				if (thistle==null) {
					thistle=new SolidBrush(Color.Thistle);
				}
				return(thistle);
			}
		}

		public static Brush Tomato {
			get {
				if (tomato==null) {
					tomato=new SolidBrush(Color.Tomato);
				}
				return(tomato);
			}
		}

		public static Brush Transparent {
			get {
				if (transparent==null) {
					transparent=new SolidBrush(Color.Transparent);
				}
				return(transparent);
			}
		}

		public static Brush Turquoise {
			get {
				if (turquoise==null) {
					turquoise=new SolidBrush(Color.Turquoise);
				}
				return(turquoise);
			}
		}

		public static Brush Violet {
			get {
				if (violet==null) {
					violet=new SolidBrush(Color.Violet);
				}
				return(violet);
			}
		}

		public static Brush Wheat {
			get {
				if (wheat==null) {
					wheat=new SolidBrush(Color.Wheat);
				}
				return(wheat);
			}
		}

		public static Brush White {
			get {
				if (white==null) {
					white=new SolidBrush(Color.White);
				}
				return(white);
			}
		}

		public static Brush WhiteSmoke {
			get {
				if (whiteSmoke==null) {
					whiteSmoke=new SolidBrush(Color.WhiteSmoke);
				}
				return(whiteSmoke);
			}
		}

		public static Brush Yellow {
			get {
				if (yellow==null) {
					yellow=new SolidBrush(Color.Yellow);
				}
				return(yellow);
			}
		}

		public static Brush YellowGreen {
			get {
				if (yellowGreen==null) {
					yellowGreen=new SolidBrush(Color.YellowGreen);
				}
				return(yellowGreen);
			}
		}

	}
}