class/System.Drawing/System.Drawing/SystemBrushes.cs

   1 //
   2 // System.Drawing.SystemBrushes.cs
   3 //
   4 // Authors:
   5 //   Dennis Hayes (dennish@Raytek.com)
   6 //   Ravindra (rkumar@novell.com)
   7 //   Jordi Mas i Hernandez <jordimash@gmail.com>
   8 //
   9 // Copyright (C) 2002 Ximian, Inc. http://www.ximian.com
  10 // Copyright (C) 2004 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         /// <summary>
  41         /// Summary description for SystemBrushes.
  42         /// </summary>
  43         public sealed class SystemBrushes
  44         {
  45                 static SolidBrush active_border;
  46                 static SolidBrush active_caption;
  47                 static SolidBrush active_caption_text;
  48                 static SolidBrush app_workspace;
  49                 static SolidBrush control;
  50                 static SolidBrush control_dark;
  51                 static SolidBrush control_dark_dark;
  52                 static SolidBrush control_light;
  53                 static SolidBrush control_light_light;
  54                 static SolidBrush control_text;
  55                 static SolidBrush desktop;
  56                 static SolidBrush highlight;
  57                 static SolidBrush highlight_text;
  58                 static SolidBrush hot_track;
  59                 static SolidBrush inactive_border;
  60                 static SolidBrush inactive_caption;
  61                 static SolidBrush info;
  62                 static SolidBrush menu;
  63                 static SolidBrush scroll_bar;
  64                 static SolidBrush window;
  65                 static SolidBrush window_text;
  66 #if NET_2_0
  67                 static SolidBrush button_face;
  68                 static SolidBrush button_highlight;
  69                 static SolidBrush button_shadow;
  70                 static SolidBrush gradient_activecaption;
  71                 static SolidBrush gradient_inactivecaption;
  72                 static SolidBrush graytext;
  73                 static SolidBrush inactive_captiontext;
  74                 static SolidBrush infotext;
  75                 static SolidBrush menubar;
  76                 static SolidBrush menu_highlight;
  77                 static SolidBrush menu_text;
  78                 static SolidBrush window_fame;
  79 #endif
  80
  81                 private SystemBrushes() { }
  82
  83                 public static Brush ActiveBorder
  84                 {
  85                         get {
  86                                 if (active_border == null) {
  87                                         active_border = new SolidBrush (SystemColors.ActiveBorder);
  88                                         active_border.isModifiable = false;
  89                                 }
  90
  91                                 return active_border;
  92                         }
  93                 }
  94
  95                 public static Brush ActiveCaption
  96                 {
  97                         get {
  98                                 if (active_caption == null) {
  99                                         active_caption = new SolidBrush (SystemColors.ActiveCaption);
 100                                         active_caption.isModifiable = false;
 101                                 }
 102
 103                                 return active_caption;
 104                         }
 105                 }
 106
 107                 public static Brush ActiveCaptionText
 108                 {
 109                         get {
 110                                 if (active_caption_text == null) {
 111                                         active_caption_text = new SolidBrush (SystemColors.ActiveCaptionText);
 112                                         active_caption_text.isModifiable = false;
 113                                 }
 114
 115                                 return active_caption_text;
 116                         }
 117                 }
 118
 119                 public static Brush AppWorkspace
 120                 {
 121                         get {
 122                                 if (app_workspace == null) {
 123                                         app_workspace = new SolidBrush (SystemColors.AppWorkspace);
 124                                         app_workspace.isModifiable = false;
 125                                 }
 126
 127                                 return app_workspace;
 128                         }
 129                 }
 130
 131                 public static Brush Control {
 132                         get {
 133                                 if (control == null) {
 134                                         control = new SolidBrush (SystemColors.Control);
 135                                         control.isModifiable = false;
 136                                 }
 137
 138                                 return control;
 139                         }
 140                 }
 141
 142                 public static Brush ControlLight {
 143                         get {
 144                                 if (control_light == null) {
 145                                         control_light = new SolidBrush (SystemColors.ControlLight);
 146                                         control_light.isModifiable = false;
 147                                 }
 148
 149                                 return control_light;
 150                         }
 151                 }
 152
 153                 public static Brush ControlLightLight {
 154                         get {
 155                                 if (control_light_light == null) {
 156                                         control_light_light = new SolidBrush (SystemColors.ControlLightLight);
 157                                         control_light_light.isModifiable = false;
 158                                 }
 159
 160                                 return control_light_light;
 161                         }
 162                 }
 163
 164                 public static Brush ControlDark {
 165                         get {
 166                                 if (control_dark == null) {
 167                                         control_dark = new SolidBrush (SystemColors.ControlDark);
 168                                         control_dark.isModifiable = false;
 169                                 }
 170
 171                                 return control_dark;
 172                         }
 173                 }
 174
 175                 public static Brush ControlDarkDark {
 176                         get {
 177                                 if (control_dark_dark == null) {
 178                                         control_dark_dark = new SolidBrush (SystemColors.ControlDarkDark);
 179                                         control_dark_dark.isModifiable = false;
 180                                 }
 181
 182                                 return control_dark_dark;
 183                         }
 184                 }
 185
 186                 public static Brush ControlText {
 187                         get {
 188                                 if (control_text == null) {
 189                                         control_text = new SolidBrush (SystemColors.ControlText);
 190                                         control_text.isModifiable = false;
 191                                 }
 192
 193                                 return control_text;
 194                         }
 195                 }
 196
 197                 public static Brush Highlight {
 198                         get {
 199                                 if (highlight == null) {
 200                                         highlight = new SolidBrush (SystemColors.Highlight);
 201                                         highlight.isModifiable = false;
 202                                 }
 203
 204                                 return highlight;
 205                         }
 206                 }
 207
 208                 public static Brush HighlightText {
 209                         get {
 210                                 if (highlight_text == null) {
 211                                         highlight_text = new SolidBrush (SystemColors.HighlightText);
 212                                         highlight_text.isModifiable = false;
 213                                 }
 214
 215                                 return highlight_text;
 216                         }
 217                 }
 218
 219                 public static Brush Window {
 220                         get {
 221                                 if (window == null) {
 222                                         window = new SolidBrush (SystemColors.Window);
 223                                         window.isModifiable = false;
 224                                 }
 225
 226                                 return window;
 227                         }
 228                 }
 229                 public static Brush WindowText {
 230                         get {
 231                                 if (window_text == null) {
 232                                         window_text = new SolidBrush (SystemColors.WindowText);
 233                                         window_text.isModifiable = false;
 234                                 }
 235
 236                                 return window_text;
 237                         }
 238                 }
 239
 240                 public static Brush InactiveBorder {
 241                         get {
 242                                 if (inactive_border == null) {
 243                                         inactive_border = new SolidBrush (SystemColors.InactiveBorder);
 244                                         inactive_border.isModifiable = false;
 245                                 }
 246
 247                                 return inactive_border;
 248                         }
 249                 }
 250
 251                 public static Brush Desktop {
 252                         get {
 253                                 if (desktop == null) {
 254                                         desktop = new SolidBrush (SystemColors.Desktop);
 255                                         desktop.isModifiable = false;
 256                                 }
 257
 258                                 return desktop;
 259                         }
 260                 }
 261
 262                 public static Brush HotTrack {
 263                         get {
 264                                 if (hot_track == null) {
 265                                         hot_track = new SolidBrush (SystemColors.HotTrack);
 266                                         hot_track.isModifiable = false;
 267                                 }
 268
 269                                 return hot_track;
 270                         }
 271                 }
 272
 273                 public static Brush InactiveCaption {
 274                         get {
 275                                 if (inactive_caption == null) {
 276                                         inactive_caption = new SolidBrush (SystemColors.InactiveCaption);
 277                                         inactive_caption.isModifiable = false;
 278                                 }
 279
 280                                 return inactive_caption;
 281                         }
 282                 }
 283
 284                 public static Brush Info {
 285                         get {
 286                                 if (info == null) {
 287                                         info = new SolidBrush (SystemColors.Info);
 288                                         info.isModifiable = false;
 289                                 }
 290
 291                                 return info;
 292                         }
 293                 }
 294
 295                 public static Brush Menu {
 296                         get {
 297                                 if (menu == null) {
 298                                         menu = new SolidBrush (SystemColors.Menu);
 299                                         menu.isModifiable = false;
 300                                 }
 301
 302                                 return menu;
 303                         }
 304                 }
 305
 306                 public static Brush ScrollBar {
 307                         get {
 308                                 if (scroll_bar == null) {
 309                                         scroll_bar = new SolidBrush (SystemColors.ScrollBar);
 310                                         scroll_bar.isModifiable = false;
 311                                 }
 312
 313                                 return scroll_bar;
 314                         }
 315                 }
 316
 317                 public static Brush FromSystemColor (Color c)
 318                 {
 319                         if (c.IsSystemColor) {
 320                                 SolidBrush newBrush = new SolidBrush (c);
 321                                 newBrush.isModifiable = false;
 322                                 return newBrush;
 323                         }
 324
 325                         String message = String.Format ("The color {0} is not a system color.", c);
 326                         throw new ArgumentException (message);
 327                 }
 328
 329 #if NET_2_0
 330                 public static Brush ButtonFace {
 331                         get {
 332                                 if (button_face == null) {
 333                                         button_face = new SolidBrush (SystemColors.ButtonFace);
 334                                         button_face.isModifiable = false;
 335                                 }
 336
 337                                 return button_face;
 338                         }
 339                 }
 340
 341                 public static Brush ButtonHighlight {
 342                         get {
 343                                 if (button_highlight == null) {
 344                                         button_highlight = new SolidBrush (SystemColors.ButtonHighlight);
 345                                         button_highlight.isModifiable = false;
 346                                 }
 347
 348                                 return button_highlight;
 349                         }
 350                 }
 351
 352                 public static Brush ButtonShadow {
 353                         get {
 354                                 if (button_shadow == null) {
 355                                         button_shadow = new SolidBrush (SystemColors.ButtonShadow);
 356                                         button_shadow.isModifiable = false;
 357                                 }
 358
 359                                 return button_shadow;
 360                         }
 361                 }
 362
 363                 public static Brush GradientActiveCaption {
 364                         get {
 365                                 if (gradient_activecaption == null) {
 366                                         gradient_activecaption = new SolidBrush (SystemColors.GradientActiveCaption);
 367                                         gradient_activecaption.isModifiable = false;
 368                                 }
 369
 370                                 return gradient_activecaption;
 371                         }
 372                 }
 373
 374                 public static Brush GradientInactiveCaption {
 375                         get {
 376                                 if (gradient_inactivecaption == null) {
 377                                         gradient_inactivecaption = new SolidBrush (SystemColors.GradientInactiveCaption);
 378                                         gradient_inactivecaption.isModifiable = false;
 379                                 }
 380
 381                                 return gradient_inactivecaption;
 382                         }
 383                 }
 384
 385                 public static Brush GrayText {
 386                         get {
 387                                 if (graytext == null) {
 388                                         graytext = new SolidBrush (SystemColors.GrayText);
 389                                         graytext.isModifiable = false;
 390                                 }
 391
 392                                 return graytext;
 393                         }
 394                 }
 395
 396                 public static Brush InactiveCaptionText {
 397                         get {
 398                                 if (inactive_captiontext == null) {
 399                                         inactive_captiontext = new SolidBrush (SystemColors.InactiveCaptionText);
 400                                         inactive_captiontext.isModifiable = false;
 401                                 }
 402
 403                                 return inactive_captiontext;
 404                         }
 405                 }
 406
 407                 public static Brush InfoText {
 408                         get {
 409                                 if (infotext == null) {
 410                                         infotext = new SolidBrush (SystemColors.InfoText);
 411                                         infotext.isModifiable = false;
 412                                 }
 413
 414                                 return infotext;
 415                         }
 416                 }
 417
 418                 public static Brush MenuBar {
 419                         get {
 420                                 if (menubar == null) {
 421                                         menubar = new SolidBrush (SystemColors.MenuBar);
 422                                         menubar.isModifiable = false;
 423                                 }
 424
 425                                 return menubar;
 426                         }
 427                 }
 428
 429                 public static Brush MenuHighlight {
 430                         get {
 431                                 if (menu_highlight == null) {
 432                                         menu_highlight = new SolidBrush (SystemColors.MenuHighlight);
 433                                         menu_highlight.isModifiable = false;
 434                                 }
 435
 436                                 return menu_highlight;
 437                         }
 438                 }
 439
 440                 public static Brush MenuText {
 441                         get {
 442                                 if (menu_text == null) {
 443                                         menu_text = new SolidBrush (SystemColors.MenuText);
 444                                         menu_text.isModifiable = false;
 445                                 }
 446
 447                                 return menu_text;
 448                         }
 449                 }
 450
 451                 public static Brush WindowFrame {
 452                         get {
 453                                 if (window_fame == null) {
 454                                         window_fame = new SolidBrush (SystemColors.WindowFrame);
 455                                         window_fame.isModifiable = false;
 456                                 }
 457
 458                                 return window_fame;
 459                         }
 460                 }
 461 #endif
 462
 463         }
 464 }