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