mcs/class/System.Drawing/System.Drawing/Color.cs

   1 //
   2 // System.Drawing.Color.cs
   3 //
   4 // Authors:
   5 //      Dennis Hayes (dennish@raytek.com)
   6 //      Ben Houston  (ben@exocortex.org)
   7 //      Gonzalo Paniagua (gonzalo@ximian.com)
   8 //      Juraj Skripsky (juraj@hotfeet.ch)
   9 //
  10 // (C) 2002 Dennis Hayes
  11 // (c) 2002 Ximian, Inc. (http://www.ximiam.com)
  12 // (C) 2005 HotFeet GmbH (http://www.hotfeet.ch)
  13 //
  14 // TODO: Are the static/non static functions declared correctly
  15
  16 //
  17 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  18 //
  19 // Permission is hereby granted, free of charge, to any person obtaining
  20 // a copy of this software and associated documentation files (the
  21 // "Software"), to deal in the Software without restriction, including
  22 // without limitation the rights to use, copy, modify, merge, publish,
  23 // distribute, sublicense, and/or sell copies of the Software, and to
  24 // permit persons to whom the Software is furnished to do so, subject to
  25 // the following conditions:
  26 //
  27 // The above copyright notice and this permission notice shall be
  28 // included in all copies or substantial portions of the Software.
  29 //
  30 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  31 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  32 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  33 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  34 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  35 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  36 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  37 //
  38
  39 using System;
  40 using System.Collections;
  41 using System.Runtime.InteropServices;
  42 using System.ComponentModel;
  43 using System.Reflection;
  44
  45 namespace System.Drawing
  46 {
  47         [TypeConverter(typeof(ColorConverter))]
  48         [ComVisible (true)]
  49         [Editor ("System.Drawing.Design.ColorEditor, " + Consts.AssemblySystem_Drawing_Design, typeof (System.Drawing.Design.UITypeEditor))]
  50         [Serializable]
  51         public struct Color
  52         {
  53                 private static Hashtable namedColors;
  54                 private static Hashtable systemColors;
  55                 static Color [] knownColors;
  56
  57                 // Private transparancy (A) and R,G,B fields.
  58                 private byte a;
  59                 private byte r;
  60                 private byte g;
  61                 private byte b;
  62                 private static string creatingColorNames = "creatingColorNames";
  63
  64                 // The specs also indicate that all three of these propities are true
  65                 // if created with FromKnownColor or FromNamedColor, false otherwise (FromARGB).
  66                 // Per Microsoft and ECMA specs these varibles are set by which constructor is used, not by their values.
  67                 private bool isknowncolor;
  68                 private bool isnamedcolor;
  69                 private bool issystemcolor;
  70                 private KnownColor knownColor;
  71
  72                 private string myname;
  73
  74                 public string Name {
  75                         get{
  76                                 if (myname == null || myname == String.Empty)
  77                                         return String.Format ("{0:x}", ToArgb ());
  78                                 return myname;
  79                         }
  80                 }
  81
  82                 public bool IsKnownColor {
  83                         get{
  84                                 return isknowncolor;
  85                         }
  86                 }
  87
  88                 public bool IsSystemColor {
  89                         get{
  90                                 return issystemcolor;
  91                         }
  92                 }
  93
  94                 public bool IsNamedColor {
  95                         get{
  96                                 if (!isnamedcolor)
  97                                         return IsKnownColor;
  98                                 return isnamedcolor;
  99                         }
 100                 }
 101
 102
 103                 public static Color FromArgb (int red, int green, int blue)
 104                 {
 105                         return FromArgb (255, red, green, blue);
 106                 }
 107
 108                 public static Color FromArgb (int alpha, int red, int green, int blue)
 109                 {
 110                         CheckARGBValues (alpha, red, green, blue);
 111                         Color color = new Color ();
 112                         color.a = (byte) alpha;
 113                         color.r = (byte) red;
 114                         color.g = (byte) green;
 115                         color.b = (byte) blue;
 116                         color.myname = String.Empty;
 117                         return color;
 118                 }
 119
 120                 private static Color FromArgbNamed (int alpha, int red, int green, int blue, string name, KnownColor knownColor)
 121                 {
 122                         Color color = FromArgb (alpha, red, green, blue);
 123                         color.isknowncolor = true;
 124                         color.isnamedcolor = true;
 125                         //color.issystemcolor = false; //???
 126                         color.myname = name;
 127                         // FIXME: here happens SEGFAULT.
 128                         //color.knownColor = (KnownColor) Enum.Parse (typeof (KnownColor), name, false);
 129                         color.knownColor = knownColor;
 130                         return color;
 131                 }
 132
 133                 internal static Color FromArgbSystem (int alpha, int red, int green, int blue, string name, KnownColor knownColor)
 134                 {
 135                         Color color = FromArgbNamed (alpha, red, green, blue, name, knownColor);
 136                         color.issystemcolor = true;
 137                         return color;
 138                 }
 139
 140                 public int ToArgb()
 141                 {
 142                         return a << 24 | r << 16 | g << 8 | b;
 143                 }
 144
 145                 public static Color FromArgb (int alpha, Color baseColor)
 146                 {
 147                         return FromArgb (alpha, baseColor.r, baseColor.g, baseColor.b);
 148                 }
 149
 150                 public static Color FromArgb (int argb)
 151                 {
 152                         return FromArgb ((argb >> 24) & 0x0FF, (argb >> 16) & 0x0FF, (argb >> 8) & 0x0FF, argb & 0x0FF);
 153                 }
 154
 155                 public static Color FromKnownColor (KnownColor c)
 156                 {
 157                         if (knownColors == null)
 158                                 FillColorNames ();
 159
 160                         if (c < KnownColor.ActiveBorder || c > KnownColor.YellowGreen) {
 161                                 // This is what it returns!
 162                                 Color d = FromArgb (0, 0, 0, 0);
 163                                 d.myname = c.ToString ();
 164                                 d.isnamedcolor = true;
 165                                 d.knownColor = c;
 166                                 return d;
 167                         }
 168
 169                         return knownColors [(int) c];
 170                 }
 171
 172                 private static Hashtable GetColorHashtableFromType (Type type)
 173                 {
 174                         Hashtable colorHash = new Hashtable (CaseInsensitiveHashCodeProvider.Default,
 175                                                              CaseInsensitiveComparer.Default);
 176
 177                         PropertyInfo [] props = type.GetProperties ();
 178                         foreach (PropertyInfo prop in props){
 179                                 if (prop.PropertyType != typeof (Color))
 180                                         continue;
 181
 182                                 MethodInfo getget = prop.GetGetMethod ();
 183                                 if (getget == null || getget.IsStatic == false)
 184                                         continue;
 185
 186                                 object o = prop.GetValue (null, null);
 187                                 colorHash.Add (prop.Name, o);
 188
 189                                 Color c = (Color) o;
 190                                 knownColors [(int) c.knownColor] = c;
 191                         }
 192                         return colorHash;
 193                 }
 194
 195                 private static void FillColorNames ()
 196                 {
 197                         if (systemColors != null)
 198                                 return;
 199
 200                         lock (creatingColorNames) {
 201                                 if (systemColors != null)
 202                                         return;
 203
 204                                 knownColors = new Color [(int)KnownColor.YellowGreen + 1];
 205
 206                                 Hashtable colorHash = GetColorHashtableFromType (typeof (Color));
 207                                 namedColors = colorHash;
 208
 209                                 colorHash = GetColorHashtableFromType (typeof (SystemColors));
 210                                 systemColors = colorHash;
 211                         }
 212                 }
 213
 214                 public static Color FromName (string colorName)
 215                 {
 216                         object c = NamedColors [colorName];
 217                         if (c == null) {
 218                                 c = SystemColors [colorName];
 219                                 if (c == null) {
 220                                         // This is what it returns!
 221                                         Color d = FromArgb (0, 0, 0, 0);
 222                                         d.myname = colorName;
 223                                         d.isnamedcolor = true;
 224                                         c = d;
 225                                 }
 226                         }
 227
 228                         return (Color) c;
 229                 }
 230
 231                 internal static Hashtable NamedColors
 232                 {
 233                         get {
 234                                 FillColorNames ();
 235                                 return namedColors;
 236                         }
 237                 }
 238
 239                 internal static Hashtable SystemColors
 240                 {
 241                         get {
 242                                 FillColorNames ();
 243                                 return systemColors;
 244                         }
 245                 }
 246
 247                 // -----------------------
 248                 // Public Shared Members
 249                 // -----------------------
 250
 251                 /// <summary>
 252                 ///     Empty Shared Field
 253                 /// </summary>
 254                 ///
 255                 /// <remarks>
 256                 ///     An uninitialized Color Structure
 257                 /// </remarks>
 258
 259                 public static readonly Color Empty;
 260
 261                 /// <summary>
 262                 ///     Equality Operator
 263                 /// </summary>
 264                 ///
 265                 /// <remarks>
 266                 ///     Compares two Color objects. The return value is
 267                 ///     based on the equivalence of the A,R,G,B properties
 268                 ///     of the two Colors.
 269                 /// </remarks>
 270
 271                 public static bool operator == (Color colorA, Color colorB)
 272                 {
 273                         return ((colorA.a == colorB.a) && (colorA.r == colorB.r)
 274                         && (colorA.g == colorB.g) && (colorA.b == colorB.b) &&
 275                         (colorA.myname == colorB.myname));
 276                 }
 277
 278                 /// <summary>
 279                 ///     Inequality Operator
 280                 /// </summary>
 281                 ///
 282                 /// <remarks>
 283                 ///     Compares two Color objects. The return value is
 284                 ///     based on the equivalence of the A,R,G,B properties
 285                 ///     of the two colors.
 286                 /// </remarks>
 287
 288                 public static bool operator != (Color colorA, Color colorB)
 289                 {
 290                         return ((colorA.a != colorB.a) || (colorA.r != colorB.r)
 291                         || (colorA.g != colorB.g) || (colorA.b != colorB.b) ||
 292                         (colorA.myname != colorB.myname));
 293                 }
 294
 295                 public float GetBrightness ()
 296                 {
 297                         byte minval = Math.Min (r, Math.Min (g, b));\r
 298                         byte maxval = Math.Max (r, Math.Max (g, b));\r
 299         \r
 300                         return (float)(maxval + minval) / 510;\r
 301                 }
 302
 303                 public float GetSaturation ()
 304                 {
 305                         byte minval = Math.Min (r, Math.Min (g, b));\r
 306                         byte maxval = Math.Max (r, Math.Max (g, b));
 307
 308                         if (maxval == minval)\r
 309                                         return 0.0f;\r
 310
 311                         int sum = maxval + minval;
 312                         if (sum > 255)
 313                                 sum = 510 - sum;\r
 314
 315                         return (float)(maxval - minval) / sum;
 316                 }
 317
 318                 public float GetHue ()
 319                 {
 320                         byte minval = Math.Min (r, Math.Min (g, b));\r
 321                         byte maxval = Math.Max (r, Math.Max (g, b));
 322
 323                         if (maxval == minval)\r
 324                                         return 0.0f;\r
 325
 326                         float diff = (float)(maxval - minval);
 327                         float rnorm = (maxval - r) / diff;\r
 328                         float gnorm = (maxval - g) / diff;\r
 329                         float bnorm = (maxval - b) / diff;\r
 330
 331                         float hue = 0.0f;\r
 332                         if (r == maxval) \r
 333                                 hue = 60.0f * (6.0f + bnorm - gnorm);\r
 334                         if (g == maxval) \r
 335                                 hue = 60.0f * (2.0f + rnorm - bnorm);\r
 336                         if (b  == maxval) \r
 337                                 hue = 60.0f * (4.0f + gnorm - rnorm);\r
 338                         if (hue > 360.0f) \r
 339                                 hue = hue - 360.0f;
 340
 341                         return hue;\r
 342                 }
 343
 344                 // -----------------------
 345                 // Public Instance Members
 346                 // -----------------------
 347
 348                 /// <summary>
 349                 ///     ToKnownColor method
 350                 /// </summary>
 351                 ///
 352                 /// <remarks>
 353                 ///     Returns the KnownColor enum value for this color, 0 if is not known.
 354                 /// </remarks>
 355                 public KnownColor ToKnownColor ()
 356                 {
 357                         return knownColor;
 358                 }
 359
 360                 /// <summary>
 361                 ///     IsEmpty Property
 362                 /// </summary>
 363                 ///
 364                 /// <remarks>
 365                 ///     Indicates transparent black. R,G,B = 0; A=0?
 366                 /// </remarks>
 367
 368                 public bool IsEmpty
 369                 {
 370                         get {
 371                                 return (a + r + g + b) == 0;
 372                         }
 373                 }
 374
 375                 /// <summary>
 376                 ///     A Property
 377                 /// </summary>
 378                 ///
 379                 /// <remarks>
 380                 ///     The transparancy of the Color.
 381                 /// </remarks>
 382
 383                 public byte A
 384                 {
 385                         get {
 386                                 return a;
 387                         }
 388                 }
 389
 390                 /// <summary>
 391                 ///     R Property
 392                 /// </summary>
 393                 ///
 394                 /// <remarks>
 395                 ///     The red value of the Color.
 396                 /// </remarks>
 397
 398                 public byte R
 399                 {
 400                         get {
 401                                 return r;
 402                         }
 403                 }
 404
 405                 /// <summary>
 406                 ///     G Property
 407                 /// </summary>
 408                 ///
 409                 /// <remarks>
 410                 ///     The green value of the Color.
 411                 /// </remarks>
 412
 413                 public byte G
 414                 {
 415                         get {
 416                                 return g;
 417                         }
 418                 }
 419
 420                 /// <summary>
 421                 ///     B Property
 422                 /// </summary>
 423                 ///
 424                 /// <remarks>
 425                 ///     The blue value of the Color.
 426                 /// </remarks>
 427
 428                 public byte B
 429                 {
 430                         get {
 431                                 return b;
 432                         }
 433                 }
 434
 435                 /// <summary>
 436                 ///     Equals Method
 437                 /// </summary>
 438                 ///
 439                 /// <remarks>
 440                 ///     Checks equivalence of this Color and another object.
 441                 /// </remarks>
 442
 443                 public override bool Equals (object o)
 444                 {
 445                         if (!(o is Color))
 446                                 return false;
 447
 448                         Color c = (Color) o;
 449                         if (c.r == r && c.g == g && c.b == b) {
 450                                 if (myname != null || c.myname != null)
 451                                         return (myname == c.myname);
 452                                 return true;
 453                         }
 454                         return false;
 455                 }
 456
 457                 /// <summary>
 458                 ///     Reference Equals Method
 459                 ///     Is commented out because this is handled by the base class.
 460                 ///     TODO: Is it correct to let the base class handel reference equals
 461                 /// </summary>
 462                 ///
 463                 /// <remarks>
 464                 ///     Checks equivalence of this Color and another object.
 465                 /// </remarks>
 466                 //public bool ReferenceEquals (object o)
 467                 //{
 468                 //      if (!(o is Color))return false;
 469                 //      return (this == (Color) o);
 470                 //}
 471
 472
 473
 474                 /// <summary>
 475                 ///     GetHashCode Method
 476                 /// </summary>
 477                 ///
 478                 /// <remarks>
 479                 ///     Calculates a hashing value.
 480                 /// </remarks>
 481
 482                 public override int GetHashCode ()
 483                 {
 484                         return ToArgb().GetHashCode();
 485                 }
 486
 487                 /// <summary>
 488                 ///     ToString Method
 489                 /// </summary>
 490                 ///
 491                 /// <remarks>
 492                 ///     Formats the Color as a string in ARGB notation.
 493                 /// </remarks>
 494
 495                 public override string ToString ()
 496                 {
 497                         if (myname != "")
 498                                 return "Color [" + myname + "]";
 499
 500                         return String.Format ("Color [A={0}, R={1}, G={2}, B={3}]", a, r, g, b);
 501                 }
 502
 503                 private static void CheckRGBValues (int red,int green,int blue)
 504                 {
 505                         if( (red > 255) || (red < 0))
 506                                 throw new System.ArgumentOutOfRangeException
 507                                         ("red",red,"Value must be in the range 0 - 255");
 508                         if( (green > 255) || (green < 0))
 509                                 throw new System.ArgumentOutOfRangeException
 510                                         ("green",green,"Value must be in the range 0 - 255");
 511                         if( (blue > 255) || (blue < 0))
 512                                 throw new System.ArgumentOutOfRangeException
 513                                         ("blue",blue,"Value must be in the range 0 - 255");
 514                 }
 515
 516                 private static void CheckARGBValues (int alpha,int red,int green,int blue)
 517                 {
 518                         if( (alpha > 255) || (alpha < 0))
 519                                 throw new System.ArgumentOutOfRangeException
 520                                         ("alpha",alpha,"Value must be in the range 0 - 255");
 521                         CheckRGBValues(red,green,blue);
 522                 }
 523
 524                 //Documentation, do not remove!
 525                 //This is the program that was used to generate the C# source code below.
 526                 //using System;
 527                 //using System.Diagnostics;
 528                 //using System.Drawing;
 529                 //using System.Reflection;
 530                 //public class m {
 531                 //static void Main(string[] args)
 532                 //{
 533                 //      Type cType = typeof (Color);
 534                 //      PropertyInfo [] properties = cType.GetProperties ();
 535                 //      foreach (PropertyInfo property in properties) {
 536                 //              MethodInfo method = property.GetGetMethod();
 537                 //              if (method != null && method.IsStatic && method.ReturnType == cType) {
 538                 //                      Color c = (Color) method.Invoke( null, new object[0] );
 539                 //                      Console.WriteLine("static public Color " + property.Name);
 540                 //                      Console.WriteLine("{\t\n\tget {");
 541                 //                      Console.WriteLine("\t\treturn Color.FromArgbNamed ({0}, {1}, {2}, {3}, \"{4}\", KnownColor.{4});",
 542                 //                                              c.A, c.R, c.G, c.B, property.Name);
 543                 //                      Console.WriteLine("\t}");
 544                 //                      Console.WriteLine("}\n");
 545                 //              }
 546                 //      }
 547                 //}
 548                 //}
 549
 550                 static public Color Transparent
 551                 {
 552                         get {
 553                                 return Color.FromArgbNamed (0, 255, 255, 255, "Transparent", KnownColor.Transparent);
 554                         }
 555                 }
 556
 557                 static public Color AliceBlue
 558                 {
 559                         get {
 560                                 return Color.FromArgbNamed (255, 240, 248, 255, "AliceBlue", KnownColor.AliceBlue);
 561                         }
 562                 }
 563
 564                 static public Color AntiqueWhite
 565                 {
 566                         get {
 567                                 return Color.FromArgbNamed (255, 250, 235, 215, "AntiqueWhite", KnownColor.AntiqueWhite);
 568                         }
 569                 }
 570
 571                 static public Color Aqua
 572                 {
 573                         get {
 574                                 return Color.FromArgbNamed (255, 0, 255, 255, "Aqua", KnownColor.Aqua);
 575                         }
 576                 }
 577
 578                 static public Color Aquamarine
 579                 {
 580                         get {
 581                                 return Color.FromArgbNamed (255, 127, 255, 212, "Aquamarine", KnownColor.Aquamarine);
 582                         }
 583                 }
 584
 585                 static public Color Azure
 586                 {
 587                         get {
 588                                 return Color.FromArgbNamed (255, 240, 255, 255, "Azure", KnownColor.Azure);
 589                         }
 590                 }
 591
 592                 static public Color Beige
 593                 {
 594                         get {
 595                                 return Color.FromArgbNamed (255, 245, 245, 220, "Beige", KnownColor.Beige);
 596                         }
 597                 }
 598
 599                 static public Color Bisque
 600                 {
 601                         get {
 602                                 return Color.FromArgbNamed (255, 255, 228, 196, "Bisque", KnownColor.Bisque);
 603                         }
 604                 }
 605
 606                 static public Color Black
 607                 {
 608                         get {
 609                                 return Color.FromArgbNamed (255, 0, 0, 0, "Black", KnownColor.Black);
 610                         }
 611                 }
 612
 613                 static public Color BlanchedAlmond
 614                 {
 615                         get {
 616                                 return Color.FromArgbNamed (255, 255, 235, 205, "BlanchedAlmond", KnownColor.BlanchedAlmond);
 617                         }
 618                 }
 619
 620                 static public Color Blue
 621                 {
 622                         get {
 623                                 return Color.FromArgbNamed (255, 0, 0, 255, "Blue", KnownColor.Blue);
 624                         }
 625                 }
 626
 627                 static public Color BlueViolet
 628                 {
 629                         get {
 630                                 return Color.FromArgbNamed (255, 138, 43, 226, "BlueViolet", KnownColor.BlueViolet);
 631                         }
 632                 }
 633
 634                 static public Color Brown
 635                 {
 636                         get {
 637                                 return Color.FromArgbNamed (255, 165, 42, 42, "Brown", KnownColor.Brown);
 638                         }
 639                 }
 640
 641                 static public Color BurlyWood
 642                 {
 643                         get {
 644                                 return Color.FromArgbNamed (255, 222, 184, 135, "BurlyWood", KnownColor.BurlyWood);
 645                         }
 646                 }
 647
 648                 static public Color CadetBlue
 649                 {
 650                         get {
 651                                 return Color.FromArgbNamed (255, 95, 158, 160, "CadetBlue", KnownColor.CadetBlue);
 652                         }
 653                 }
 654
 655                 static public Color Chartreuse
 656                 {
 657                         get {
 658                                 return Color.FromArgbNamed (255, 127, 255, 0, "Chartreuse", KnownColor.Chartreuse);
 659                         }
 660                 }
 661
 662                 static public Color Chocolate
 663                 {
 664                         get {
 665                                 return Color.FromArgbNamed (255, 210, 105, 30, "Chocolate", KnownColor.Chocolate);
 666                         }
 667                 }
 668
 669                 static public Color Coral
 670                 {
 671                         get {
 672                                 return Color.FromArgbNamed (255, 255, 127, 80, "Coral", KnownColor.Coral);
 673                         }
 674                 }
 675
 676                 static public Color CornflowerBlue
 677                 {
 678                         get {
 679                                 return Color.FromArgbNamed (255, 100, 149, 237, "CornflowerBlue", KnownColor.CornflowerBlue);
 680                         }
 681                 }
 682
 683                 static public Color Cornsilk
 684                 {
 685                         get {
 686                                 return Color.FromArgbNamed (255, 255, 248, 220, "Cornsilk", KnownColor.Cornsilk);
 687                         }
 688                 }
 689
 690                 static public Color Crimson
 691                 {
 692                         get {
 693                                 return Color.FromArgbNamed (255, 220, 20, 60, "Crimson", KnownColor.Crimson);
 694                         }
 695                 }
 696
 697                 static public Color Cyan
 698                 {
 699                         get {
 700                                 return Color.FromArgbNamed (255, 0, 255, 255, "Cyan", KnownColor.Cyan);
 701                         }
 702                 }
 703
 704                 static public Color DarkBlue
 705                 {
 706                         get {
 707                                 return Color.FromArgbNamed (255, 0, 0, 139, "DarkBlue", KnownColor.DarkBlue);
 708                         }
 709                 }
 710
 711                 static public Color DarkCyan
 712                 {
 713                         get {
 714                                 return Color.FromArgbNamed (255, 0, 139, 139, "DarkCyan", KnownColor.DarkCyan);
 715                         }
 716                 }
 717
 718                 static public Color DarkGoldenrod
 719                 {
 720                         get {
 721                                 return Color.FromArgbNamed (255, 184, 134, 11, "DarkGoldenrod", KnownColor.DarkGoldenrod);
 722                         }
 723                 }
 724
 725                 static public Color DarkGray
 726                 {
 727                         get {
 728                                 return Color.FromArgbNamed (255, 169, 169, 169, "DarkGray", KnownColor.DarkGray);
 729                         }
 730                 }
 731
 732                 static public Color DarkGreen
 733                 {
 734                         get {
 735                                 return Color.FromArgbNamed (255, 0, 100, 0, "DarkGreen", KnownColor.DarkGreen);
 736                         }
 737                 }
 738
 739                 static public Color DarkKhaki
 740                 {
 741                         get {
 742                                 return Color.FromArgbNamed (255, 189, 183, 107, "DarkKhaki", KnownColor.DarkKhaki);
 743                         }
 744                 }
 745
 746                 static public Color DarkMagenta
 747                 {
 748                         get {
 749                                 return Color.FromArgbNamed (255, 139, 0, 139, "DarkMagenta", KnownColor.DarkMagenta);
 750                         }
 751                 }
 752
 753                 static public Color DarkOliveGreen
 754                 {
 755                         get {
 756                                 return Color.FromArgbNamed (255, 85, 107, 47, "DarkOliveGreen", KnownColor.DarkOliveGreen);
 757                         }
 758                 }
 759
 760                 static public Color DarkOrange
 761                 {
 762                         get {
 763                                 return Color.FromArgbNamed (255, 255, 140, 0, "DarkOrange", KnownColor.DarkOrange);
 764                         }
 765                 }
 766
 767                 static public Color DarkOrchid
 768                 {
 769                         get {
 770                                 return Color.FromArgbNamed (255, 153, 50, 204, "DarkOrchid", KnownColor.DarkOrchid);
 771                         }
 772                 }
 773
 774                 static public Color DarkRed
 775                 {
 776                         get {
 777                                 return Color.FromArgbNamed (255, 139, 0, 0, "DarkRed", KnownColor.DarkRed);
 778                         }
 779                 }
 780
 781                 static public Color DarkSalmon
 782                 {
 783                         get {
 784                                 return Color.FromArgbNamed (255, 233, 150, 122, "DarkSalmon", KnownColor.DarkSalmon);
 785                         }
 786                 }
 787
 788                 static public Color DarkSeaGreen
 789                 {
 790                         get {
 791                                 return Color.FromArgbNamed (255, 143, 188, 139, "DarkSeaGreen", KnownColor.DarkSeaGreen);
 792                         }
 793                 }
 794
 795                 static public Color DarkSlateBlue
 796                 {
 797                         get {
 798                                 return Color.FromArgbNamed (255, 72, 61, 139, "DarkSlateBlue", KnownColor.DarkSlateBlue);
 799                         }
 800                 }
 801
 802                 static public Color DarkSlateGray
 803                 {
 804                         get {
 805                                 return Color.FromArgbNamed (255, 47, 79, 79, "DarkSlateGray", KnownColor.DarkSlateGray);
 806                         }
 807                 }
 808
 809                 static public Color DarkTurquoise
 810                 {
 811                         get {
 812                                 return Color.FromArgbNamed (255, 0, 206, 209, "DarkTurquoise", KnownColor.DarkTurquoise);
 813                         }
 814                 }
 815
 816                 static public Color DarkViolet
 817                 {
 818                         get {
 819                                 return Color.FromArgbNamed (255, 148, 0, 211, "DarkViolet", KnownColor.DarkViolet);
 820                         }
 821                 }
 822
 823                 static public Color DeepPink
 824                 {
 825                         get {
 826                                 return Color.FromArgbNamed (255, 255, 20, 147, "DeepPink", KnownColor.DeepPink);
 827                         }
 828                 }
 829
 830                 static public Color DeepSkyBlue
 831                 {
 832                         get {
 833                                 return Color.FromArgbNamed (255, 0, 191, 255, "DeepSkyBlue", KnownColor.DeepSkyBlue);
 834                         }
 835                 }
 836
 837                 static public Color DimGray
 838                 {
 839                         get {
 840                                 return Color.FromArgbNamed (255, 105, 105, 105, "DimGray", KnownColor.DimGray);
 841                         }
 842                 }
 843
 844                 static public Color DodgerBlue
 845                 {
 846                         get {
 847                                 return Color.FromArgbNamed (255, 30, 144, 255, "DodgerBlue", KnownColor.DodgerBlue);
 848                         }
 849                 }
 850
 851                 static public Color Firebrick
 852                 {
 853                         get {
 854                                 return Color.FromArgbNamed (255, 178, 34, 34, "Firebrick", KnownColor.Firebrick);
 855                         }
 856                 }
 857
 858                 static public Color FloralWhite
 859                 {
 860                         get {
 861                                 return Color.FromArgbNamed (255, 255, 250, 240, "FloralWhite", KnownColor.FloralWhite);
 862                         }
 863                 }
 864
 865                 static public Color ForestGreen
 866                 {
 867                         get {
 868                                 return Color.FromArgbNamed (255, 34, 139, 34, "ForestGreen", KnownColor.ForestGreen);
 869                         }
 870                 }
 871
 872                 static public Color Fuchsia
 873                 {
 874                         get {
 875                                 return Color.FromArgbNamed (255, 255, 0, 255, "Fuchsia", KnownColor.Fuchsia);
 876                         }
 877                 }
 878
 879                 static public Color Gainsboro
 880                 {
 881                         get {
 882                                 return Color.FromArgbNamed (255, 220, 220, 220, "Gainsboro", KnownColor.Gainsboro);
 883                         }
 884                 }
 885
 886                 static public Color GhostWhite
 887                 {
 888                         get {
 889                                 return Color.FromArgbNamed (255, 248, 248, 255, "GhostWhite", KnownColor.GhostWhite);
 890                         }
 891                 }
 892
 893                 static public Color Gold
 894                 {
 895                         get {
 896                                 return Color.FromArgbNamed (255, 255, 215, 0, "Gold", KnownColor.Gold);
 897                         }
 898                 }
 899
 900                 static public Color Goldenrod
 901                 {
 902                         get {
 903                                 return Color.FromArgbNamed (255, 218, 165, 32, "Goldenrod", KnownColor.Goldenrod);
 904                         }
 905                 }
 906
 907                 static public Color Gray
 908                 {
 909                         get {
 910                                 return Color.FromArgbNamed (255, 128, 128, 128, "Gray", KnownColor.Gray);
 911                         }
 912                 }
 913
 914                 static public Color Green
 915                 {
 916                         get {
 917                                 // LAMESPEC: MS uses A=255, R=0, G=128, B=0 for Green Color,
 918                                 // which is seems to be wrong. G must be 255.
 919                                 return Color.FromArgbNamed (255, 0, 128, 0, "Green", KnownColor.Green);
 920                         }
 921                 }
 922
 923                 static public Color GreenYellow
 924                 {
 925                         get {
 926                                 return Color.FromArgbNamed (255, 173, 255, 47, "GreenYellow", KnownColor.GreenYellow);
 927                         }
 928                 }
 929
 930                 static public Color Honeydew
 931                 {
 932                         get {
 933                                 return Color.FromArgbNamed (255, 240, 255, 240, "Honeydew", KnownColor.Honeydew);
 934                         }
 935                 }
 936
 937                 static public Color HotPink
 938                 {
 939                         get {
 940                                 return Color.FromArgbNamed (255, 255, 105, 180, "HotPink", KnownColor.HotPink);
 941                         }
 942                 }
 943
 944                 static public Color IndianRed
 945                 {
 946                         get {
 947                                 return Color.FromArgbNamed (255, 205, 92, 92, "IndianRed", KnownColor.IndianRed);
 948                         }
 949                 }
 950
 951                 static public Color Indigo
 952                 {
 953                         get {
 954                                 return Color.FromArgbNamed (255, 75, 0, 130, "Indigo", KnownColor.Indigo);
 955                         }
 956                 }
 957
 958                 static public Color Ivory
 959                 {
 960                         get {
 961                                 return Color.FromArgbNamed (255, 255, 255, 240, "Ivory", KnownColor.Ivory);
 962                         }
 963                 }
 964
 965                 static public Color Khaki
 966                 {
 967                         get {
 968                                 return Color.FromArgbNamed (255, 240, 230, 140, "Khaki", KnownColor.Khaki);
 969                         }
 970                 }
 971
 972                 static public Color Lavender
 973                 {
 974                         get {
 975                                 return Color.FromArgbNamed (255, 230, 230, 250, "Lavender", KnownColor.Lavender);
 976                         }
 977                 }
 978
 979                 static public Color LavenderBlush
 980                 {
 981                         get {
 982                                 return Color.FromArgbNamed (255, 255, 240, 245, "LavenderBlush", KnownColor.LavenderBlush);
 983                         }
 984                 }
 985
 986                 static public Color LawnGreen
 987                 {
 988                         get {
 989                                 return Color.FromArgbNamed (255, 124, 252, 0, "LawnGreen", KnownColor.LawnGreen);
 990                         }
 991                 }
 992
 993                 static public Color LemonChiffon
 994                 {
 995                         get {
 996                                 return Color.FromArgbNamed (255, 255, 250, 205, "LemonChiffon", KnownColor.LemonChiffon);
 997                         }
 998                 }
 999
1000                 static public Color LightBlue
1001                 {
1002                         get {
1003                                 return Color.FromArgbNamed (255, 173, 216, 230, "LightBlue", KnownColor.LightBlue);
1004                         }
1005                 }
1006
1007                 static public Color LightCoral
1008                 {
1009                         get {
1010                                 return Color.FromArgbNamed (255, 240, 128, 128, "LightCoral", KnownColor.LightCoral);
1011                         }
1012                 }
1013
1014                 static public Color LightCyan
1015                 {
1016                         get {
1017                                 return Color.FromArgbNamed (255, 224, 255, 255, "LightCyan", KnownColor.LightCyan);
1018                         }
1019                 }
1020
1021                 static public Color LightGoldenrodYellow
1022                 {
1023                         get {
1024                                 return Color.FromArgbNamed (255, 250, 250, 210, "LightGoldenrodYellow", KnownColor.LightGoldenrodYellow);
1025                         }
1026                 }
1027
1028                 static public Color LightGreen
1029                 {
1030                         get {
1031                                 return Color.FromArgbNamed (255, 144, 238, 144, "LightGreen", KnownColor.LightGreen);
1032                         }
1033                 }
1034
1035                 static public Color LightGray
1036                 {
1037                         get {
1038                                 return Color.FromArgbNamed (255, 211, 211, 211, "LightGray", KnownColor.LightGray);
1039                         }
1040                 }
1041
1042                 static public Color LightPink
1043                 {
1044                         get {
1045                                 return Color.FromArgbNamed (255, 255, 182, 193, "LightPink", KnownColor.LightPink);
1046                         }
1047                 }
1048
1049                 static public Color LightSalmon
1050                 {
1051                         get {
1052                                 return Color.FromArgbNamed (255, 255, 160, 122, "LightSalmon", KnownColor.LightSalmon);
1053                         }
1054                 }
1055
1056                 static public Color LightSeaGreen
1057                 {
1058                         get {
1059                                 return Color.FromArgbNamed (255, 32, 178, 170, "LightSeaGreen", KnownColor.LightSeaGreen);
1060                         }
1061                 }
1062
1063                 static public Color LightSkyBlue
1064                 {
1065                         get {
1066                                 return Color.FromArgbNamed (255, 135, 206, 250, "LightSkyBlue", KnownColor.LightSkyBlue);
1067                         }
1068                 }
1069
1070                 static public Color LightSlateGray
1071                 {
1072                         get {
1073                                 return Color.FromArgbNamed (255, 119, 136, 153, "LightSlateGray", KnownColor.LightSlateGray);
1074                         }
1075                 }
1076
1077                 static public Color LightSteelBlue
1078                 {
1079                         get {
1080                                 return Color.FromArgbNamed (255, 176, 196, 222, "LightSteelBlue", KnownColor.LightSteelBlue);
1081                         }
1082                 }
1083
1084                 static public Color LightYellow
1085                 {
1086                         get {
1087                                 return Color.FromArgbNamed (255, 255, 255, 224, "LightYellow", KnownColor.LightYellow);
1088                         }
1089                 }
1090
1091                 static public Color Lime
1092                 {
1093                         get {
1094                                 return Color.FromArgbNamed (255, 0, 255, 0, "Lime", KnownColor.Lime);
1095                         }
1096                 }
1097
1098                 static public Color LimeGreen
1099                 {
1100                         get {
1101                                 return Color.FromArgbNamed (255, 50, 205, 50, "LimeGreen", KnownColor.LimeGreen);
1102                         }
1103                 }
1104
1105                 static public Color Linen
1106                 {
1107                         get {
1108                                 return Color.FromArgbNamed (255, 250, 240, 230, "Linen", KnownColor.Linen);
1109                         }
1110                 }
1111
1112                 static public Color Magenta
1113                 {
1114                         get {
1115                                 return Color.FromArgbNamed (255, 255, 0, 255, "Magenta", KnownColor.Magenta);
1116                         }
1117                 }
1118
1119                 static public Color Maroon
1120                 {
1121                         get {
1122                                 return Color.FromArgbNamed (255, 128, 0, 0, "Maroon", KnownColor.Maroon);
1123                         }
1124                 }
1125
1126                 static public Color MediumAquamarine
1127                 {
1128                         get {
1129                                 return Color.FromArgbNamed (255, 102, 205, 170, "MediumAquamarine", KnownColor.MediumAquamarine);
1130                         }
1131                 }
1132
1133                 static public Color MediumBlue
1134                 {
1135                         get {
1136                                 return Color.FromArgbNamed (255, 0, 0, 205, "MediumBlue", KnownColor.MediumBlue);
1137                         }
1138                 }
1139
1140                 static public Color MediumOrchid
1141                 {
1142                         get {
1143                                 return Color.FromArgbNamed (255, 186, 85, 211, "MediumOrchid", KnownColor.MediumOrchid);
1144                         }
1145                 }
1146
1147                 static public Color MediumPurple
1148                 {
1149                         get {
1150                                 return Color.FromArgbNamed (255, 147, 112, 219, "MediumPurple", KnownColor.MediumPurple);
1151                         }
1152                 }
1153
1154                 static public Color MediumSeaGreen
1155                 {
1156                         get {
1157                                 return Color.FromArgbNamed (255, 60, 179, 113, "MediumSeaGreen", KnownColor.MediumSeaGreen);
1158                         }
1159                 }
1160
1161                 static public Color MediumSlateBlue
1162                 {
1163                         get {
1164                                 return Color.FromArgbNamed (255, 123, 104, 238, "MediumSlateBlue", KnownColor.MediumSlateBlue);
1165                         }
1166                 }
1167
1168                 static public Color MediumSpringGreen
1169                 {
1170                         get {
1171                                 return Color.FromArgbNamed (255, 0, 250, 154, "MediumSpringGreen", KnownColor.MediumSpringGreen);
1172                         }
1173                 }
1174
1175                 static public Color MediumTurquoise
1176                 {
1177                         get {
1178                                 return Color.FromArgbNamed (255, 72, 209, 204, "MediumTurquoise", KnownColor.MediumTurquoise);
1179                         }
1180                 }
1181
1182                 static public Color MediumVioletRed
1183                 {
1184                         get {
1185                                 return Color.FromArgbNamed (255, 199, 21, 133, "MediumVioletRed", KnownColor.MediumVioletRed);
1186                         }
1187                 }
1188
1189                 static public Color MidnightBlue
1190                 {
1191                         get {
1192                                 return Color.FromArgbNamed (255, 25, 25, 112, "MidnightBlue", KnownColor.MidnightBlue);
1193                         }
1194                 }
1195
1196                 static public Color MintCream
1197                 {
1198                         get {
1199                                 return Color.FromArgbNamed (255, 245, 255, 250, "MintCream", KnownColor.MintCream);
1200                         }
1201                 }
1202
1203                 static public Color MistyRose
1204                 {
1205                         get {
1206                                 return Color.FromArgbNamed (255, 255, 228, 225, "MistyRose", KnownColor.MistyRose);
1207                         }
1208                 }
1209
1210                 static public Color Moccasin
1211                 {
1212                         get {
1213                                 return Color.FromArgbNamed (255, 255, 228, 181, "Moccasin", KnownColor.Moccasin);
1214                         }
1215                 }
1216
1217                 static public Color NavajoWhite
1218                 {
1219                         get {
1220                                 return Color.FromArgbNamed (255, 255, 222, 173, "NavajoWhite", KnownColor.NavajoWhite);
1221                         }
1222                 }
1223
1224                 static public Color Navy
1225                 {
1226                         get {
1227                                 return Color.FromArgbNamed (255, 0, 0, 128, "Navy", KnownColor.Navy);
1228                         }
1229                 }
1230
1231                 static public Color OldLace
1232                 {
1233                         get {
1234                                 return Color.FromArgbNamed (255, 253, 245, 230, "OldLace", KnownColor.OldLace);
1235                         }
1236                 }
1237
1238                 static public Color Olive
1239                 {
1240                         get {
1241                                 return Color.FromArgbNamed (255, 128, 128, 0, "Olive", KnownColor.Olive);
1242                         }
1243                 }
1244
1245                 static public Color OliveDrab
1246                 {
1247                         get {
1248                                 return Color.FromArgbNamed (255, 107, 142, 35, "OliveDrab", KnownColor.OliveDrab);
1249                         }
1250                 }
1251
1252                 static public Color Orange
1253                 {
1254                         get {
1255                                 return Color.FromArgbNamed (255, 255, 165, 0, "Orange", KnownColor.Orange);
1256                         }
1257                 }
1258
1259                 static public Color OrangeRed
1260                 {
1261                         get {
1262                                 return Color.FromArgbNamed (255, 255, 69, 0, "OrangeRed", KnownColor.OrangeRed);
1263                         }
1264                 }
1265
1266                 static public Color Orchid
1267                 {
1268                         get {
1269                                 return Color.FromArgbNamed (255, 218, 112, 214, "Orchid", KnownColor.Orchid);
1270                         }
1271                 }
1272
1273                 static public Color PaleGoldenrod
1274                 {
1275                         get {
1276                                 return Color.FromArgbNamed (255, 238, 232, 170, "PaleGoldenrod", KnownColor.PaleGoldenrod);
1277                         }
1278                 }
1279
1280                 static public Color PaleGreen
1281                 {
1282                         get {
1283                                 return Color.FromArgbNamed (255, 152, 251, 152, "PaleGreen", KnownColor.PaleGreen);
1284                         }
1285                 }
1286
1287                 static public Color PaleTurquoise
1288                 {
1289                         get {
1290                                 return Color.FromArgbNamed (255, 175, 238, 238, "PaleTurquoise", KnownColor.PaleTurquoise);
1291                         }
1292                 }
1293
1294                 static public Color PaleVioletRed
1295                 {
1296                         get {
1297                                 return Color.FromArgbNamed (255, 219, 112, 147, "PaleVioletRed", KnownColor.PaleVioletRed);
1298                         }
1299                 }
1300
1301                 static public Color PapayaWhip
1302                 {
1303                         get {
1304                                 return Color.FromArgbNamed (255, 255, 239, 213, "PapayaWhip", KnownColor.PapayaWhip);
1305                         }
1306                 }
1307
1308                 static public Color PeachPuff
1309                 {
1310                         get {
1311                                 return Color.FromArgbNamed (255, 255, 218, 185, "PeachPuff", KnownColor.PeachPuff);
1312                         }
1313                 }
1314
1315                 static public Color Peru
1316                 {
1317                         get {
1318                                 return Color.FromArgbNamed (255, 205, 133, 63, "Peru", KnownColor.Peru);
1319                         }
1320                 }
1321
1322                 static public Color Pink
1323                 {
1324                         get {
1325                                 return Color.FromArgbNamed (255, 255, 192, 203, "Pink", KnownColor.Pink);
1326                         }
1327                 }
1328
1329                 static public Color Plum
1330                 {
1331                         get {
1332                                 return Color.FromArgbNamed (255, 221, 160, 221, "Plum", KnownColor.Plum);
1333                         }
1334                 }
1335
1336                 static public Color PowderBlue
1337                 {
1338                         get {
1339                                 return Color.FromArgbNamed (255, 176, 224, 230, "PowderBlue", KnownColor.PowderBlue);
1340                         }
1341                 }
1342
1343                 static public Color Purple
1344                 {
1345                         get {
1346                                 return Color.FromArgbNamed (255, 128, 0, 128, "Purple", KnownColor.Purple);
1347                         }
1348                 }
1349
1350                 static public Color Red
1351                 {
1352                         get {
1353                                 return Color.FromArgbNamed (255, 255, 0, 0, "Red", KnownColor.Red);
1354                         }
1355                 }
1356
1357                 static public Color RosyBrown
1358                 {
1359                         get {
1360                                 return Color.FromArgbNamed (255, 188, 143, 143, "RosyBrown", KnownColor.RosyBrown);
1361                         }
1362                 }
1363
1364                 static public Color RoyalBlue
1365                 {
1366                         get {
1367                                 return Color.FromArgbNamed (255, 65, 105, 225, "RoyalBlue", KnownColor.RoyalBlue);
1368                         }
1369                 }
1370
1371                 static public Color SaddleBrown
1372                 {
1373                         get {
1374                                 return Color.FromArgbNamed (255, 139, 69, 19, "SaddleBrown", KnownColor.SaddleBrown);
1375                         }
1376                 }
1377
1378                 static public Color Salmon
1379                 {
1380                         get {
1381                                 return Color.FromArgbNamed (255, 250, 128, 114, "Salmon", KnownColor.Salmon);
1382                         }
1383                 }
1384
1385                 static public Color SandyBrown
1386                 {
1387                         get {
1388                                 return Color.FromArgbNamed (255, 244, 164, 96, "SandyBrown", KnownColor.SandyBrown);
1389                         }
1390                 }
1391
1392                 static public Color SeaGreen
1393                 {
1394                         get {
1395                                 return Color.FromArgbNamed (255, 46, 139, 87, "SeaGreen", KnownColor.SeaGreen);
1396                         }
1397                 }
1398
1399                 static public Color SeaShell
1400                 {
1401                         get {
1402                                 return Color.FromArgbNamed (255, 255, 245, 238, "SeaShell", KnownColor.SeaShell);
1403                         }
1404                 }
1405
1406                 static public Color Sienna
1407                 {
1408                         get {
1409                                 return Color.FromArgbNamed (255, 160, 82, 45, "Sienna", KnownColor.Sienna);
1410                         }
1411                 }
1412
1413                 static public Color Silver
1414                 {
1415                         get {
1416                                 return Color.FromArgbNamed (255, 192, 192, 192, "Silver", KnownColor.Silver);
1417                         }
1418                 }
1419
1420                 static public Color SkyBlue
1421                 {
1422                         get {
1423                                 return Color.FromArgbNamed (255, 135, 206, 235, "SkyBlue", KnownColor.SkyBlue);
1424                         }
1425                 }
1426
1427                 static public Color SlateBlue
1428                 {
1429                         get {
1430                                 return Color.FromArgbNamed (255, 106, 90, 205, "SlateBlue", KnownColor.SlateBlue);
1431                         }
1432                 }
1433
1434                 static public Color SlateGray
1435                 {
1436                         get {
1437                                 return Color.FromArgbNamed (255, 112, 128, 144, "SlateGray", KnownColor.SlateGray);
1438                         }
1439                 }
1440
1441                 static public Color Snow
1442                 {
1443                         get {
1444                                 return Color.FromArgbNamed (255, 255, 250, 250, "Snow", KnownColor.Snow);
1445                         }
1446                 }
1447
1448                 static public Color SpringGreen
1449                 {
1450                         get {
1451                                 return Color.FromArgbNamed (255, 0, 255, 127, "SpringGreen", KnownColor.SpringGreen);
1452                         }
1453                 }
1454
1455                 static public Color SteelBlue
1456                 {
1457                         get {
1458                                 return Color.FromArgbNamed (255, 70, 130, 180, "SteelBlue", KnownColor.SteelBlue);
1459                         }
1460                 }
1461
1462                 static public Color Tan
1463                 {
1464                         get {
1465                                 return Color.FromArgbNamed (255, 210, 180, 140, "Tan", KnownColor.Tan);
1466                         }
1467                 }
1468
1469                 static public Color Teal
1470                 {
1471                         get {
1472                                 return Color.FromArgbNamed (255, 0, 128, 128, "Teal", KnownColor.Teal);
1473                         }
1474                 }
1475
1476                 static public Color Thistle
1477                 {
1478                         get {
1479                                 return Color.FromArgbNamed (255, 216, 191, 216, "Thistle", KnownColor.Thistle);
1480                         }
1481                 }
1482
1483                 static public Color Tomato
1484                 {
1485                         get {
1486                                 return Color.FromArgbNamed (255, 255, 99, 71, "Tomato", KnownColor.Tomato);
1487                         }
1488                 }
1489
1490                 static public Color Turquoise
1491                 {
1492                         get {
1493                                 return Color.FromArgbNamed (255, 64, 224, 208, "Turquoise", KnownColor.Turquoise);
1494                         }
1495                 }
1496
1497                 static public Color Violet
1498                 {
1499                         get {
1500                                 return Color.FromArgbNamed (255, 238, 130, 238, "Violet", KnownColor.Violet);
1501                         }
1502                 }
1503
1504                 static public Color Wheat
1505                 {
1506                         get {
1507                                 return Color.FromArgbNamed (255, 245, 222, 179, "Wheat", KnownColor.Wheat);
1508                         }
1509                 }
1510
1511                 static public Color White
1512                 {
1513                         get {
1514                                 return Color.FromArgbNamed (255, 255, 255, 255, "White", KnownColor.White);
1515                         }
1516                 }
1517
1518                 static public Color WhiteSmoke
1519                 {
1520                         get {
1521                                 return Color.FromArgbNamed (255, 245, 245, 245, "WhiteSmoke", KnownColor.WhiteSmoke);
1522                         }
1523                 }
1524
1525                 static public Color Yellow
1526                 {
1527                         get {
1528                                 return Color.FromArgbNamed (255, 255, 255, 0, "Yellow", KnownColor.Yellow);
1529                         }
1530                 }
1531
1532                 static public Color YellowGreen
1533                 {
1534                         get {
1535                                 return Color.FromArgbNamed (255, 154, 205, 50, "YellowGreen", KnownColor.YellowGreen);
1536                         }
1537                 }
1538         }
1539 }