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