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