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