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