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