class/System.Drawing/System.Drawing/Brushes.cs

   1 //
   2 // System.Windows.Drawing.Brushes.cs
   3 //
   4 // Authors:
   5 //   Dennis Hayes (dennish@Raytek.com)
   6 //      Suesan Chaney
   7 //        Peter Bartok (pbartok@novell.com)
   8 //
   9 // (C) Ximian, Inc., 2002 http://www.ximian.com
  10 // (C) Novell, Inc., 2004 http://www.novell.com
  11 //
  12
  13 //
  14 // Copyright (C) 2004 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;
  37
  38 namespace System.Drawing
  39 {
  40         public sealed class Brushes
  41         {
  42                 static SolidBrush aliceBlue;
  43                 static SolidBrush antiqueWhite;
  44                 static SolidBrush aqua;
  45                 static SolidBrush aquamarine;
  46                 static SolidBrush azure;
  47                 static SolidBrush beige;
  48                 static SolidBrush bisque;
  49                 static SolidBrush black;
  50                 static SolidBrush blanchedAlmond;
  51                 static SolidBrush blue;
  52                 static SolidBrush blueViolet;
  53                 static SolidBrush brown;
  54                 static SolidBrush burlyWood;
  55                 static SolidBrush cadetBlue;
  56                 static SolidBrush chartreuse;
  57                 static SolidBrush chocolate;
  58                 static SolidBrush coral;
  59                 static SolidBrush cornflowerBlue;
  60                 static SolidBrush cornsilk;
  61                 static SolidBrush crimson;
  62                 static SolidBrush cyan;
  63                 static SolidBrush darkBlue;
  64                 static SolidBrush darkCyan;
  65                 static SolidBrush darkGoldenrod;
  66                 static SolidBrush darkGray;
  67                 static SolidBrush darkGreen;
  68                 static SolidBrush darkKhaki;
  69                 static SolidBrush darkMagenta;
  70                 static SolidBrush darkOliveGreen;
  71                 static SolidBrush darkOrange;
  72                 static SolidBrush darkOrchid;
  73                 static SolidBrush darkRed;
  74                 static SolidBrush darkSalmon;
  75                 static SolidBrush darkSeaGreen;
  76                 static SolidBrush darkSlateBlue;
  77                 static SolidBrush darkSlateGray;
  78                 static SolidBrush darkTurquoise;
  79                 static SolidBrush darkViolet;
  80                 static SolidBrush deepPink;
  81                 static SolidBrush deepSkyBlue;
  82                 static SolidBrush dimGray;
  83                 static SolidBrush dodgerBlue;
  84                 static SolidBrush firebrick;
  85                 static SolidBrush floralWhite;
  86                 static SolidBrush forestGreen;
  87                 static SolidBrush fuchsia;
  88                 static SolidBrush gainsboro;
  89                 static SolidBrush ghostWhite;
  90                 static SolidBrush gold;
  91                 static SolidBrush goldenrod;
  92                 static SolidBrush gray;
  93                 static SolidBrush green;
  94                 static SolidBrush greenYellow;
  95                 static SolidBrush honeydew;
  96                 static SolidBrush hotPink;
  97                 static SolidBrush indianRed;
  98                 static SolidBrush indigo;
  99                 static SolidBrush ivory;
 100                 static SolidBrush khaki;
 101                 static SolidBrush lavender;
 102                 static SolidBrush lavenderBlush;
 103                 static SolidBrush lawnGreen;
 104                 static SolidBrush lemonChiffon;
 105                 static SolidBrush lightBlue;
 106                 static SolidBrush lightCoral;
 107                 static SolidBrush lightCyan;
 108                 static SolidBrush lightGoldenrodYellow;
 109                 static SolidBrush lightGray;
 110                 static SolidBrush lightGreen;
 111                 static SolidBrush lightPink;
 112                 static SolidBrush lightSalmon;
 113                 static SolidBrush lightSeaGreen;
 114                 static SolidBrush lightSkyBlue;
 115                 static SolidBrush lightSlateGray;
 116                 static SolidBrush lightSteelBlue;
 117                 static SolidBrush lightYellow;
 118                 static SolidBrush lime;
 119                 static SolidBrush limeGreen;
 120                 static SolidBrush linen;
 121                 static SolidBrush magenta;
 122                 static SolidBrush maroon;
 123                 static SolidBrush mediumAquamarine;
 124                 static SolidBrush mediumBlue;
 125                 static SolidBrush mediumOrchid;
 126                 static SolidBrush mediumPurple;
 127                 static SolidBrush mediumSeaGreen;
 128                 static SolidBrush mediumSlateBlue;
 129                 static SolidBrush mediumSpringGreen;
 130                 static SolidBrush mediumTurquoise;
 131                 static SolidBrush mediumVioletRed;
 132                 static SolidBrush midnightBlue;
 133                 static SolidBrush mintCream;
 134                 static SolidBrush mistyRose;
 135                 static SolidBrush moccasin;
 136                 static SolidBrush navajoWhite;
 137                 static SolidBrush navy;
 138                 static SolidBrush oldLace;
 139                 static SolidBrush olive;
 140                 static SolidBrush oliveDrab;
 141                 static SolidBrush orange;
 142                 static SolidBrush orangeRed;
 143                 static SolidBrush orchid;
 144                 static SolidBrush paleGoldenrod;
 145                 static SolidBrush paleGreen;
 146                 static SolidBrush paleTurquoise;
 147                 static SolidBrush paleVioletRed;
 148                 static SolidBrush papayaWhip;
 149                 static SolidBrush peachPuff;
 150                 static SolidBrush peru;
 151                 static SolidBrush pink;
 152                 static SolidBrush plum;
 153                 static SolidBrush powderBlue;
 154                 static SolidBrush purple;
 155                 static SolidBrush red;
 156                 static SolidBrush rosyBrown;
 157                 static SolidBrush royalBlue;
 158                 static SolidBrush saddleBrown;
 159                 static SolidBrush salmon;
 160                 static SolidBrush sandyBrown;
 161                 static SolidBrush seaGreen;
 162                 static SolidBrush seaShell;
 163                 static SolidBrush sienna;
 164                 static SolidBrush silver;
 165                 static SolidBrush skyBlue;
 166                 static SolidBrush slateBlue;
 167                 static SolidBrush slateGray;
 168                 static SolidBrush snow;
 169                 static SolidBrush springGreen;
 170                 static SolidBrush steelBlue;
 171                 static SolidBrush tan;
 172                 static SolidBrush teal;
 173                 static SolidBrush thistle;
 174                 static SolidBrush tomato;
 175                 static SolidBrush transparent;
 176                 static SolidBrush turquoise;
 177                 static SolidBrush violet;
 178                 static SolidBrush wheat;
 179                 static SolidBrush white;
 180                 static SolidBrush whiteSmoke;
 181                 static SolidBrush yellow;
 182                 static SolidBrush yellowGreen;
 183
 184                 // We intentionally do not set the is_modifiable=false flag on
 185                 // the brushes, to stay Microsoft compatible
 186
 187                 private Brushes () { }
 188
 189                 public static Brush AliceBlue {
 190                         get {
 191                                 if (aliceBlue==null) {
 192                                         aliceBlue=new SolidBrush(Color.AliceBlue);
 193                                 }
 194                                 return(aliceBlue);
 195                         }
 196                 }
 197
 198                 public static Brush AntiqueWhite {
 199                         get {
 200                                 if (antiqueWhite==null) {
 201                                         antiqueWhite=new SolidBrush(Color.AntiqueWhite);
 202                                 }
 203                                 return(antiqueWhite);
 204                         }
 205                 }
 206
 207                 public static Brush Aqua {
 208                         get {
 209                                 if (aqua==null) {
 210                                         aqua=new SolidBrush(Color.Aqua);
 211                                 }
 212                                 return(aqua);
 213                         }
 214                 }
 215
 216                 public static Brush Aquamarine {
 217                         get {
 218                                 if (aquamarine==null) {
 219                                         aquamarine=new SolidBrush(Color.Aquamarine);
 220                                 }
 221                                 return(aquamarine);
 222                         }
 223                 }
 224
 225                 public static Brush Azure {
 226                         get {
 227                                 if (azure==null) {
 228                                         azure=new SolidBrush(Color.Azure);
 229                                 }
 230                                 return(azure);
 231                         }
 232                 }
 233
 234                 public static Brush Beige {
 235                         get {
 236                                 if (beige==null) {
 237                                         beige=new SolidBrush(Color.Beige);
 238                                 }
 239                                 return(beige);
 240                         }
 241                 }
 242
 243                 public static Brush Bisque {
 244                         get {
 245                                 if (bisque==null) {
 246                                         bisque=new SolidBrush(Color.Bisque);
 247                                 }
 248                                 return(bisque);
 249                         }
 250                 }
 251
 252                 public static Brush Black {
 253                         get {
 254                                 if (black==null) {
 255                                         black=new SolidBrush(Color.Black);
 256                                 }
 257                                 return(black);
 258                         }
 259                 }
 260
 261                 public static Brush BlanchedAlmond {
 262                         get {
 263                                 if (blanchedAlmond==null) {
 264                                         blanchedAlmond=new SolidBrush(Color.BlanchedAlmond);
 265                                 }
 266                                 return(blanchedAlmond);
 267                         }
 268                 }
 269
 270                 public static Brush Blue {
 271                         get {
 272                                 if (blue==null) {
 273                                         blue=new SolidBrush(Color.Blue);
 274                                 }
 275                                 return(blue);
 276                         }
 277                 }
 278
 279                 public static Brush BlueViolet {
 280                         get {
 281                                 if (blueViolet==null) {
 282                                         blueViolet=new SolidBrush(Color.BlueViolet);
 283                                 }
 284                                 return(blueViolet);
 285                         }
 286                 }
 287
 288                 public static Brush Brown {
 289                         get {
 290                                 if (brown==null) {
 291                                         brown=new SolidBrush(Color.Brown);
 292                                 }
 293                                 return(brown);
 294                         }
 295                 }
 296
 297                 public static Brush BurlyWood {
 298                         get {
 299                                 if (burlyWood==null) {
 300                                         burlyWood=new SolidBrush(Color.BurlyWood);
 301                                 }
 302                                 return(burlyWood);
 303                         }
 304                 }
 305
 306                 public static Brush CadetBlue {
 307                         get {
 308                                 if (cadetBlue==null) {
 309                                         cadetBlue=new SolidBrush(Color.CadetBlue);
 310                                 }
 311                                 return(cadetBlue);
 312                         }
 313                 }
 314
 315                 public static Brush Chartreuse {
 316                         get {
 317                                 if (chartreuse==null) {
 318                                         chartreuse=new SolidBrush(Color.Chartreuse);
 319                                 }
 320                                 return(chartreuse);
 321                         }
 322                 }
 323
 324                 public static Brush Chocolate {
 325                         get {
 326                                 if (chocolate==null) {
 327                                         chocolate=new SolidBrush(Color.Chocolate);
 328                                 }
 329                                 return(chocolate);
 330                         }
 331                 }
 332
 333                 public static Brush Coral {
 334                         get {
 335                                 if (coral==null) {
 336                                         coral=new SolidBrush(Color.Coral);
 337                                 }
 338                                 return(coral);
 339                         }
 340                 }
 341
 342                 public static Brush CornflowerBlue {
 343                         get {
 344                                 if (cornflowerBlue==null) {
 345                                         cornflowerBlue=new SolidBrush(Color.CornflowerBlue);
 346                                 }
 347                                 return(cornflowerBlue);
 348                         }
 349                 }
 350
 351                 public static Brush Cornsilk {
 352                         get {
 353                                 if (cornsilk==null) {
 354                                         cornsilk=new SolidBrush(Color.Cornsilk);
 355                                 }
 356                                 return(cornsilk);
 357                         }
 358                 }
 359
 360                 public static Brush Crimson {
 361                         get {
 362                                 if (crimson==null) {
 363                                         crimson=new SolidBrush(Color.Crimson);
 364                                 }
 365                                 return(crimson);
 366                         }
 367                 }
 368
 369                 public static Brush Cyan {
 370                         get {
 371                                 if (cyan==null) {
 372                                         cyan=new SolidBrush(Color.Cyan);
 373                                 }
 374                                 return(cyan);
 375                         }
 376                 }
 377
 378                 public static Brush DarkBlue {
 379                         get {
 380                                 if (darkBlue==null) {
 381                                         darkBlue=new SolidBrush(Color.DarkBlue);
 382                                 }
 383                                 return(darkBlue);
 384                         }
 385                 }
 386
 387                 public static Brush DarkCyan {
 388                         get {
 389                                 if (darkCyan==null) {
 390                                         darkCyan=new SolidBrush(Color.DarkCyan);
 391                                 }
 392                                 return(darkCyan);
 393                         }
 394                 }
 395
 396                 public static Brush DarkGoldenrod {
 397                         get {
 398                                 if (darkGoldenrod==null) {
 399                                         darkGoldenrod=new SolidBrush(Color.DarkGoldenrod);
 400                                 }
 401                                 return(darkGoldenrod);
 402                         }
 403                 }
 404
 405                 public static Brush DarkGray {
 406                         get {
 407                                 if (darkGray==null) {
 408                                         darkGray=new SolidBrush(Color.DarkGray);
 409                                 }
 410                                 return(darkGray);
 411                         }
 412                 }
 413
 414                 public static Brush DarkGreen {
 415                         get {
 416                                 if (darkGreen==null) {
 417                                         darkGreen=new SolidBrush(Color.DarkGreen);
 418                                 }
 419                                 return(darkGreen);
 420                         }
 421                 }
 422
 423                 public static Brush DarkKhaki {
 424                         get {
 425                                 if (darkKhaki==null) {
 426                                         darkKhaki=new SolidBrush(Color.DarkKhaki);
 427                                 }
 428                                 return(darkKhaki);
 429                         }
 430                 }
 431
 432                 public static Brush DarkMagenta {
 433                         get {
 434                                 if (darkMagenta==null) {
 435                                         darkMagenta=new SolidBrush(Color.DarkMagenta);
 436                                 }
 437                                 return(darkMagenta);
 438                         }
 439                 }
 440
 441                 public static Brush DarkOliveGreen {
 442                         get {
 443                                 if (darkOliveGreen==null) {
 444                                         darkOliveGreen=new SolidBrush(Color.DarkOliveGreen);
 445                                 }
 446                                 return(darkOliveGreen);
 447                         }
 448                 }
 449
 450                 public static Brush DarkOrange {
 451                         get {
 452                                 if (darkOrange==null) {
 453                                         darkOrange=new SolidBrush(Color.DarkOrange);
 454                                 }
 455                                 return(darkOrange);
 456                         }
 457                 }
 458
 459                 public static Brush DarkOrchid {
 460                         get {
 461                                 if (darkOrchid==null) {
 462                                         darkOrchid=new SolidBrush(Color.DarkOrchid);
 463                                 }
 464                                 return(darkOrchid);
 465                         }
 466                 }
 467
 468                 public static Brush DarkRed {
 469                         get {
 470                                 if (darkRed==null) {
 471                                         darkRed=new SolidBrush(Color.DarkRed);
 472                                 }
 473                                 return(darkRed);
 474                         }
 475                 }
 476
 477                 public static Brush DarkSalmon {
 478                         get {
 479                                 if (darkSalmon==null) {
 480                                         darkSalmon=new SolidBrush(Color.DarkSalmon);
 481                                 }
 482                                 return(darkSalmon);
 483                         }
 484                 }
 485
 486                 public static Brush DarkSeaGreen {
 487                         get {
 488                                 if (darkSeaGreen==null) {
 489                                         darkSeaGreen=new SolidBrush(Color.DarkSeaGreen);
 490                                 }
 491                                 return(darkSeaGreen);
 492                         }
 493                 }
 494
 495                 public static Brush DarkSlateBlue {
 496                         get {
 497                                 if (darkSlateBlue==null) {
 498                                         darkSlateBlue=new SolidBrush(Color.DarkSlateBlue);
 499                                 }
 500                                 return(darkSlateBlue);
 501                         }
 502                 }
 503
 504                 public static Brush DarkSlateGray {
 505                         get {
 506                                 if (darkSlateGray==null) {
 507                                         darkSlateGray=new SolidBrush(Color.DarkSlateGray);
 508                                 }
 509                                 return(darkSlateGray);
 510                         }
 511                 }
 512
 513                 public static Brush DarkTurquoise {
 514                         get {
 515                                 if (darkTurquoise==null) {
 516                                         darkTurquoise=new SolidBrush(Color.DarkTurquoise);
 517                                 }
 518                                 return(darkTurquoise);
 519                         }
 520                 }
 521
 522                 public static Brush DarkViolet {
 523                         get {
 524                                 if (darkViolet==null) {
 525                                         darkViolet=new SolidBrush(Color.DarkViolet);
 526                                 }
 527                                 return(darkViolet);
 528                         }
 529                 }
 530
 531                 public static Brush DeepPink {
 532                         get {
 533                                 if (deepPink==null) {
 534                                         deepPink=new SolidBrush(Color.DeepPink);
 535                                 }
 536                                 return(deepPink);
 537                         }
 538                 }
 539
 540                 public static Brush DeepSkyBlue {
 541                         get {
 542                                 if (deepSkyBlue==null) {
 543                                         deepSkyBlue=new SolidBrush(Color.DeepSkyBlue);
 544                                 }
 545                                 return(deepSkyBlue);
 546                         }
 547                 }
 548
 549                 public static Brush DimGray {
 550                         get {
 551                                 if (dimGray==null) {
 552                                         dimGray=new SolidBrush(Color.DimGray);
 553                                 }
 554                                 return(dimGray);
 555                         }
 556                 }
 557
 558                 public static Brush DodgerBlue {
 559                         get {
 560                                 if (dodgerBlue==null) {
 561                                         dodgerBlue=new SolidBrush(Color.DodgerBlue);
 562                                 }
 563                                 return(dodgerBlue);
 564                         }
 565                 }
 566
 567                 public static Brush Firebrick {
 568                         get {
 569                                 if (firebrick==null) {
 570                                         firebrick=new SolidBrush(Color.Firebrick);
 571                                 }
 572                                 return(firebrick);
 573                         }
 574                 }
 575
 576                 public static Brush FloralWhite {
 577                         get {
 578                                 if (floralWhite==null) {
 579                                         floralWhite=new SolidBrush(Color.FloralWhite);
 580                                 }
 581                                 return(floralWhite);
 582                         }
 583                 }
 584
 585                 public static Brush ForestGreen {
 586                         get {
 587                                 if (forestGreen==null) {
 588                                         forestGreen=new SolidBrush(Color.ForestGreen);
 589                                 }
 590                                 return(forestGreen);
 591                         }
 592                 }
 593
 594                 public static Brush Fuchsia {
 595                         get {
 596                                 if (fuchsia==null) {
 597                                         fuchsia=new SolidBrush(Color.Fuchsia);
 598                                 }
 599                                 return(fuchsia);
 600                         }
 601                 }
 602
 603                 public static Brush Gainsboro {
 604                         get {
 605                                 if (gainsboro==null) {
 606                                         gainsboro=new SolidBrush(Color.Gainsboro);
 607                                 }
 608                                 return(gainsboro);
 609                         }
 610                 }
 611
 612                 public static Brush GhostWhite {
 613                         get {
 614                                 if (ghostWhite==null) {
 615                                         ghostWhite=new SolidBrush(Color.GhostWhite);
 616                                 }
 617                                 return(ghostWhite);
 618                         }
 619                 }
 620
 621                 public static Brush Gold {
 622                         get {
 623                                 if (gold==null) {
 624                                         gold=new SolidBrush(Color.Gold);
 625                                 }
 626                                 return(gold);
 627                         }
 628                 }
 629
 630                 public static Brush Goldenrod {
 631                         get {
 632                                 if (goldenrod==null) {
 633                                         goldenrod=new SolidBrush(Color.Goldenrod);
 634                                 }
 635                                 return(goldenrod);
 636                         }
 637                 }
 638
 639                 public static Brush Gray {
 640                         get {
 641                                 if (gray==null) {
 642                                         gray=new SolidBrush(Color.Gray);
 643                                 }
 644                                 return(gray);
 645                         }
 646                 }
 647
 648                 public static Brush Green {
 649                         get {
 650                                 if (green==null) {
 651                                         green=new SolidBrush(Color.Green);
 652                                 }
 653                                 return(green);
 654                         }
 655                 }
 656
 657                 public static Brush GreenYellow {
 658                         get {
 659                                 if (greenYellow==null) {
 660                                         greenYellow=new SolidBrush(Color.GreenYellow);
 661                                 }
 662                                 return(greenYellow);
 663                         }
 664                 }
 665
 666                 public static Brush Honeydew {
 667                         get {
 668                                 if (honeydew==null) {
 669                                         honeydew=new SolidBrush(Color.Honeydew);
 670                                 }
 671                                 return(honeydew);
 672                         }
 673                 }
 674
 675                 public static Brush HotPink {
 676                         get {
 677                                 if (hotPink==null) {
 678                                         hotPink=new SolidBrush(Color.HotPink);
 679                                 }
 680                                 return(hotPink);
 681                         }
 682                 }
 683
 684                 public static Brush IndianRed {
 685                         get {
 686                                 if (indianRed==null) {
 687                                         indianRed=new SolidBrush(Color.IndianRed);
 688                                 }
 689                                 return(indianRed);
 690                         }
 691                 }
 692
 693                 public static Brush Indigo {
 694                         get {
 695                                 if (indigo==null) {
 696                                         indigo=new SolidBrush(Color.Indigo);
 697                                 }
 698                                 return(indigo);
 699                         }
 700                 }
 701
 702                 public static Brush Ivory {
 703                         get {
 704                                 if (ivory==null) {
 705                                         ivory=new SolidBrush(Color.Ivory);
 706                                 }
 707                                 return(ivory);
 708                         }
 709                 }
 710
 711                 public static Brush Khaki {
 712                         get {
 713                                 if (khaki==null) {
 714                                         khaki=new SolidBrush(Color.Khaki);
 715                                 }
 716                                 return(khaki);
 717                         }
 718                 }
 719
 720                 public static Brush Lavender {
 721                         get {
 722                                 if (lavender==null) {
 723                                         lavender=new SolidBrush(Color.Lavender);
 724                                 }
 725                                 return(lavender);
 726                         }
 727                 }
 728
 729                 public static Brush LavenderBlush {
 730                         get {
 731                                 if (lavenderBlush==null) {
 732                                         lavenderBlush=new SolidBrush(Color.LavenderBlush);
 733                                 }
 734                                 return(lavenderBlush);
 735                         }
 736                 }
 737
 738                 public static Brush LawnGreen {
 739                         get {
 740                                 if (lawnGreen==null) {
 741                                         lawnGreen=new SolidBrush(Color.LawnGreen);
 742                                 }
 743                                 return(lawnGreen);
 744                         }
 745                 }
 746
 747                 public static Brush LemonChiffon {
 748                         get {
 749                                 if (lemonChiffon==null) {
 750                                         lemonChiffon=new SolidBrush(Color.LemonChiffon);
 751                                 }
 752                                 return(lemonChiffon);
 753                         }
 754                 }
 755
 756                 public static Brush LightBlue {
 757                         get {
 758                                 if (lightBlue==null) {
 759                                         lightBlue=new SolidBrush(Color.LightBlue);
 760                                 }
 761                                 return(lightBlue);
 762                         }
 763                 }
 764
 765                 public static Brush LightCoral {
 766                         get {
 767                                 if (lightCoral==null) {
 768                                         lightCoral=new SolidBrush(Color.LightCoral);
 769                                 }
 770                                 return(lightCoral);
 771                         }
 772                 }
 773
 774                 public static Brush LightCyan {
 775                         get {
 776                                 if (lightCyan==null) {
 777                                         lightCyan=new SolidBrush(Color.LightCyan);
 778                                 }
 779                                 return(lightCyan);
 780                         }
 781                 }
 782
 783                 public static Brush LightGoldenrodYellow {
 784                         get {
 785                                 if (lightGoldenrodYellow==null) {
 786                                         lightGoldenrodYellow=new SolidBrush(Color.LightGoldenrodYellow);
 787                                 }
 788                                 return(lightGoldenrodYellow);
 789                         }
 790                 }
 791
 792                 public static Brush LightGray {
 793                         get {
 794                                 if (lightGray==null) {
 795                                         lightGray=new SolidBrush(Color.LightGray);
 796                                 }
 797                                 return(lightGray);
 798                         }
 799                 }
 800
 801                 public static Brush LightGreen {
 802                         get {
 803                                 if (lightGreen==null) {
 804                                         lightGreen=new SolidBrush(Color.LightGreen);
 805                                 }
 806                                 return(lightGreen);
 807                         }
 808                 }
 809
 810                 public static Brush LightPink {
 811                         get {
 812                                 if (lightPink==null) {
 813                                         lightPink=new SolidBrush(Color.LightPink);
 814                                 }
 815                                 return(lightPink);
 816                         }
 817                 }
 818
 819                 public static Brush LightSalmon {
 820                         get {
 821                                 if (lightSalmon==null) {
 822                                         lightSalmon=new SolidBrush(Color.LightSalmon);
 823                                 }
 824                                 return(lightSalmon);
 825                         }
 826                 }
 827
 828                 public static Brush LightSeaGreen {
 829                         get {
 830                                 if (lightSeaGreen==null) {
 831                                         lightSeaGreen=new SolidBrush(Color.LightSeaGreen);
 832                                 }
 833                                 return(lightSeaGreen);
 834                         }
 835                 }
 836
 837                 public static Brush LightSkyBlue {
 838                         get {
 839                                 if (lightSkyBlue==null) {
 840                                         lightSkyBlue=new SolidBrush(Color.LightSkyBlue);
 841                                 }
 842                                 return(lightSkyBlue);
 843                         }
 844                 }
 845
 846                 public static Brush LightSlateGray {
 847                         get {
 848                                 if (lightSlateGray==null) {
 849                                         lightSlateGray=new SolidBrush(Color.LightSlateGray);
 850                                 }
 851                                 return(lightSlateGray);
 852                         }
 853                 }
 854
 855                 public static Brush LightSteelBlue {
 856                         get {
 857                                 if (lightSteelBlue==null) {
 858                                         lightSteelBlue=new SolidBrush(Color.LightSteelBlue);
 859                                 }
 860                                 return(lightSteelBlue);
 861                         }
 862                 }
 863
 864                 public static Brush LightYellow {
 865                         get {
 866                                 if (lightYellow==null) {
 867                                         lightYellow=new SolidBrush(Color.LightYellow);
 868                                 }
 869                                 return(lightYellow);
 870                         }
 871                 }
 872
 873                 public static Brush Lime {
 874                         get {
 875                                 if (lime==null) {
 876                                         lime=new SolidBrush(Color.Lime);
 877                                 }
 878                                 return(lime);
 879                         }
 880                 }
 881
 882                 public static Brush LimeGreen {
 883                         get {
 884                                 if (limeGreen==null) {
 885                                         limeGreen=new SolidBrush(Color.LimeGreen);
 886                                 }
 887                                 return(limeGreen);
 888                         }
 889                 }
 890
 891                 public static Brush Linen {
 892                         get {
 893                                 if (linen==null) {
 894                                         linen=new SolidBrush(Color.Linen);
 895                                 }
 896                                 return(linen);
 897                         }
 898                 }
 899
 900                 public static Brush Magenta {
 901                         get {
 902                                 if (magenta==null) {
 903                                         magenta=new SolidBrush(Color.Magenta);
 904                                 }
 905                                 return(magenta);
 906                         }
 907                 }
 908
 909                 public static Brush Maroon {
 910                         get {
 911                                 if (maroon==null) {
 912                                         maroon=new SolidBrush(Color.Maroon);
 913                                 }
 914                                 return(maroon);
 915                         }
 916                 }
 917
 918                 public static Brush MediumAquamarine {
 919                         get {
 920                                 if (mediumAquamarine==null) {
 921                                         mediumAquamarine=new SolidBrush(Color.MediumAquamarine);
 922                                 }
 923                                 return(mediumAquamarine);
 924                         }
 925                 }
 926
 927                 public static Brush MediumBlue {
 928                         get {
 929                                 if (mediumBlue==null) {
 930                                         mediumBlue=new SolidBrush(Color.MediumBlue);
 931                                 }
 932                                 return(mediumBlue);
 933                         }
 934                 }
 935
 936                 public static Brush MediumOrchid {
 937                         get {
 938                                 if (mediumOrchid==null) {
 939                                         mediumOrchid=new SolidBrush(Color.MediumOrchid);
 940                                 }
 941                                 return(mediumOrchid);
 942                         }
 943                 }
 944
 945                 public static Brush MediumPurple {
 946                         get {
 947                                 if (mediumPurple==null) {
 948                                         mediumPurple=new SolidBrush(Color.MediumPurple);
 949                                 }
 950                                 return(mediumPurple);
 951                         }
 952                 }
 953
 954                 public static Brush MediumSeaGreen {
 955                         get {
 956                                 if (mediumSeaGreen==null) {
 957                                         mediumSeaGreen=new SolidBrush(Color.MediumSeaGreen);
 958                                 }
 959                                 return(mediumSeaGreen);
 960                         }
 961                 }
 962
 963                 public static Brush MediumSlateBlue {
 964                         get {
 965                                 if (mediumSlateBlue==null) {
 966                                         mediumSlateBlue=new SolidBrush(Color.MediumSlateBlue);
 967                                 }
 968                                 return(mediumSlateBlue);
 969                         }
 970                 }
 971
 972                 public static Brush MediumSpringGreen {
 973                         get {
 974                                 if (mediumSpringGreen==null) {
 975                                         mediumSpringGreen=new SolidBrush(Color.MediumSpringGreen);
 976                                 }
 977                                 return(mediumSpringGreen);
 978                         }
 979                 }
 980
 981                 public static Brush MediumTurquoise {
 982                         get {
 983                                 if (mediumTurquoise==null) {
 984                                         mediumTurquoise=new SolidBrush(Color.MediumTurquoise);
 985                                 }
 986                                 return(mediumTurquoise);
 987                         }
 988                 }
 989
 990                 public static Brush MediumVioletRed {
 991                         get {
 992                                 if (mediumVioletRed==null) {
 993                                         mediumVioletRed=new SolidBrush(Color.MediumVioletRed);
 994                                 }
 995                                 return(mediumVioletRed);
 996                         }
 997                 }
 998
 999                 public static Brush MidnightBlue {
1000                         get {
1001                                 if (midnightBlue==null) {
1002                                         midnightBlue=new SolidBrush(Color.MidnightBlue);
1003                                 }
1004                                 return(midnightBlue);
1005                         }
1006                 }
1007
1008                 public static Brush MintCream {
1009                         get {
1010                                 if (mintCream==null) {
1011                                         mintCream=new SolidBrush(Color.MintCream);
1012                                 }
1013                                 return(mintCream);
1014                         }
1015                 }
1016
1017                 public static Brush MistyRose {
1018                         get {
1019                                 if (mistyRose==null) {
1020                                         mistyRose=new SolidBrush(Color.MistyRose);
1021                                 }
1022                                 return(mistyRose);
1023                         }
1024                 }
1025
1026                 public static Brush Moccasin {
1027                         get {
1028                                 if (moccasin==null) {
1029                                         moccasin=new SolidBrush(Color.Moccasin);
1030                                 }
1031                                 return(moccasin);
1032                         }
1033                 }
1034
1035                 public static Brush NavajoWhite {
1036                         get {
1037                                 if (navajoWhite==null) {
1038                                         navajoWhite=new SolidBrush(Color.NavajoWhite);
1039                                 }
1040                                 return(navajoWhite);
1041                         }
1042                 }
1043
1044                 public static Brush Navy {
1045                         get {
1046                                 if (navy==null) {
1047                                         navy=new SolidBrush(Color.Navy);
1048                                 }
1049                                 return(navy);
1050                         }
1051                 }
1052
1053                 public static Brush OldLace {
1054                         get {
1055                                 if (oldLace==null) {
1056                                         oldLace=new SolidBrush(Color.OldLace);
1057                                 }
1058                                 return(oldLace);
1059                         }
1060                 }
1061
1062                 public static Brush Olive {
1063                         get {
1064                                 if (olive==null) {
1065                                         olive=new SolidBrush(Color.Olive);
1066                                 }
1067                                 return(olive);
1068                         }
1069                 }
1070
1071                 public static Brush OliveDrab {
1072                         get {
1073                                 if (oliveDrab==null) {
1074                                         oliveDrab=new SolidBrush(Color.OliveDrab);
1075                                 }
1076                                 return(oliveDrab);
1077                         }
1078                 }
1079
1080                 public static Brush Orange {
1081                         get {
1082                                 if (orange==null) {
1083                                         orange=new SolidBrush(Color.Orange);
1084                                 }
1085                                 return(orange);
1086                         }
1087                 }
1088
1089                 public static Brush OrangeRed {
1090                         get {
1091                                 if (orangeRed==null) {
1092                                         orangeRed=new SolidBrush(Color.OrangeRed);
1093                                 }
1094                                 return(orangeRed);
1095                         }
1096                 }
1097
1098                 public static Brush Orchid {
1099                         get {
1100                                 if (orchid==null) {
1101                                         orchid=new SolidBrush(Color.Orchid);
1102                                 }
1103                                 return(orchid);
1104                         }
1105                 }
1106
1107                 public static Brush PaleGoldenrod {
1108                         get {
1109                                 if (paleGoldenrod==null) {
1110                                         paleGoldenrod=new SolidBrush(Color.PaleGoldenrod);
1111                                 }
1112                                 return(paleGoldenrod);
1113                         }
1114                 }
1115
1116                 public static Brush PaleGreen {
1117                         get {
1118                                 if (paleGreen==null) {
1119                                         paleGreen=new SolidBrush(Color.PaleGreen);
1120                                 }
1121                                 return(paleGreen);
1122                         }
1123                 }
1124
1125                 public static Brush PaleTurquoise {
1126                         get {
1127                                 if (paleTurquoise==null) {
1128                                         paleTurquoise=new SolidBrush(Color.PaleTurquoise);
1129                                 }
1130                                 return(paleTurquoise);
1131                         }
1132                 }
1133
1134                 public static Brush PaleVioletRed {
1135                         get {
1136                                 if (paleVioletRed==null) {
1137                                         paleVioletRed=new SolidBrush(Color.PaleVioletRed);
1138                                 }
1139                                 return(paleVioletRed);
1140                         }
1141                 }
1142
1143                 public static Brush PapayaWhip {
1144                         get {
1145                                 if (papayaWhip==null) {
1146                                         papayaWhip=new SolidBrush(Color.PapayaWhip);
1147                                 }
1148                                 return(papayaWhip);
1149                         }
1150                 }
1151
1152                 public static Brush PeachPuff {
1153                         get {
1154                                 if (peachPuff==null) {
1155                                         peachPuff=new SolidBrush(Color.PeachPuff);
1156                                 }
1157                                 return(peachPuff);
1158                         }
1159                 }
1160
1161                 public static Brush Peru {
1162                         get {
1163                                 if (peru==null) {
1164                                         peru=new SolidBrush(Color.Peru);
1165                                 }
1166                                 return(peru);
1167                         }
1168                 }
1169
1170                 public static Brush Pink {
1171                         get {
1172                                 if (pink==null) {
1173                                         pink=new SolidBrush(Color.Pink);
1174                                 }
1175                                 return(pink);
1176                         }
1177                 }
1178
1179                 public static Brush Plum {
1180                         get {
1181                                 if (plum==null) {
1182                                         plum=new SolidBrush(Color.Plum);
1183                                 }
1184                                 return(plum);
1185                         }
1186                 }
1187
1188                 public static Brush PowderBlue {
1189                         get {
1190                                 if (powderBlue==null) {
1191                                         powderBlue=new SolidBrush(Color.PowderBlue);
1192                                 }
1193                                 return(powderBlue);
1194                         }
1195                 }
1196
1197                 public static Brush Purple {
1198                         get {
1199                                 if (purple==null) {
1200                                         purple=new SolidBrush(Color.Purple);
1201                                 }
1202                                 return(purple);
1203                         }
1204                 }
1205
1206                 public static Brush Red {
1207                         get {
1208                                 if (red==null) {
1209                                         red=new SolidBrush(Color.Red);
1210                                 }
1211                                 return(red);
1212                         }
1213                 }
1214
1215                 public static Brush RosyBrown {
1216                         get {
1217                                 if (rosyBrown==null) {
1218                                         rosyBrown=new SolidBrush(Color.RosyBrown);
1219                                 }
1220                                 return(rosyBrown);
1221                         }
1222                 }
1223
1224                 public static Brush RoyalBlue {
1225                         get {
1226                                 if (royalBlue==null) {
1227                                         royalBlue=new SolidBrush(Color.RoyalBlue);
1228                                 }
1229                                 return(royalBlue);
1230                         }
1231                 }
1232
1233                 public static Brush SaddleBrown {
1234                         get {
1235                                 if (saddleBrown==null) {
1236                                         saddleBrown=new SolidBrush(Color.SaddleBrown);
1237                                 }
1238                                 return(saddleBrown);
1239                         }
1240                 }
1241
1242                 public static Brush Salmon {
1243                         get {
1244                                 if (salmon==null) {
1245                                         salmon=new SolidBrush(Color.Salmon);
1246                                 }
1247                                 return(salmon);
1248                         }
1249                 }
1250
1251                 public static Brush SandyBrown {
1252                         get {
1253                                 if (sandyBrown==null) {
1254                                         sandyBrown=new SolidBrush(Color.SandyBrown);
1255                                 }
1256                                 return(sandyBrown);
1257                         }
1258                 }
1259
1260                 public static Brush SeaGreen {
1261                         get {
1262                                 if (seaGreen==null) {
1263                                         seaGreen=new SolidBrush(Color.SeaGreen);
1264                                 }
1265                                 return(seaGreen);
1266                         }
1267                 }
1268
1269                 public static Brush SeaShell {
1270                         get {
1271                                 if (seaShell==null) {
1272                                         seaShell=new SolidBrush(Color.SeaShell);
1273                                 }
1274                                 return(seaShell);
1275                         }
1276                 }
1277
1278                 public static Brush Sienna {
1279                         get {
1280                                 if (sienna==null) {
1281                                         sienna=new SolidBrush(Color.Sienna);
1282                                 }
1283                                 return(sienna);
1284                         }
1285                 }
1286
1287                 public static Brush Silver {
1288                         get {
1289                                 if (silver==null) {
1290                                         silver=new SolidBrush(Color.Silver);
1291                                 }
1292                                 return(silver);
1293                         }
1294                 }
1295
1296                 public static Brush SkyBlue {
1297                         get {
1298                                 if (skyBlue==null) {
1299                                         skyBlue=new SolidBrush(Color.SkyBlue);
1300                                 }
1301                                 return(skyBlue);
1302                         }
1303                 }
1304
1305                 public static Brush SlateBlue {
1306                         get {
1307                                 if (slateBlue==null) {
1308                                         slateBlue=new SolidBrush(Color.SlateBlue);
1309                                 }
1310                                 return(slateBlue);
1311                         }
1312                 }
1313
1314                 public static Brush SlateGray {
1315                         get {
1316                                 if (slateGray==null) {
1317                                         slateGray=new SolidBrush(Color.SlateGray);
1318                                 }
1319                                 return(slateGray);
1320                         }
1321                 }
1322
1323                 public static Brush Snow {
1324                         get {
1325                                 if (snow==null) {
1326                                         snow=new SolidBrush(Color.Snow);
1327                                 }
1328                                 return(snow);
1329                         }
1330                 }
1331
1332                 public static Brush SpringGreen {
1333                         get {
1334                                 if (springGreen==null) {
1335                                         springGreen=new SolidBrush(Color.SpringGreen);
1336                                 }
1337                                 return(springGreen);
1338                         }
1339                 }
1340
1341                 public static Brush SteelBlue {
1342                         get {
1343                                 if (steelBlue==null) {
1344                                         steelBlue=new SolidBrush(Color.SteelBlue);
1345                                 }
1346                                 return(steelBlue);
1347                         }
1348                 }
1349
1350                 public static Brush Tan {
1351                         get {
1352                                 if (tan==null) {
1353                                         tan=new SolidBrush(Color.Tan);
1354                                 }
1355                                 return(tan);
1356                         }
1357                 }
1358
1359                 public static Brush Teal {
1360                         get {
1361                                 if (teal==null) {
1362                                         teal=new SolidBrush(Color.Teal);
1363                                 }
1364                                 return(teal);
1365                         }
1366                 }
1367
1368                 public static Brush Thistle {
1369                         get {
1370                                 if (thistle==null) {
1371                                         thistle=new SolidBrush(Color.Thistle);
1372                                 }
1373                                 return(thistle);
1374                         }
1375                 }
1376
1377                 public static Brush Tomato {
1378                         get {
1379                                 if (tomato==null) {
1380                                         tomato=new SolidBrush(Color.Tomato);
1381                                 }
1382                                 return(tomato);
1383                         }
1384                 }
1385
1386                 public static Brush Transparent {
1387                         get {
1388                                 if (transparent==null) {
1389                                         transparent=new SolidBrush(Color.Transparent);
1390                                 }
1391                                 return(transparent);
1392                         }
1393                 }
1394
1395                 public static Brush Turquoise {
1396                         get {
1397                                 if (turquoise==null) {
1398                                         turquoise=new SolidBrush(Color.Turquoise);
1399                                 }
1400                                 return(turquoise);
1401                         }
1402                 }
1403
1404                 public static Brush Violet {
1405                         get {
1406                                 if (violet==null) {
1407                                         violet=new SolidBrush(Color.Violet);
1408                                 }
1409                                 return(violet);
1410                         }
1411                 }
1412
1413                 public static Brush Wheat {
1414                         get {
1415                                 if (wheat==null) {
1416                                         wheat=new SolidBrush(Color.Wheat);
1417                                 }
1418                                 return(wheat);
1419                         }
1420                 }
1421
1422                 public static Brush White {
1423                         get {
1424                                 if (white==null) {
1425                                         white=new SolidBrush(Color.White);
1426                                 }
1427                                 return(white);
1428                         }
1429                 }
1430
1431                 public static Brush WhiteSmoke {
1432                         get {
1433                                 if (whiteSmoke==null) {
1434                                         whiteSmoke=new SolidBrush(Color.WhiteSmoke);
1435                                 }
1436                                 return(whiteSmoke);
1437                         }
1438                 }
1439
1440                 public static Brush Yellow {
1441                         get {
1442                                 if (yellow==null) {
1443                                         yellow=new SolidBrush(Color.Yellow);
1444                                 }
1445                                 return(yellow);
1446                         }
1447                 }
1448
1449                 public static Brush YellowGreen {
1450                         get {
1451                                 if (yellowGreen==null) {
1452                                         yellowGreen=new SolidBrush(Color.YellowGreen);
1453                                 }
1454                                 return(yellowGreen);
1455                         }
1456                 }
1457
1458         }
1459 }