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 //      Sebastien Pouliot  <sebastien@ximian.com>
  10 //
  11 // (C) 2002 Dennis Hayes
  12 // (c) 2002 Ximian, Inc. (http://www.ximiam.com)
  13 // (C) 2005 HotFeet GmbH (http://www.hotfeet.ch)
  14 // Copyright (C) 2004,2006-2007 Novell, Inc (http://www.novell.com)
  15 //
  16 // Permission is hereby granted, free of charge, to any person obtaining
  17 // a copy of this software and associated documentation files (the
  18 // "Software"), to deal in the Software without restriction, including
  19 // without limitation the rights to use, copy, modify, merge, publish,
  20 // distribute, sublicense, and/or sell copies of the Software, and to
  21 // permit persons to whom the Software is furnished to do so, subject to
  22 // the following conditions:
  23 //
  24 // The above copyright notice and this permission notice shall be
  25 // included in all copies or substantial portions of the Software.
  26 //
  27 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  28 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  29 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  30 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  31 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  32 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  33 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  34 //
  35
  36 using System.ComponentModel;
  37 using System.Runtime.InteropServices;
  38
  39 namespace System.Drawing
  40 {
  41         [TypeConverter(typeof(ColorConverter))]
  42         [Editor ("System.Drawing.Design.ColorEditor, " + Consts.AssemblySystem_Drawing_Design, typeof (System.Drawing.Design.UITypeEditor))]
  43         [Serializable]
  44         public struct Color {
  45
  46                 // Private transparency (A) and R,G,B fields.
  47                 private long value;
  48
  49                 // The specs also indicate that all three of these properties are true
  50                 // if created with FromKnownColor or FromNamedColor, false otherwise (FromARGB).
  51                 // Per Microsoft and ECMA specs these varibles are set by which constructor is used, not by their values.
  52                 [Flags]
  53                 internal enum ColorType : short {
  54                         Empty=0,
  55                         Known=1,
  56                         ARGB=2,
  57                         Named=4,
  58                         System=8
  59                 }
  60
  61                 internal short state;
  62                 internal short knownColor;
  63 // #if ONLY_1_1
  64 // Mono bug #324144 is holding this change
  65                 // MS 1.1 requires this member to be present for serialization (not so in 2.0)
  66                 // however it's bad to keep a string (reference) in a struct
  67                 internal string name;
  68 // #endif
  69
  70                 public string Name {
  71                         get {
  72 #if NET_2_0_ONCE_MONO_BUG_324144_IS_FIXED
  73                                 if (IsNamedColor)
  74                                         return KnownColors.GetName (knownColor);
  75                                 else
  76                                         return String.Format ("{0:x}", ToArgb ());
  77 #else
  78                                 // name is required for serialization under 1.x, but not under 2.0
  79                                 if (name == null) {
  80                                         // Can happen with stuff deserialized from MS
  81                                         if (IsNamedColor)
  82                                                 name = KnownColors.GetName (knownColor);
  83                                         else
  84                                                 name = String.Format ("{0:x}", ToArgb ());
  85                                 }
  86                                 return name;
  87 #endif
  88                         }
  89                 }
  90
  91                 public bool IsKnownColor {
  92                         get{
  93                                 return (state & ((short) ColorType.Known)) != 0;
  94                         }
  95                 }
  96
  97                 public bool IsSystemColor {
  98                         get{
  99                                 return (state & ((short) ColorType.System)) != 0;
 100                         }
 101                 }
 102
 103                 public bool IsNamedColor {
 104                         get{
 105                                 return (state & (short)(ColorType.Known|ColorType.Named)) != 0;
 106                         }
 107                 }
 108
 109                 internal long Value {
 110                         get {
 111                                 // Optimization for known colors that were deserialized
 112                                 // from an MS serialized stream.
 113                                 if (value == 0 && IsKnownColor) {
 114                                         value = KnownColors.FromKnownColor ((KnownColor)knownColor).ToArgb () & 0xFFFFFFFF;
 115                                 }
 116                                 return value;
 117                         }
 118                         set { this.value = value; }
 119                 }
 120
 121                 public static Color FromArgb (int red, int green, int blue)
 122                 {
 123                         return FromArgb (255, red, green, blue);
 124                 }
 125
 126                 public static Color FromArgb (int alpha, int red, int green, int blue)
 127                 {
 128                         CheckARGBValues (alpha, red, green, blue);
 129                         Color color = new Color ();
 130                         color.state = (short) ColorType.ARGB;
 131                         color.Value = (int)((uint) alpha << 24) + (red << 16) + (green << 8) + blue;
 132                         return color;
 133                 }
 134
 135                 public int ToArgb()
 136                 {
 137                         return (int) Value;
 138                 }
 139
 140                 public static Color FromArgb (int alpha, Color baseColor)
 141                 {
 142                         return FromArgb (alpha, baseColor.R, baseColor.G, baseColor.B);
 143                 }
 144
 145                 public static Color FromArgb (int argb)
 146                 {
 147                         return FromArgb ((argb >> 24) & 0x0FF, (argb >> 16) & 0x0FF, (argb >> 8) & 0x0FF, argb & 0x0FF);
 148                 }
 149
 150                 public static Color FromKnownColor (KnownColor color)
 151                 {
 152                         return KnownColors.FromKnownColor (color);
 153                 }
 154
 155                 public static Color FromName (string name)
 156                 {
 157                         try {
 158                                 KnownColor kc = (KnownColor) Enum.Parse (typeof (KnownColor), name, true);
 159                                 return KnownColors.FromKnownColor (kc);
 160                         }
 161                         catch {
 162                                 // This is what it returns!
 163                                 Color d = FromArgb (0, 0, 0, 0);
 164                                 d.name = name;
 165                                 d.state |= (short) ColorType.Named;
 166                                 return d;
 167                         }
 168                 }
 169
 170
 171                 // -----------------------
 172                 // Public Shared Members
 173                 // -----------------------
 174
 175                 /// <summary>
 176                 ///     Empty Shared Field
 177                 /// </summary>
 178                 ///
 179                 /// <remarks>
 180                 ///     An uninitialized Color Structure
 181                 /// </remarks>
 182
 183                 public static readonly Color Empty;
 184
 185                 /// <summary>
 186                 ///     Equality Operator
 187                 /// </summary>
 188                 ///
 189                 /// <remarks>
 190                 ///     Compares two Color objects. The return value is
 191                 ///     based on the equivalence of the A,R,G,B properties
 192                 ///     of the two Colors.
 193                 /// </remarks>
 194
 195                 public static bool operator == (Color left, Color right)
 196                 {
 197                         if (left.Value != right.Value)
 198                                 return false;
 199                         if (left.IsNamedColor != right.IsNamedColor)
 200                                 return false;
 201                         if (left.IsSystemColor != right.IsSystemColor)
 202                                 return false;
 203                         if (left.IsEmpty != right.IsEmpty)
 204                                 return false;
 205                         if (left.IsNamedColor) {
 206                                 // then both are named (see previous check) and so we need to compare them
 207                                 // but otherwise we don't as it kills performance (Name calls String.Format)
 208                                 if (left.Name != right.Name)
 209                                         return false;
 210                         }
 211                         return true;
 212                 }
 213
 214                 /// <summary>
 215                 ///     Inequality Operator
 216                 /// </summary>
 217                 ///
 218                 /// <remarks>
 219                 ///     Compares two Color objects. The return value is
 220                 ///     based on the equivalence of the A,R,G,B properties
 221                 ///     of the two colors.
 222                 /// </remarks>
 223
 224                 public static bool operator != (Color left, Color right)
 225                 {
 226                         return ! (left == right);
 227                 }
 228
 229                 public float GetBrightness ()
 230                 {
 231                         byte minval = Math.Min (R, Math.Min (G, B));
 232                         byte maxval = Math.Max (R, Math.Max (G, B));
 233
 234                         return (float)(maxval + minval) / 510;
 235                 }
 236
 237                 public float GetSaturation ()
 238                 {
 239                         byte minval = (byte) Math.Min (R, Math.Min (G, B));
 240                         byte maxval = (byte) Math.Max (R, Math.Max (G, B));
 241
 242                         if (maxval == minval)
 243                                         return 0.0f;
 244
 245                         int sum = maxval + minval;
 246                         if (sum > 255)
 247                                 sum = 510 - sum;
 248
 249                         return (float)(maxval - minval) / sum;
 250                 }
 251
 252                 public float GetHue ()
 253                 {
 254                         int r = R;
 255                         int g = G;
 256                         int b = B;
 257                         byte minval = (byte) Math.Min (r, Math.Min (g, b));
 258                         byte maxval = (byte) Math.Max (r, Math.Max (g, b));
 259
 260                         if (maxval == minval)
 261                                         return 0.0f;
 262
 263                         float diff = (float)(maxval - minval);
 264                         float rnorm = (maxval - r) / diff;
 265                         float gnorm = (maxval - g) / diff;
 266                         float bnorm = (maxval - b) / diff;
 267
 268                         float hue = 0.0f;
 269                         if (r == maxval)
 270                                 hue = 60.0f * (6.0f + bnorm - gnorm);
 271                         if (g == maxval)
 272                                 hue = 60.0f * (2.0f + rnorm - bnorm);
 273                         if (b  == maxval)
 274                                 hue = 60.0f * (4.0f + gnorm - rnorm);
 275                         if (hue > 360.0f)
 276                                 hue = hue - 360.0f;
 277
 278                         return hue;
 279                 }
 280
 281                 // -----------------------
 282                 // Public Instance Members
 283                 // -----------------------
 284
 285                 /// <summary>
 286                 ///     ToKnownColor method
 287                 /// </summary>
 288                 ///
 289                 /// <remarks>
 290                 ///     Returns the KnownColor enum value for this color, 0 if is not known.
 291                 /// </remarks>
 292                 public KnownColor ToKnownColor ()
 293                 {
 294                         return (KnownColor) knownColor;
 295                 }
 296
 297                 /// <summary>
 298                 ///     IsEmpty Property
 299                 /// </summary>
 300                 ///
 301                 /// <remarks>
 302                 ///     Indicates transparent black. R,G,B = 0; A=0?
 303                 /// </remarks>
 304
 305                 public bool IsEmpty
 306                 {
 307                         get {
 308                                 return state == (short) ColorType.Empty;
 309                         }
 310                 }
 311
 312                 public byte A {
 313                         get { return (byte) (Value >> 24); }
 314                 }
 315
 316                 public byte R {
 317                         get { return (byte) (Value >> 16); }
 318                 }
 319
 320                 public byte G {
 321                         get { return (byte) (Value >> 8); }
 322                 }
 323
 324                 public byte B {
 325                         get { return (byte) Value; }
 326                 }
 327
 328                 /// <summary>
 329                 ///     Equals Method
 330                 /// </summary>
 331                 ///
 332                 /// <remarks>
 333                 ///     Checks equivalence of this Color and another object.
 334                 /// </remarks>
 335
 336                 public override bool Equals (object obj)
 337                 {
 338                         if (!(obj is Color))
 339                                 return false;
 340                         Color c = (Color) obj;
 341                         return this == c;
 342                 }
 343
 344                 /// <summary>
 345                 ///     Reference Equals Method
 346                 ///     Is commented out because this is handled by the base class.
 347                 ///     TODO: Is it correct to let the base class handel reference equals
 348                 /// </summary>
 349                 ///
 350                 /// <remarks>
 351                 ///     Checks equivalence of this Color and another object.
 352                 /// </remarks>
 353                 //public bool ReferenceEquals (object o)
 354                 //{
 355                 //      if (!(o is Color))return false;
 356                 //      return (this == (Color) o);
 357                 //}
 358
 359
 360
 361                 /// <summary>
 362                 ///     GetHashCode Method
 363                 /// </summary>
 364                 ///
 365                 /// <remarks>
 366                 ///     Calculates a hashing value.
 367                 /// </remarks>
 368
 369                 public override int GetHashCode ()
 370                 {
 371                         int hc = (int)(Value ^ (Value >> 32) ^ state ^ (knownColor >> 16));
 372                         if (IsNamedColor)
 373                                 hc ^= Name.GetHashCode ();
 374                         return hc;
 375                 }
 376
 377                 /// <summary>
 378                 ///     ToString Method
 379                 /// </summary>
 380                 ///
 381                 /// <remarks>
 382                 ///     Formats the Color as a string in ARGB notation.
 383                 /// </remarks>
 384
 385                 public override string ToString ()
 386                 {
 387                         if (IsEmpty)
 388                                 return "Color [Empty]";
 389
 390                         // Use the property here, not the field.
 391                         if (IsNamedColor)
 392                                 return "Color [" + Name + "]";
 393
 394                         return String.Format ("Color [A={0}, R={1}, G={2}, B={3}]", A, R, G, B);
 395                 }
 396
 397                 private static void CheckRGBValues (int red,int green,int blue)
 398                 {
 399                         if( (red > 255) || (red < 0))
 400                                 throw CreateColorArgumentException(red, "red");
 401                         if( (green > 255) || (green < 0))
 402                                 throw CreateColorArgumentException (green, "green");
 403                         if( (blue > 255) || (blue < 0))
 404                                 throw CreateColorArgumentException (blue, "blue");
 405                 }
 406
 407                 private static ArgumentException CreateColorArgumentException (int value, string color)
 408                 {
 409                         return new ArgumentException (string.Format ("'{0}' is not a valid"
 410                                 + " value for '{1}'. '{1}' should be greater or equal to 0 and"
 411                                 + " less than or equal to 255.", value, color));
 412                 }
 413
 414                 private static void CheckARGBValues (int alpha,int red,int green,int blue)
 415                 {
 416                         if( (alpha > 255) || (alpha < 0))
 417                                 throw CreateColorArgumentException (alpha, "alpha");
 418                         CheckRGBValues(red,green,blue);
 419                 }
 420
 421
 422                 static public Color Transparent {
 423                         get { return KnownColors.FromKnownColor (KnownColor.Transparent); }
 424                 }
 425
 426                 static public Color AliceBlue {
 427                         get { return KnownColors.FromKnownColor (KnownColor.AliceBlue); }
 428                 }
 429
 430                 static public Color AntiqueWhite {
 431                         get { return KnownColors.FromKnownColor (KnownColor.AntiqueWhite); }
 432                 }
 433
 434                 static public Color Aqua {
 435                         get { return KnownColors.FromKnownColor (KnownColor.Aqua); }
 436                 }
 437
 438                 static public Color Aquamarine {
 439                         get { return KnownColors.FromKnownColor (KnownColor.Aquamarine); }
 440                 }
 441
 442                 static public Color Azure {
 443                         get { return KnownColors.FromKnownColor (KnownColor.Azure); }
 444                 }
 445
 446                 static public Color Beige {
 447                         get { return KnownColors.FromKnownColor (KnownColor.Beige); }
 448                 }
 449
 450                 static public Color Bisque {
 451                         get { return KnownColors.FromKnownColor (KnownColor.Bisque); }
 452                 }
 453
 454                 static public Color Black {
 455                         get { return KnownColors.FromKnownColor (KnownColor.Black); }
 456                 }
 457
 458                 static public Color BlanchedAlmond {
 459                         get { return KnownColors.FromKnownColor (KnownColor.BlanchedAlmond); }
 460                 }
 461
 462                 static public Color Blue {
 463                         get { return KnownColors.FromKnownColor (KnownColor.Blue); }
 464                 }
 465
 466                 static public Color BlueViolet {
 467                         get { return KnownColors.FromKnownColor (KnownColor.BlueViolet); }
 468                 }
 469
 470                 static public Color Brown {
 471                         get { return KnownColors.FromKnownColor (KnownColor.Brown); }
 472                 }
 473
 474                 static public Color BurlyWood {
 475                         get { return KnownColors.FromKnownColor (KnownColor.BurlyWood); }
 476                 }
 477
 478                 static public Color CadetBlue {
 479                         get { return KnownColors.FromKnownColor (KnownColor.CadetBlue); }
 480                 }
 481
 482                 static public Color Chartreuse {
 483                         get { return KnownColors.FromKnownColor (KnownColor.Chartreuse); }
 484                 }
 485
 486                 static public Color Chocolate {
 487                         get { return KnownColors.FromKnownColor (KnownColor.Chocolate); }
 488                 }
 489
 490                 static public Color Coral {
 491                         get { return KnownColors.FromKnownColor (KnownColor.Coral); }
 492                 }
 493
 494                 static public Color CornflowerBlue {
 495                         get { return KnownColors.FromKnownColor (KnownColor.CornflowerBlue); }
 496                 }
 497
 498                 static public Color Cornsilk {
 499                         get { return KnownColors.FromKnownColor (KnownColor.Cornsilk); }
 500                 }
 501
 502                 static public Color Crimson {
 503                         get { return KnownColors.FromKnownColor (KnownColor.Crimson); }
 504                 }
 505
 506                 static public Color Cyan {
 507                         get { return KnownColors.FromKnownColor (KnownColor.Cyan); }
 508                 }
 509
 510                 static public Color DarkBlue {
 511                         get { return KnownColors.FromKnownColor (KnownColor.DarkBlue); }
 512                 }
 513
 514                 static public Color DarkCyan {
 515                         get { return KnownColors.FromKnownColor (KnownColor.DarkCyan); }
 516                 }
 517
 518                 static public Color DarkGoldenrod {
 519                         get { return KnownColors.FromKnownColor (KnownColor.DarkGoldenrod); }
 520                 }
 521
 522                 static public Color DarkGray {
 523                         get { return KnownColors.FromKnownColor (KnownColor.DarkGray); }
 524                 }
 525
 526                 static public Color DarkGreen {
 527                         get { return KnownColors.FromKnownColor (KnownColor.DarkGreen); }
 528                 }
 529
 530                 static public Color DarkKhaki {
 531                         get { return KnownColors.FromKnownColor (KnownColor.DarkKhaki); }
 532                 }
 533
 534                 static public Color DarkMagenta {
 535                         get { return KnownColors.FromKnownColor (KnownColor.DarkMagenta); }
 536                 }
 537
 538                 static public Color DarkOliveGreen {
 539                         get { return KnownColors.FromKnownColor (KnownColor.DarkOliveGreen); }
 540                 }
 541
 542                 static public Color DarkOrange {
 543                         get { return KnownColors.FromKnownColor (KnownColor.DarkOrange); }
 544                 }
 545
 546                 static public Color DarkOrchid {
 547                         get { return KnownColors.FromKnownColor (KnownColor.DarkOrchid); }
 548                 }
 549
 550                 static public Color DarkRed {
 551                         get { return KnownColors.FromKnownColor (KnownColor.DarkRed); }
 552                 }
 553
 554                 static public Color DarkSalmon {
 555                         get { return KnownColors.FromKnownColor (KnownColor.DarkSalmon); }
 556                 }
 557
 558                 static public Color DarkSeaGreen {
 559                         get { return KnownColors.FromKnownColor (KnownColor.DarkSeaGreen); }
 560                 }
 561
 562                 static public Color DarkSlateBlue {
 563                         get { return KnownColors.FromKnownColor (KnownColor.DarkSlateBlue); }
 564                 }
 565
 566                 static public Color DarkSlateGray {
 567                         get { return KnownColors.FromKnownColor (KnownColor.DarkSlateGray); }
 568                 }
 569
 570                 static public Color DarkTurquoise {
 571                         get { return KnownColors.FromKnownColor (KnownColor.DarkTurquoise); }
 572                 }
 573
 574                 static public Color DarkViolet {
 575                         get { return KnownColors.FromKnownColor (KnownColor.DarkViolet); }
 576                 }
 577
 578                 static public Color DeepPink {
 579                         get { return KnownColors.FromKnownColor (KnownColor.DeepPink); }
 580                 }
 581
 582                 static public Color DeepSkyBlue {
 583                         get { return KnownColors.FromKnownColor (KnownColor.DeepSkyBlue); }
 584                 }
 585
 586                 static public Color DimGray {
 587                         get { return KnownColors.FromKnownColor (KnownColor.DimGray); }
 588                 }
 589
 590                 static public Color DodgerBlue {
 591                         get { return KnownColors.FromKnownColor (KnownColor.DodgerBlue); }
 592                 }
 593
 594                 static public Color Firebrick {
 595                         get { return KnownColors.FromKnownColor (KnownColor.Firebrick); }
 596                 }
 597
 598                 static public Color FloralWhite {
 599                         get { return KnownColors.FromKnownColor (KnownColor.FloralWhite); }
 600                 }
 601
 602                 static public Color ForestGreen {
 603                         get { return KnownColors.FromKnownColor (KnownColor.ForestGreen); }
 604                 }
 605
 606                 static public Color Fuchsia {
 607                         get { return KnownColors.FromKnownColor (KnownColor.Fuchsia); }
 608                 }
 609
 610                 static public Color Gainsboro {
 611                         get { return KnownColors.FromKnownColor (KnownColor.Gainsboro); }
 612                 }
 613
 614                 static public Color GhostWhite {
 615                         get { return KnownColors.FromKnownColor (KnownColor.GhostWhite); }
 616                 }
 617
 618                 static public Color Gold {
 619                         get { return KnownColors.FromKnownColor (KnownColor.Gold); }
 620                 }
 621
 622                 static public Color Goldenrod {
 623                         get { return KnownColors.FromKnownColor (KnownColor.Goldenrod); }
 624                 }
 625
 626                 static public Color Gray {
 627                         get { return KnownColors.FromKnownColor (KnownColor.Gray); }
 628                 }
 629
 630                 static public Color Green {
 631                         get { return KnownColors.FromKnownColor (KnownColor.Green); }
 632                 }
 633
 634                 static public Color GreenYellow {
 635                         get { return KnownColors.FromKnownColor (KnownColor.GreenYellow); }
 636                 }
 637
 638                 static public Color Honeydew {
 639                         get { return KnownColors.FromKnownColor (KnownColor.Honeydew); }
 640                 }
 641
 642                 static public Color HotPink {
 643                         get { return KnownColors.FromKnownColor (KnownColor.HotPink); }
 644                 }
 645
 646                 static public Color IndianRed {
 647                         get { return KnownColors.FromKnownColor (KnownColor.IndianRed); }
 648                 }
 649
 650                 static public Color Indigo {
 651                         get { return KnownColors.FromKnownColor (KnownColor.Indigo); }
 652                 }
 653
 654                 static public Color Ivory {
 655                         get { return KnownColors.FromKnownColor (KnownColor.Ivory); }
 656                 }
 657
 658                 static public Color Khaki {
 659                         get { return KnownColors.FromKnownColor (KnownColor.Khaki); }
 660                 }
 661
 662                 static public Color Lavender {
 663                         get { return KnownColors.FromKnownColor (KnownColor.Lavender); }
 664                 }
 665
 666                 static public Color LavenderBlush {
 667                         get { return KnownColors.FromKnownColor (KnownColor.LavenderBlush); }
 668                 }
 669
 670                 static public Color LawnGreen {
 671                         get { return KnownColors.FromKnownColor (KnownColor.LawnGreen); }
 672                 }
 673
 674                 static public Color LemonChiffon {
 675                         get { return KnownColors.FromKnownColor (KnownColor.LemonChiffon); }
 676                 }
 677
 678                 static public Color LightBlue {
 679                         get { return KnownColors.FromKnownColor (KnownColor.LightBlue); }
 680                 }
 681
 682                 static public Color LightCoral {
 683                         get { return KnownColors.FromKnownColor (KnownColor.LightCoral); }
 684                 }
 685
 686                 static public Color LightCyan {
 687                         get { return KnownColors.FromKnownColor (KnownColor.LightCyan); }
 688                 }
 689
 690                 static public Color LightGoldenrodYellow {
 691                         get { return KnownColors.FromKnownColor (KnownColor.LightGoldenrodYellow); }
 692                 }
 693
 694                 static public Color LightGreen {
 695                         get { return KnownColors.FromKnownColor (KnownColor.LightGreen); }
 696                 }
 697
 698                 static public Color LightGray {
 699                         get { return KnownColors.FromKnownColor (KnownColor.LightGray); }
 700                 }
 701
 702                 static public Color LightPink {
 703                         get { return KnownColors.FromKnownColor (KnownColor.LightPink); }
 704                 }
 705
 706                 static public Color LightSalmon {
 707                         get { return KnownColors.FromKnownColor (KnownColor.LightSalmon); }
 708                 }
 709
 710                 static public Color LightSeaGreen {
 711                         get { return KnownColors.FromKnownColor (KnownColor.LightSeaGreen); }
 712                 }
 713
 714                 static public Color LightSkyBlue {
 715                         get { return KnownColors.FromKnownColor (KnownColor.LightSkyBlue); }
 716                 }
 717
 718                 static public Color LightSlateGray {
 719                         get { return KnownColors.FromKnownColor (KnownColor.LightSlateGray); }
 720                 }
 721
 722                 static public Color LightSteelBlue {
 723                         get { return KnownColors.FromKnownColor (KnownColor.LightSteelBlue); }
 724                 }
 725
 726                 static public Color LightYellow {
 727                         get { return KnownColors.FromKnownColor (KnownColor.LightYellow); }
 728                 }
 729
 730                 static public Color Lime {
 731                         get { return KnownColors.FromKnownColor (KnownColor.Lime); }
 732                 }
 733
 734                 static public Color LimeGreen {
 735                         get { return KnownColors.FromKnownColor (KnownColor.LimeGreen); }
 736                 }
 737
 738                 static public Color Linen {
 739                         get { return KnownColors.FromKnownColor (KnownColor.Linen); }
 740                 }
 741
 742                 static public Color Magenta {
 743                         get { return KnownColors.FromKnownColor (KnownColor.Magenta); }
 744                 }
 745
 746                 static public Color Maroon {
 747                         get { return KnownColors.FromKnownColor (KnownColor.Maroon); }
 748                 }
 749
 750                 static public Color MediumAquamarine {
 751                         get { return KnownColors.FromKnownColor (KnownColor.MediumAquamarine); }
 752                 }
 753
 754                 static public Color MediumBlue {
 755                         get { return KnownColors.FromKnownColor (KnownColor.MediumBlue); }
 756                 }
 757
 758                 static public Color MediumOrchid {
 759                         get { return KnownColors.FromKnownColor (KnownColor.MediumOrchid); }
 760                 }
 761
 762                 static public Color MediumPurple {
 763                         get { return KnownColors.FromKnownColor (KnownColor.MediumPurple); }
 764                 }
 765
 766                 static public Color MediumSeaGreen {
 767                         get { return KnownColors.FromKnownColor (KnownColor.MediumSeaGreen); }
 768                 }
 769
 770                 static public Color MediumSlateBlue {
 771                         get { return KnownColors.FromKnownColor (KnownColor.MediumSlateBlue); }
 772                 }
 773
 774                 static public Color MediumSpringGreen {
 775                         get { return KnownColors.FromKnownColor (KnownColor.MediumSpringGreen); }
 776                 }
 777
 778                 static public Color MediumTurquoise {
 779                         get { return KnownColors.FromKnownColor (KnownColor.MediumTurquoise); }
 780                 }
 781
 782                 static public Color MediumVioletRed {
 783                         get { return KnownColors.FromKnownColor (KnownColor.MediumVioletRed); }
 784                 }
 785
 786                 static public Color MidnightBlue {
 787                         get { return KnownColors.FromKnownColor (KnownColor.MidnightBlue); }
 788                 }
 789
 790                 static public Color MintCream {
 791                         get { return KnownColors.FromKnownColor (KnownColor.MintCream); }
 792                 }
 793
 794                 static public Color MistyRose {
 795                         get { return KnownColors.FromKnownColor (KnownColor.MistyRose); }
 796                 }
 797
 798                 static public Color Moccasin {
 799                         get { return KnownColors.FromKnownColor (KnownColor.Moccasin); }
 800                 }
 801
 802                 static public Color NavajoWhite {
 803                         get { return KnownColors.FromKnownColor (KnownColor.NavajoWhite); }
 804                 }
 805
 806                 static public Color Navy {
 807                         get { return KnownColors.FromKnownColor (KnownColor.Navy); }
 808                 }
 809
 810                 static public Color OldLace {
 811                         get { return KnownColors.FromKnownColor (KnownColor.OldLace); }
 812                 }
 813
 814                 static public Color Olive {
 815                         get { return KnownColors.FromKnownColor (KnownColor.Olive); }
 816                 }
 817
 818                 static public Color OliveDrab {
 819                         get { return KnownColors.FromKnownColor (KnownColor.OliveDrab); }
 820                 }
 821
 822                 static public Color Orange {
 823                         get { return KnownColors.FromKnownColor (KnownColor.Orange); }
 824                 }
 825
 826                 static public Color OrangeRed {
 827                         get { return KnownColors.FromKnownColor (KnownColor.OrangeRed); }
 828                 }
 829
 830                 static public Color Orchid {
 831                         get { return KnownColors.FromKnownColor (KnownColor.Orchid); }
 832                 }
 833
 834                 static public Color PaleGoldenrod {
 835                         get { return KnownColors.FromKnownColor (KnownColor.PaleGoldenrod); }
 836                 }
 837
 838                 static public Color PaleGreen {
 839                         get { return KnownColors.FromKnownColor (KnownColor.PaleGreen); }
 840                 }
 841
 842                 static public Color PaleTurquoise {
 843                         get { return KnownColors.FromKnownColor (KnownColor.PaleTurquoise); }
 844                 }
 845
 846                 static public Color PaleVioletRed {
 847                         get { return KnownColors.FromKnownColor (KnownColor.PaleVioletRed); }
 848                 }
 849
 850                 static public Color PapayaWhip {
 851                         get { return KnownColors.FromKnownColor (KnownColor.PapayaWhip); }
 852                 }
 853
 854                 static public Color PeachPuff {
 855                         get { return KnownColors.FromKnownColor (KnownColor.PeachPuff); }
 856                 }
 857
 858                 static public Color Peru {
 859                         get { return KnownColors.FromKnownColor (KnownColor.Peru); }
 860                 }
 861
 862                 static public Color Pink {
 863                         get { return KnownColors.FromKnownColor (KnownColor.Pink); }
 864                 }
 865
 866                 static public Color Plum {
 867                         get { return KnownColors.FromKnownColor (KnownColor.Plum); }
 868                 }
 869
 870                 static public Color PowderBlue {
 871                         get { return KnownColors.FromKnownColor (KnownColor.PowderBlue); }
 872                 }
 873
 874                 static public Color Purple {
 875                         get { return KnownColors.FromKnownColor (KnownColor.Purple); }
 876                 }
 877
 878                 static public Color Red {
 879                         get { return KnownColors.FromKnownColor (KnownColor.Red); }
 880                 }
 881
 882                 static public Color RosyBrown {
 883                         get { return KnownColors.FromKnownColor (KnownColor.RosyBrown); }
 884                 }
 885
 886                 static public Color RoyalBlue {
 887                         get { return KnownColors.FromKnownColor (KnownColor.RoyalBlue); }
 888                 }
 889
 890                 static public Color SaddleBrown {
 891                         get { return KnownColors.FromKnownColor (KnownColor.SaddleBrown); }
 892                 }
 893
 894                 static public Color Salmon {
 895                         get { return KnownColors.FromKnownColor (KnownColor.Salmon); }
 896                 }
 897
 898                 static public Color SandyBrown {
 899                         get { return KnownColors.FromKnownColor (KnownColor.SandyBrown); }
 900                 }
 901
 902                 static public Color SeaGreen {
 903                         get { return KnownColors.FromKnownColor (KnownColor.SeaGreen); }
 904                 }
 905
 906                 static public Color SeaShell {
 907                         get { return KnownColors.FromKnownColor (KnownColor.SeaShell); }
 908                 }
 909
 910                 static public Color Sienna {
 911                         get { return KnownColors.FromKnownColor (KnownColor.Sienna); }
 912                 }
 913
 914                 static public Color Silver {
 915                         get { return KnownColors.FromKnownColor (KnownColor.Silver); }
 916                 }
 917
 918                 static public Color SkyBlue {
 919                         get { return KnownColors.FromKnownColor (KnownColor.SkyBlue); }
 920                 }
 921
 922                 static public Color SlateBlue {
 923                         get { return KnownColors.FromKnownColor (KnownColor.SlateBlue); }
 924                 }
 925
 926                 static public Color SlateGray {
 927                         get { return KnownColors.FromKnownColor (KnownColor.SlateGray); }
 928                 }
 929
 930                 static public Color Snow {
 931                         get { return KnownColors.FromKnownColor (KnownColor.Snow); }
 932                 }
 933
 934                 static public Color SpringGreen {
 935                         get { return KnownColors.FromKnownColor (KnownColor.SpringGreen); }
 936                 }
 937
 938                 static public Color SteelBlue {
 939                         get { return KnownColors.FromKnownColor (KnownColor.SteelBlue); }
 940                 }
 941
 942                 static public Color Tan {
 943                         get { return KnownColors.FromKnownColor (KnownColor.Tan); }
 944                 }
 945
 946                 static public Color Teal {
 947                         get { return KnownColors.FromKnownColor (KnownColor.Teal); }
 948                 }
 949
 950                 static public Color Thistle {
 951                         get { return KnownColors.FromKnownColor (KnownColor.Thistle); }
 952                 }
 953
 954                 static public Color Tomato {
 955                         get { return KnownColors.FromKnownColor (KnownColor.Tomato); }
 956                 }
 957
 958                 static public Color Turquoise {
 959                         get { return KnownColors.FromKnownColor (KnownColor.Turquoise); }
 960                 }
 961
 962                 static public Color Violet {
 963                         get { return KnownColors.FromKnownColor (KnownColor.Violet); }
 964                 }
 965
 966                 static public Color Wheat {
 967                         get { return KnownColors.FromKnownColor (KnownColor.Wheat); }
 968                 }
 969
 970                 static public Color White {
 971                         get { return KnownColors.FromKnownColor (KnownColor.White); }
 972                 }
 973
 974                 static public Color WhiteSmoke {
 975                         get { return KnownColors.FromKnownColor (KnownColor.WhiteSmoke); }
 976                 }
 977
 978                 static public Color Yellow {
 979                         get { return KnownColors.FromKnownColor (KnownColor.Yellow); }
 980                 }
 981
 982                 static public Color YellowGreen {
 983                         get { return KnownColors.FromKnownColor (KnownColor.YellowGreen); }
 984                 }
 985         }
 986 }