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