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