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