mcs/class/System.Drawing/System.Drawing/Pens.cs

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