mcs/class/Managed.Windows.Forms/System.Windows.Forms/ThemeWin32Classic.cs

   1 // Permission is hereby granted, free of charge, to any person obtaining
   2 // a copy of this software and associated documentation files (the
   3 // "Software"), to deal in the Software without restriction, including
   4 // without limitation the rights to use, copy, modify, merge, publish,
   5 // distribute, sublicense, and/or sell copies of the Software, and to
   6 // permit persons to whom the Software is furnished to do so, subject to
   7 // the following conditions:
   8 //
   9 // The above copyright notice and this permission notice shall be
  10 // included in all copies or substantial portions of the Software.
  11 //
  12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  18 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  19 //
  20 // Copyright (c) 2004-2006 Novell, Inc.
  21 //
  22 // Authors:
  23 //      Jordi Mas i Hernandez, jordi@ximian.com
  24 //      Peter Bartok, pbartok@novell.com
  25 //      John BouAntoun, jba-mono@optusnet.com.au
  26 //      Marek Safar, marek.safar@seznam.cz
  27 //      Alexander Olk, alex.olk@googlemail.com
  28 //
  29
  30 using System.ComponentModel;
  31 using System.Data;
  32 using System.Drawing;
  33 using System.Drawing.Drawing2D;
  34 using System.Drawing.Imaging;
  35 using System.Drawing.Printing;
  36 using System.Drawing.Text;
  37 using System.Text;
  38 using System.Windows.Forms.Theming;
  39
  40 namespace System.Windows.Forms
  41 {
  42
  43         internal class ThemeWin32Classic : Theme
  44         {
  45                 public override Version Version {
  46                         get {
  47                                 return new Version(0, 1, 0, 0);
  48                         }
  49                 }
  50
  51                 /* Hardcoded colour values not exposed in the API constants in all configurations */
  52                 protected static readonly Color arrow_color = Color.Black;
  53                 protected static readonly Color pen_ticks_color = Color.Black;
  54                 protected static readonly Color progressbarblock_color = Color.FromArgb (255, 0, 0, 128);
  55                 protected static StringFormat string_format_menu_text;
  56                 protected static StringFormat string_format_menu_shortcut;
  57                 protected static StringFormat string_format_menu_menubar_text;
  58                 static ImageAttributes imagedisabled_attributes = null;
  59                 const int SEPARATOR_HEIGHT = 6;
  60                 const int SEPARATOR_MIN_WIDTH = 20;
  61                 const int SM_CXBORDER = 1;
  62                 const int SM_CYBORDER = 1;
  63                 const int MENU_TAB_SPACE = 8;           // Pixels added to the width of an item because of a tab
  64                 const int MENU_BAR_ITEMS_SPACE = 8;     // Space between menu bar items
  65
  66                 #region Principal Theme Methods
  67                 public ThemeWin32Classic ()
  68                 {
  69                         defaultWindowBackColor = this.ColorWindow;
  70                         defaultWindowForeColor = this.ColorControlText;
  71             window_border_font = new Font(FontFamily.GenericSansSerif, 8.25f, FontStyle.Bold);
  72
  73                         /* Menu string formats */
  74                         string_format_menu_text = new StringFormat ();
  75                         string_format_menu_text.LineAlignment = StringAlignment.Center;
  76                         string_format_menu_text.Alignment = StringAlignment.Near;
  77                         string_format_menu_text.HotkeyPrefix = HotkeyPrefix.Show;
  78
  79                         string_format_menu_shortcut = new StringFormat ();
  80                         string_format_menu_shortcut.LineAlignment = StringAlignment.Center;
  81                         string_format_menu_shortcut.Alignment = StringAlignment.Far;
  82
  83                         string_format_menu_menubar_text = new StringFormat ();
  84                         string_format_menu_menubar_text.LineAlignment = StringAlignment.Center;
  85                         string_format_menu_menubar_text.Alignment = StringAlignment.Center;
  86                         string_format_menu_menubar_text.HotkeyPrefix = HotkeyPrefix.Show;
  87                 }
  88
  89                 public override void ResetDefaults() {
  90                         Console.WriteLine("NOT IMPLEMENTED: ResetDefault()");
  91                         //throw new NotImplementedException("Need to implement ResetDefaults() for Win32 theme");
  92                 }
  93
  94                 public override bool DoubleBufferingSupported {
  95                         get {return true; }
  96                 }
  97
  98                 public override int HorizontalScrollBarHeight {
  99                         get {
 100                                 return XplatUI.HorizontalScrollBarHeight;
 101                         }
 102                 }
 103
 104                 public override int VerticalScrollBarWidth {
 105                         get {
 106                                 return XplatUI.VerticalScrollBarWidth;
 107                         }
 108                 }
 109
 110                 #endregion      // Principal Theme Methods
 111
 112                 #region Internal Methods
 113                 protected Brush GetControlBackBrush (Color c) {
 114                         if (c.ToArgb () == DefaultControlBackColor.ToArgb ())
 115                                 return SystemBrushes.Control;
 116                         return ResPool.GetSolidBrush (c);
 117                 }
 118
 119                 protected Brush GetControlForeBrush (Color c) {
 120                         if (c.ToArgb () == DefaultControlForeColor.ToArgb ())
 121                                 return SystemBrushes.ControlText;
 122                         return ResPool.GetSolidBrush (c);
 123                 }
 124                 #endregion      // Internal Methods
 125
 126                 #region Control
 127                 public override Font GetLinkFont (Control control)
 128                 {
 129                         return new Font (control.Font.FontFamily, control.Font.Size, control.Font.Style | FontStyle.Underline, control.Font.Unit);
 130                 }
 131                 #endregion      // Control
 132
 133                 #region OwnerDraw Support
 134                 public  override void DrawOwnerDrawBackground (DrawItemEventArgs e)
 135                 {
 136                         if ((e.State & DrawItemState.Selected) == DrawItemState.Selected) {
 137                                 e.Graphics.FillRectangle (SystemBrushes.Highlight, e.Bounds);
 138                                 return;
 139                         }
 140
 141                         e.Graphics.FillRectangle (ResPool.GetSolidBrush(e.BackColor), e.Bounds);
 142                 }
 143
 144                 public  override void DrawOwnerDrawFocusRectangle (DrawItemEventArgs e)
 145                 {
 146                         if (e.State == DrawItemState.Focus)
 147                                 CPDrawFocusRectangle (e.Graphics, e.Bounds, e.ForeColor, e.BackColor);
 148                 }
 149                 #endregion      // OwnerDraw Support
 150
 151                 #region Button
 152                 #region Standard Button Style
 153                 public override void DrawButton (Graphics g, Button b, Rectangle textBounds, Rectangle imageBounds, Rectangle clipRectangle)
 154                 {
 155                         // Draw Button Background
 156                         DrawButtonBackground (g, b, clipRectangle);
 157
 158                         // If we have an image, draw it
 159                         if (imageBounds.Size != Size.Empty)
 160                                 DrawButtonImage (g, b, imageBounds);
 161
 162                         // If we're focused, draw a focus rectangle
 163                         if (b.Focused && b.Enabled)
 164                                 DrawButtonFocus (g, b);
 165
 166                         // If we have text, draw it
 167                         if (textBounds != Rectangle.Empty)
 168                                 DrawButtonText (g, b, textBounds);
 169                 }
 170
 171                 public virtual void DrawButtonBackground (Graphics g, Button button, Rectangle clipArea)
 172                 {
 173                         if (button.Pressed)
 174                                 ThemeElements.DrawButton (g, button.ClientRectangle, ButtonThemeState.Pressed, button.BackColor, button.ForeColor);
 175                         else if (button.InternalSelected)
 176                                 ThemeElements.DrawButton (g, button.ClientRectangle, ButtonThemeState.Default, button.BackColor, button.ForeColor);
 177                         else if (button.Entered)
 178                                 ThemeElements.DrawButton (g, button.ClientRectangle, ButtonThemeState.Entered, button.BackColor, button.ForeColor);
 179                         else if (!button.Enabled)
 180                                 ThemeElements.DrawButton (g, button.ClientRectangle, ButtonThemeState.Disabled, button.BackColor, button.ForeColor);
 181                         else
 182                                 ThemeElements.DrawButton (g, button.ClientRectangle, ButtonThemeState.Normal, button.BackColor, button.ForeColor);
 183                 }
 184
 185                 public virtual void DrawButtonFocus (Graphics g, Button button)
 186                 {
 187                         ControlPaint.DrawFocusRectangle (g, Rectangle.Inflate (button.ClientRectangle, -4, -4));
 188                 }
 189
 190                 public virtual void DrawButtonImage (Graphics g, Button button, Rectangle imageBounds)
 191                 {
 192                         if (button.Enabled)
 193                                 g.DrawImage (button.Image, imageBounds);
 194                         else
 195                                 CPDrawImageDisabled (g, button.Image, imageBounds.Left, imageBounds.Top, ColorControl);
 196                 }
 197
 198                 public virtual void DrawButtonText (Graphics g, Button button, Rectangle textBounds)
 199                 {
 200                         if (button.Pressed)
 201                                 textBounds.Offset (1, 1);
 202
 203                         if (button.Enabled)
 204                                 TextRenderer.DrawTextInternal (g, button.Text, button.Font, textBounds, button.ForeColor, button.TextFormatFlags, button.UseCompatibleTextRendering);
 205                         else
 206                                 DrawStringDisabled20 (g, button.Text, button.Font, textBounds, button.BackColor, button.TextFormatFlags, button.UseCompatibleTextRendering);
 207                 }
 208                 #endregion
 209
 210                 #region FlatStyle Button Style
 211                 public override void DrawFlatButton (Graphics g, Button b, Rectangle textBounds, Rectangle imageBounds, Rectangle clipRectangle)
 212                 {
 213                         // Draw Button Background
 214                         DrawFlatButtonBackground (g, b, clipRectangle);
 215
 216                         // If we have an image, draw it
 217                         if (imageBounds.Size != Size.Empty)
 218                                 DrawFlatButtonImage (g, b, imageBounds);
 219
 220                         // If we're focused, draw a focus rectangle
 221                         if (b.Focused && b.Enabled)
 222                                 DrawFlatButtonFocus (g, b);
 223
 224                         // If we have text, draw it
 225                         if (textBounds != Rectangle.Empty)
 226                                 DrawFlatButtonText (g, b, textBounds);
 227                 }
 228
 229                 public virtual void DrawFlatButtonBackground (Graphics g, Button button, Rectangle clipArea)
 230                 {
 231                         if (button.Pressed)
 232                                 ThemeElements.DrawFlatButton (g, button.ClientRectangle, ButtonThemeState.Pressed, button.BackColor, button.ForeColor, button.FlatAppearance);
 233                         else if (button.InternalSelected)
 234                                 ThemeElements.DrawFlatButton (g, button.ClientRectangle, ButtonThemeState.Default, button.BackColor, button.ForeColor, button.FlatAppearance);
 235                         else if (button.Entered)
 236                                 ThemeElements.DrawFlatButton (g, button.ClientRectangle, ButtonThemeState.Entered, button.BackColor, button.ForeColor, button.FlatAppearance);
 237                         else if (!button.Enabled)
 238                                 ThemeElements.DrawFlatButton (g, button.ClientRectangle, ButtonThemeState.Disabled, button.BackColor, button.ForeColor, button.FlatAppearance);
 239                         else
 240                                 ThemeElements.DrawFlatButton (g, button.ClientRectangle, ButtonThemeState.Normal, button.BackColor, button.ForeColor, button.FlatAppearance);
 241                 }
 242
 243                 public virtual void DrawFlatButtonFocus (Graphics g, Button button)
 244                 {
 245                         if (!button.Pressed) {
 246                                 Color focus_color = ControlPaint.Light(button.BackColor);
 247                                 g.DrawRectangle (ResPool.GetPen (focus_color), new Rectangle (button.ClientRectangle.Left + 4, button.ClientRectangle.Top + 4, button.ClientRectangle.Width - 9, button.ClientRectangle.Height - 9));
 248                         }
 249                 }
 250
 251                 public virtual void DrawFlatButtonImage (Graphics g, Button button, Rectangle imageBounds)
 252                 {
 253                         // No changes from Standard for image for this theme
 254                         DrawButtonImage (g, button, imageBounds);
 255                 }
 256
 257                 public virtual void DrawFlatButtonText (Graphics g, Button button, Rectangle textBounds)
 258                 {
 259                         // No changes from Standard for image for this theme
 260                         DrawButtonText (g, button, textBounds);
 261                 }
 262                 #endregion
 263
 264                 #region Popup Button Style
 265                 public override void DrawPopupButton (Graphics g, Button b, Rectangle textBounds, Rectangle imageBounds, Rectangle clipRectangle)
 266                 {
 267                         // Draw Button Background
 268                         DrawPopupButtonBackground (g, b, clipRectangle);
 269
 270                         // If we have an image, draw it
 271                         if (imageBounds.Size != Size.Empty)
 272                                 DrawPopupButtonImage (g, b, imageBounds);
 273
 274                         // If we're focused, draw a focus rectangle
 275                         if (b.Focused && b.Enabled)
 276                                 DrawPopupButtonFocus (g, b);
 277
 278                         // If we have text, draw it
 279                         if (textBounds != Rectangle.Empty)
 280                                 DrawPopupButtonText (g, b, textBounds);
 281                 }
 282
 283                 public virtual void DrawPopupButtonBackground (Graphics g, Button button, Rectangle clipArea)
 284                 {
 285                         if (button.Pressed)
 286                                 ThemeElements.DrawPopupButton (g, button.ClientRectangle, ButtonThemeState.Pressed, button.BackColor, button.ForeColor);
 287                         else if (button.Entered)
 288                                 ThemeElements.DrawPopupButton (g, button.ClientRectangle, ButtonThemeState.Entered, button.BackColor, button.ForeColor);
 289                         else if (button.InternalSelected)
 290                                 ThemeElements.DrawPopupButton (g, button.ClientRectangle, ButtonThemeState.Default, button.BackColor, button.ForeColor);
 291                         else if (!button.Enabled)
 292                                 ThemeElements.DrawPopupButton (g, button.ClientRectangle, ButtonThemeState.Disabled, button.BackColor, button.ForeColor);
 293                         else
 294                                 ThemeElements.DrawPopupButton (g, button.ClientRectangle, ButtonThemeState.Normal, button.BackColor, button.ForeColor);
 295                 }
 296
 297                 public virtual void DrawPopupButtonFocus (Graphics g, Button button)
 298                 {
 299                         // No changes from Standard for image for this theme
 300                         DrawButtonFocus (g, button);
 301                 }
 302
 303                 public virtual void DrawPopupButtonImage (Graphics g, Button button, Rectangle imageBounds)
 304                 {
 305                         // No changes from Standard for image for this theme
 306                         DrawButtonImage (g, button, imageBounds);
 307                 }
 308
 309                 public virtual void DrawPopupButtonText (Graphics g, Button button, Rectangle textBounds)
 310                 {
 311                         // No changes from Standard for image for this theme
 312                         DrawButtonText (g, button, textBounds);
 313                 }
 314                 #endregion
 315
 316                 #region Button Layout Calculations
 317                 public override void CalculateButtonTextAndImageLayout (Button button, out Rectangle textRectangle, out Rectangle imageRectangle)
 318                 {
 319                         Image image = button.Image;
 320                         string text = button.Text;
 321                         Rectangle content_rect = button.ClientRectangle;
 322                         Size text_size = TextRenderer.MeasureTextInternal (text, button.Font, content_rect.Size, button.TextFormatFlags, button.UseCompatibleTextRendering);
 323                         Size image_size = image == null ? Size.Empty : image.Size;
 324
 325                         textRectangle = Rectangle.Empty;
 326                         imageRectangle = Rectangle.Empty;
 327
 328                         switch (button.TextImageRelation) {
 329                                 case TextImageRelation.Overlay:
 330                                         // Overlay is easy, text always goes here
 331                                         textRectangle = Rectangle.Inflate (content_rect, -4, -4);
 332
 333                                         if (button.Pressed)
 334                                                 textRectangle.Offset (1, 1);
 335
 336                                         // Image is dependent on ImageAlign
 337                                         if (image == null)
 338                                                 return;
 339
 340                                         int image_x = 0;
 341                                         int image_y = 0;
 342                                         int image_height = image.Height;
 343                                         int image_width = image.Width;
 344
 345                                         switch (button.ImageAlign) {
 346                                                 case System.Drawing.ContentAlignment.TopLeft:
 347                                                         image_x = 5;
 348                                                         image_y = 5;
 349                                                         break;
 350                                                 case System.Drawing.ContentAlignment.TopCenter:
 351                                                         image_x = (content_rect.Width - image_width) / 2;
 352                                                         image_y = 5;
 353                                                         break;
 354                                                 case System.Drawing.ContentAlignment.TopRight:
 355                                                         image_x = content_rect.Width - image_width - 5;
 356                                                         image_y = 5;
 357                                                         break;
 358                                                 case System.Drawing.ContentAlignment.MiddleLeft:
 359                                                         image_x = 5;
 360                                                         image_y = (content_rect.Height - image_height) / 2;
 361                                                         break;
 362                                                 case System.Drawing.ContentAlignment.MiddleCenter:
 363                                                         image_x = (content_rect.Width - image_width) / 2;
 364                                                         image_y = (content_rect.Height - image_height) / 2;
 365                                                         break;
 366                                                 case System.Drawing.ContentAlignment.MiddleRight:
 367                                                         image_x = content_rect.Width - image_width - 4;
 368                                                         image_y = (content_rect.Height - image_height) / 2;
 369                                                         break;
 370                                                 case System.Drawing.ContentAlignment.BottomLeft:
 371                                                         image_x = 5;
 372                                                         image_y = content_rect.Height - image_height - 4;
 373                                                         break;
 374                                                 case System.Drawing.ContentAlignment.BottomCenter:
 375                                                         image_x = (content_rect.Width - image_width) / 2;
 376                                                         image_y = content_rect.Height - image_height - 4;
 377                                                         break;
 378                                                 case System.Drawing.ContentAlignment.BottomRight:
 379                                                         image_x = content_rect.Width - image_width - 4;
 380                                                         image_y = content_rect.Height - image_height - 4;
 381                                                         break;
 382                                                 default:
 383                                                         image_x = 5;
 384                                                         image_y = 5;
 385                                                         break;
 386                                         }
 387
 388                                         imageRectangle = new Rectangle (image_x, image_y, image_width, image_height);
 389                                         break;
 390                                 case TextImageRelation.ImageAboveText:
 391                                         content_rect.Inflate (-4, -4);
 392                                         LayoutTextAboveOrBelowImage (content_rect, false, text_size, image_size, button.TextAlign, button.ImageAlign, out textRectangle, out imageRectangle);
 393                                         break;
 394                                 case TextImageRelation.TextAboveImage:
 395                                         content_rect.Inflate (-4, -4);
 396                                         LayoutTextAboveOrBelowImage (content_rect, true, text_size, image_size, button.TextAlign, button.ImageAlign, out textRectangle, out imageRectangle);
 397                                         break;
 398                                 case TextImageRelation.ImageBeforeText:
 399                                         content_rect.Inflate (-4, -4);
 400                                         LayoutTextBeforeOrAfterImage (content_rect, false, text_size, image_size, button.TextAlign, button.ImageAlign, out textRectangle, out imageRectangle);
 401                                         break;
 402                                 case TextImageRelation.TextBeforeImage:
 403                                         content_rect.Inflate (-4, -4);
 404                                         LayoutTextBeforeOrAfterImage (content_rect, true, text_size, image_size, button.TextAlign, button.ImageAlign, out textRectangle, out imageRectangle);
 405                                         break;
 406                         }
 407                 }
 408
 409                 private void LayoutTextBeforeOrAfterImage (Rectangle totalArea, bool textFirst, Size textSize, Size imageSize, System.Drawing.ContentAlignment textAlign, System.Drawing.ContentAlignment imageAlign, out Rectangle textRect, out Rectangle imageRect)
 410                 {
 411                         int element_spacing = 0;        // Spacing between the Text and the Image
 412                         int total_width = textSize.Width + element_spacing + imageSize.Width;
 413
 414                         if (!textFirst)
 415                                 element_spacing += 2;
 416
 417                         // If the text is too big, chop it down to the size we have available to it
 418                         if (total_width > totalArea.Width) {
 419                                 textSize.Width = totalArea.Width - element_spacing - imageSize.Width;
 420                                 total_width = totalArea.Width;
 421                         }
 422
 423                         int excess_width = totalArea.Width - total_width;
 424                         int offset = 0;
 425
 426                         Rectangle final_text_rect;
 427                         Rectangle final_image_rect;
 428
 429                         HorizontalAlignment h_text = GetHorizontalAlignment (textAlign);
 430                         HorizontalAlignment h_image = GetHorizontalAlignment (imageAlign);
 431
 432                         if (h_image == HorizontalAlignment.Left)
 433                                 offset = 0;
 434                         else if (h_image == HorizontalAlignment.Right && h_text == HorizontalAlignment.Right)
 435                                 offset = excess_width;
 436                         else if (h_image == HorizontalAlignment.Center && (h_text == HorizontalAlignment.Left || h_text == HorizontalAlignment.Center))
 437                                 offset += (int)(excess_width / 3);
 438                         else
 439                                 offset += (int)(2 * (excess_width / 3));
 440
 441                         if (textFirst) {
 442                                 final_text_rect = new Rectangle (totalArea.Left + offset, AlignInRectangle (totalArea, textSize, textAlign).Top, textSize.Width, textSize.Height);
 443                                 final_image_rect = new Rectangle (final_text_rect.Right + element_spacing, AlignInRectangle (totalArea, imageSize, imageAlign).Top, imageSize.Width, imageSize.Height);
 444                         }
 445                         else {
 446                                 final_image_rect = new Rectangle (totalArea.Left + offset, AlignInRectangle (totalArea, imageSize, imageAlign).Top, imageSize.Width, imageSize.Height);
 447                                 final_text_rect = new Rectangle (final_image_rect.Right + element_spacing, AlignInRectangle (totalArea, textSize, textAlign).Top, textSize.Width, textSize.Height);
 448                         }
 449
 450                         textRect = final_text_rect;
 451                         imageRect = final_image_rect;
 452                 }
 453
 454                 private void LayoutTextAboveOrBelowImage (Rectangle totalArea, bool textFirst, Size textSize, Size imageSize, System.Drawing.ContentAlignment textAlign, System.Drawing.ContentAlignment imageAlign, out Rectangle textRect, out Rectangle imageRect)
 455                 {
 456                         int element_spacing = 0;        // Spacing between the Text and the Image
 457                         int total_height = textSize.Height + element_spacing + imageSize.Height;
 458
 459                         if (textFirst)
 460                                 element_spacing += 2;
 461
 462                         if (textSize.Width > totalArea.Width)
 463                                 textSize.Width = totalArea.Width;
 464
 465                         // If the there isn't enough room and we're text first, cut out the image
 466                         if (total_height > totalArea.Height && textFirst) {
 467                                 imageSize = Size.Empty;
 468                                 total_height = totalArea.Height;
 469                         }
 470
 471                         int excess_height = totalArea.Height - total_height;
 472                         int offset = 0;
 473
 474                         Rectangle final_text_rect;
 475                         Rectangle final_image_rect;
 476
 477                         VerticalAlignment v_text = GetVerticalAlignment (textAlign);
 478                         VerticalAlignment v_image = GetVerticalAlignment (imageAlign);
 479
 480                         if (v_image == VerticalAlignment.Top)
 481                                 offset = 0;
 482                         else if (v_image == VerticalAlignment.Bottom && v_text == VerticalAlignment.Bottom)
 483                                 offset = excess_height;
 484                         else if (v_image == VerticalAlignment.Center && (v_text == VerticalAlignment.Top || v_text == VerticalAlignment.Center))
 485                                 offset += (int)(excess_height / 3);
 486                         else
 487                                 offset += (int)(2 * (excess_height / 3));
 488
 489                         if (textFirst) {
 490                                 final_text_rect = new Rectangle (AlignInRectangle (totalArea, textSize, textAlign).Left, totalArea.Top + offset, textSize.Width, textSize.Height);
 491                                 final_image_rect = new Rectangle (AlignInRectangle (totalArea, imageSize, imageAlign).Left, final_text_rect.Bottom + element_spacing, imageSize.Width, imageSize.Height);
 492                         }
 493                         else {
 494                                 final_image_rect = new Rectangle (AlignInRectangle (totalArea, imageSize, imageAlign).Left, totalArea.Top + offset, imageSize.Width, imageSize.Height);
 495                                 final_text_rect = new Rectangle (AlignInRectangle (totalArea, textSize, textAlign).Left, final_image_rect.Bottom + element_spacing, textSize.Width, textSize.Height);
 496
 497                                 if (final_text_rect.Bottom > totalArea.Bottom)
 498                                         final_text_rect.Y = totalArea.Top;
 499                         }
 500
 501                         textRect = final_text_rect;
 502                         imageRect = final_image_rect;
 503                 }
 504
 505                 private HorizontalAlignment GetHorizontalAlignment (System.Drawing.ContentAlignment align)
 506                 {
 507                         switch (align) {
 508                                 case System.Drawing.ContentAlignment.BottomLeft:
 509                                 case System.Drawing.ContentAlignment.MiddleLeft:
 510                                 case System.Drawing.ContentAlignment.TopLeft:
 511                                         return HorizontalAlignment.Left;
 512                                 case System.Drawing.ContentAlignment.BottomCenter:
 513                                 case System.Drawing.ContentAlignment.MiddleCenter:
 514                                 case System.Drawing.ContentAlignment.TopCenter:
 515                                         return HorizontalAlignment.Center;
 516                                 case System.Drawing.ContentAlignment.BottomRight:
 517                                 case System.Drawing.ContentAlignment.MiddleRight:
 518                                 case System.Drawing.ContentAlignment.TopRight:
 519                                         return HorizontalAlignment.Right;
 520                         }
 521
 522                         return HorizontalAlignment.Left;
 523                 }
 524
 525                 private enum VerticalAlignment
 526                 {
 527                         Top = 0,
 528                         Center = 1,
 529                         Bottom = 2
 530                 }
 531
 532                 private VerticalAlignment GetVerticalAlignment (System.Drawing.ContentAlignment align)
 533                 {
 534                         switch (align) {
 535                                 case System.Drawing.ContentAlignment.TopLeft:
 536                                 case System.Drawing.ContentAlignment.TopCenter:
 537                                 case System.Drawing.ContentAlignment.TopRight:
 538                                         return VerticalAlignment.Top;
 539                                 case System.Drawing.ContentAlignment.MiddleLeft:
 540                                 case System.Drawing.ContentAlignment.MiddleCenter:
 541                                 case System.Drawing.ContentAlignment.MiddleRight:
 542                                         return VerticalAlignment.Center;
 543                                 case System.Drawing.ContentAlignment.BottomLeft:
 544                                 case System.Drawing.ContentAlignment.BottomCenter:
 545                                 case System.Drawing.ContentAlignment.BottomRight:
 546                                         return VerticalAlignment.Bottom;
 547                         }
 548
 549                         return VerticalAlignment.Top;
 550                 }
 551
 552                 internal Rectangle AlignInRectangle (Rectangle outer, Size inner, System.Drawing.ContentAlignment align)
 553                 {
 554                         int x = 0;
 555                         int y = 0;
 556
 557                         if (align == System.Drawing.ContentAlignment.BottomLeft || align == System.Drawing.ContentAlignment.MiddleLeft || align == System.Drawing.ContentAlignment.TopLeft)
 558                                 x = outer.X;
 559                         else if (align == System.Drawing.ContentAlignment.BottomCenter || align == System.Drawing.ContentAlignment.MiddleCenter || align == System.Drawing.ContentAlignment.TopCenter)
 560                                 x = Math.Max (outer.X + ((outer.Width - inner.Width) / 2), outer.Left);
 561                         else if (align == System.Drawing.ContentAlignment.BottomRight || align == System.Drawing.ContentAlignment.MiddleRight || align == System.Drawing.ContentAlignment.TopRight)
 562                                 x = outer.Right - inner.Width;
 563                         if (align == System.Drawing.ContentAlignment.TopCenter || align == System.Drawing.ContentAlignment.TopLeft || align == System.Drawing.ContentAlignment.TopRight)
 564                                 y = outer.Y;
 565                         else if (align == System.Drawing.ContentAlignment.MiddleCenter || align == System.Drawing.ContentAlignment.MiddleLeft || align == System.Drawing.ContentAlignment.MiddleRight)
 566                                 y = outer.Y + (outer.Height - inner.Height) / 2;
 567                         else if (align == System.Drawing.ContentAlignment.BottomCenter || align == System.Drawing.ContentAlignment.BottomRight || align == System.Drawing.ContentAlignment.BottomLeft)
 568                                 y = outer.Bottom - inner.Height;
 569
 570                         return new Rectangle (x, y, Math.Min (inner.Width, outer.Width), Math.Min (inner.Height, outer.Height));
 571                 }
 572                 #endregion
 573                 #endregion
 574
 575                 #region ButtonBase
 576                 public override void DrawButtonBase(Graphics dc, Rectangle clip_area, ButtonBase button)
 577                 {
 578                         // Draw the button: Draw border, etc.
 579                         ButtonBase_DrawButton(button, dc);
 580
 581                         // Draw the image
 582                         if (button.FlatStyle != FlatStyle.System && ((button.image != null) || (button.image_list != null)))
 583                                 ButtonBase_DrawImage(button, dc);
 584
 585                         // Draw the focus rectangle
 586                         if ((button.Focused || button.paint_as_acceptbutton) && button.Enabled)
 587                                 ButtonBase_DrawFocus(button, dc);
 588
 589                         // Now the text
 590                         if (button.Text != null && button.Text != String.Empty)
 591                                 ButtonBase_DrawText(button, dc);
 592                 }
 593
 594                 protected virtual void ButtonBase_DrawButton (ButtonBase button, Graphics dc)
 595                 {
 596                         Rectangle borderRectangle;
 597                         bool check_or_radio = false;
 598                         bool check_or_radio_checked = false;
 599
 600                         bool is_ColorControl = button.BackColor.ToArgb () == ColorControl.ToArgb () ? true : false;
 601
 602                         CPColor cpcolor = is_ColorControl ? CPColor.Empty : ResPool.GetCPColor (button.BackColor);
 603
 604                         if (button is CheckBox) {
 605                                 check_or_radio = true;
 606                                 check_or_radio_checked = ((CheckBox)button).Checked;
 607                         } else if (button is RadioButton) {
 608                                 check_or_radio = true;
 609                                 check_or_radio_checked = ((RadioButton)button).Checked;
 610                         }
 611
 612                         if ((button.Focused || button.paint_as_acceptbutton) && button.Enabled && !check_or_radio) {
 613                                 // shrink the rectangle for the normal button drawing inside the focus rectangle
 614                                 borderRectangle = Rectangle.Inflate (button.ClientRectangle, -1, -1);
 615                         } else {
 616                                 borderRectangle = button.ClientRectangle;
 617                         }
 618
 619                         if (button.FlatStyle == FlatStyle.Popup) {
 620                                 if (!button.is_pressed && !button.is_entered && !check_or_radio_checked)
 621                                         Internal_DrawButton (dc, borderRectangle, 1, cpcolor, is_ColorControl, button.BackColor);
 622                                 else if (!button.is_pressed && button.is_entered &&!check_or_radio_checked)
 623                                         Internal_DrawButton (dc, borderRectangle, 2, cpcolor, is_ColorControl, button.BackColor);
 624                                 else if (button.is_pressed || check_or_radio_checked)
 625                                         Internal_DrawButton (dc, borderRectangle, 1, cpcolor, is_ColorControl, button.BackColor);
 626                         } else if (button.FlatStyle == FlatStyle.Flat) {
 627                                 if (button.is_entered && !button.is_pressed && !check_or_radio_checked) {
 628                                         if ((button.image == null) && (button.image_list == null)) {
 629                                                 Brush brush = is_ColorControl ? SystemBrushes.ControlDark : ResPool.GetSolidBrush (cpcolor.Dark);
 630                                                 dc.FillRectangle (brush, borderRectangle);
 631                                         }
 632                                 } else if (button.is_pressed || check_or_radio_checked) {
 633                                         if ((button.image == null) && (button.image_list == null)) {
 634                                                 Brush brush = is_ColorControl ? SystemBrushes.ControlLightLight : ResPool.GetSolidBrush (cpcolor.LightLight);
 635                                                 dc.FillRectangle (brush, borderRectangle);
 636                                         }
 637
 638                                         Pen pen = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
 639                                         dc.DrawRectangle (pen, borderRectangle.X + 4, borderRectangle.Y + 4,
 640                                                           borderRectangle.Width - 9, borderRectangle.Height - 9);
 641                                 }
 642
 643                                 Internal_DrawButton (dc, borderRectangle, 3, cpcolor, is_ColorControl, button.BackColor);
 644                         } else {
 645                                 if ((!button.is_pressed || !button.Enabled) && !check_or_radio_checked)
 646                                         Internal_DrawButton (dc, borderRectangle, 0, cpcolor, is_ColorControl, button.BackColor);
 647                                 else
 648                                         Internal_DrawButton (dc, borderRectangle, 1, cpcolor, is_ColorControl, button.BackColor);
 649                         }
 650                 }
 651
 652                 private void Internal_DrawButton (Graphics dc, Rectangle rect, int state, CPColor cpcolor, bool is_ColorControl, Color backcolor)
 653                 {
 654                         switch (state) {
 655                         case 0: // normal or normal disabled button
 656                                 Pen pen = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
 657                                 dc.DrawLine (pen, rect.X, rect.Y, rect.X, rect.Bottom - 2);
 658                                 dc.DrawLine (pen, rect.X + 1, rect.Y, rect.Right - 2, rect.Y);
 659
 660                                 pen = is_ColorControl ? SystemPens.Control : ResPool.GetPen (backcolor);
 661                                 dc.DrawLine (pen, rect.X + 1, rect.Y + 1, rect.X + 1, rect.Bottom - 3);
 662                                 dc.DrawLine (pen, rect.X + 2, rect.Y + 1, rect.Right - 3, rect.Y + 1);
 663
 664                                 pen = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
 665                                 dc.DrawLine (pen, rect.X + 1, rect.Bottom - 2, rect.Right - 2, rect.Bottom - 2);
 666                                 dc.DrawLine (pen, rect.Right - 2, rect.Y + 1, rect.Right - 2, rect.Bottom - 3);
 667
 668                                 pen = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
 669                                 dc.DrawLine (pen, rect.X, rect.Bottom - 1, rect.Right - 1, rect.Bottom - 1);
 670                                 dc.DrawLine (pen, rect.Right - 1, rect.Y, rect.Right - 1, rect.Bottom - 2);
 671                                 break;
 672                         case 1: // popup button normal (or pressed normal or popup button)
 673                                 pen = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
 674                                 dc.DrawRectangle (pen, rect.X, rect.Y, rect.Width - 1, rect.Height - 1);
 675                                 break;
 676                         case 2: // popup button poped up
 677                                 pen = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
 678                                 dc.DrawLine (pen, rect.X, rect.Y, rect.X, rect.Bottom - 2);
 679                                 dc.DrawLine (pen, rect.X + 1, rect.Y, rect.Right - 2, rect.Y);
 680
 681                                 pen = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
 682                                 dc.DrawLine (pen, rect.X, rect.Bottom - 1, rect.Right - 1, rect.Bottom - 1);
 683                                 dc.DrawLine (pen, rect.Right - 1, rect.Y, rect.Right - 1, rect.Bottom - 2);
 684                                 break;
 685                         case 3: // flat button not entered
 686                                 pen = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
 687                                 dc.DrawRectangle (pen, rect.X, rect.Y, rect.Width - 1, rect.Height - 1);
 688                                 break;
 689                         default:
 690                                 break;
 691                         }
 692                 }
 693
 694                 protected virtual void ButtonBase_DrawImage(ButtonBase button, Graphics dc)
 695                 {
 696                         // Need to draw a picture
 697                         Image   i;
 698                         int     image_x;
 699                         int     image_y;
 700                         int     image_width;
 701                         int     image_height;
 702
 703                         int width = button.ClientSize.Width;
 704                         int height = button.ClientSize.Height;
 705
 706                         if (button.ImageIndex != -1) {   // We use ImageIndex instead of image_index since it will return -1 if image_list is null
 707                                 i = button.image_list.Images[button.ImageIndex];
 708                         } else {
 709                                 i = button.image;
 710                         }
 711
 712                         image_width = i.Width;
 713                         image_height = i.Height;
 714
 715                         switch (button.ImageAlign) {
 716                                 case ContentAlignment.TopLeft: {
 717                                         image_x = 5;
 718                                         image_y = 5;
 719                                         break;
 720                                 }
 721
 722                                 case ContentAlignment.TopCenter: {
 723                                         image_x = (width - image_width) / 2;
 724                                         image_y = 5;
 725                                         break;
 726                                 }
 727
 728                                 case ContentAlignment.TopRight: {
 729                                         image_x = width - image_width - 5;
 730                                         image_y = 5;
 731                                         break;
 732                                 }
 733
 734                                 case ContentAlignment.MiddleLeft: {
 735                                         image_x = 5;
 736                                         image_y = (height - image_height) / 2;
 737                                         break;
 738                                 }
 739
 740                                 case ContentAlignment.MiddleCenter: {
 741                                         image_x = (width - image_width) / 2;
 742                                         image_y = (height - image_height) / 2;
 743                                         break;
 744                                 }
 745
 746                                 case ContentAlignment.MiddleRight: {
 747                                         image_x = width - image_width - 4;
 748                                         image_y = (height - image_height) / 2;
 749                                         break;
 750                                 }
 751
 752                                 case ContentAlignment.BottomLeft: {
 753                                         image_x = 5;
 754                                         image_y = height - image_height - 4;
 755                                         break;
 756                                 }
 757
 758                                 case ContentAlignment.BottomCenter: {
 759                                         image_x = (width - image_width) / 2;
 760                                         image_y = height - image_height - 4;
 761                                         break;
 762                                 }
 763
 764                                 case ContentAlignment.BottomRight: {
 765                                         image_x = width - image_width - 4;
 766                                         image_y = height - image_height - 4;
 767                                         break;
 768                                 }
 769
 770                                 default: {
 771                                         image_x = 5;
 772                                         image_y = 5;
 773                                         break;
 774                                 }
 775                         }
 776
 777                         dc.SetClip (new Rectangle(3, 3, width - 5, height - 5));
 778
 779                         if (button.Enabled)
 780                                 dc.DrawImage (i, image_x, image_y, image_width, image_height);
 781                         else
 782                                 CPDrawImageDisabled (dc, i, image_x, image_y, ColorControl);
 783
 784                         dc.ResetClip ();
 785                 }
 786
 787                 protected virtual void ButtonBase_DrawFocus(ButtonBase button, Graphics dc)
 788                 {
 789                         Color focus_color = button.ForeColor;
 790
 791                         int inflate_value = -3;
 792
 793                         if (!(button is CheckBox) && !(button is RadioButton)) {
 794                                 inflate_value = -4;
 795
 796                                 if (button.FlatStyle == FlatStyle.Popup && !button.is_pressed)
 797                                         focus_color = ControlPaint.Dark(button.BackColor);
 798
 799                                 dc.DrawRectangle (ResPool.GetPen (focus_color), button.ClientRectangle.X, button.ClientRectangle.Y,
 800                                                   button.ClientRectangle.Width - 1, button.ClientRectangle.Height - 1);
 801                         }
 802
 803                         if (button.Focused) {
 804                                 Rectangle rect = Rectangle.Inflate (button.ClientRectangle, inflate_value, inflate_value);
 805                                 ControlPaint.DrawFocusRectangle (dc, rect);
 806                         }
 807                 }
 808
 809                 protected virtual void ButtonBase_DrawText(ButtonBase button, Graphics dc)
 810                 {
 811                         Rectangle buttonRectangle = button.ClientRectangle;
 812                         Rectangle text_rect = Rectangle.Inflate(buttonRectangle, -4, -4);
 813
 814                         if (button.is_pressed) {
 815                                 text_rect.X++;
 816                                 text_rect.Y++;
 817                         }
 818
 819                         if (button.Enabled) {
 820                                 dc.DrawString(button.Text, button.Font, ResPool.GetSolidBrush (button.ForeColor), text_rect, button.text_format);
 821                         } else {
 822                                 if (button.FlatStyle == FlatStyle.Flat || button.FlatStyle == FlatStyle.Popup) {
 823                                         dc.DrawString(button.Text, button.Font, ResPool.GetSolidBrush (ColorGrayText), text_rect, button.text_format);
 824                                 } else {
 825                                         CPDrawStringDisabled (dc, button.Text, button.Font, button.BackColor, text_rect, button.text_format);
 826                                 }
 827                         }
 828                 }
 829
 830                 public override Size ButtonBaseDefaultSize {
 831                         get {
 832                                 return new Size (75, 23);
 833                         }
 834                 }
 835                 #endregion      // ButtonBase
 836
 837                 #region CheckBox
 838                 public override void DrawCheckBox(Graphics dc, Rectangle clip_area, CheckBox checkbox) {
 839                         StringFormat            text_format;
 840                         Rectangle               client_rectangle;
 841                         Rectangle               text_rectangle;
 842                         Rectangle               checkbox_rectangle;
 843                         int                     checkmark_size=13;
 844                         int                     checkmark_space = 4;
 845
 846                         client_rectangle = checkbox.ClientRectangle;
 847                         text_rectangle = client_rectangle;
 848                         checkbox_rectangle = new Rectangle(text_rectangle.X, text_rectangle.Y, checkmark_size, checkmark_size);
 849
 850                         text_format = new StringFormat();
 851                         text_format.Alignment=StringAlignment.Near;
 852                         text_format.LineAlignment=StringAlignment.Center;
 853                         text_format.HotkeyPrefix = HotkeyPrefix.Show;
 854
 855                         /* Calculate the position of text and checkbox rectangle */
 856                         if (checkbox.appearance!=Appearance.Button) {
 857                                 switch(checkbox.check_alignment) {
 858                                         case ContentAlignment.BottomCenter: {
 859                                                 checkbox_rectangle.X=(client_rectangle.Right-client_rectangle.Left)/2-checkmark_size/2;
 860                                                 checkbox_rectangle.Y=client_rectangle.Bottom-checkmark_size;
 861                                                 text_rectangle.X=client_rectangle.X;
 862                                                 text_rectangle.Width=client_rectangle.Width;
 863                                                 text_rectangle.Height=client_rectangle.Height-checkbox_rectangle.Y-checkmark_space;
 864                                                 break;
 865                                         }
 866
 867                                         case ContentAlignment.BottomLeft: {
 868                                                 checkbox_rectangle.X=client_rectangle.Left;
 869                                                 checkbox_rectangle.Y=client_rectangle.Bottom-checkmark_size;
 870                                                 text_rectangle.X=client_rectangle.X+checkmark_size+checkmark_space;
 871                                                 text_rectangle.Width=client_rectangle.Width-checkmark_size-checkmark_space;
 872                                                 break;
 873                                         }
 874
 875                                         case ContentAlignment.BottomRight: {
 876                                                 checkbox_rectangle.X=client_rectangle.Right-checkmark_size;
 877                                                 checkbox_rectangle.Y=client_rectangle.Bottom-checkmark_size;
 878                                                 text_rectangle.X=client_rectangle.X;
 879                                                 text_rectangle.Width=client_rectangle.Width-checkmark_size-checkmark_space;
 880                                                 break;
 881                                         }
 882
 883                                         case ContentAlignment.MiddleCenter: {
 884                                                 checkbox_rectangle.X=(client_rectangle.Right-client_rectangle.Left)/2-checkmark_size/2;
 885                                                 checkbox_rectangle.Y=(client_rectangle.Bottom-client_rectangle.Top)/2-checkmark_size/2;
 886                                                 text_rectangle.X=client_rectangle.X;
 887                                                 text_rectangle.Width=client_rectangle.Width;
 888                                                 break;
 889                                         }
 890
 891                                         default:
 892                                         case ContentAlignment.MiddleLeft: {
 893                                                 checkbox_rectangle.X=client_rectangle.Left;
 894                                                 checkbox_rectangle.Y=(client_rectangle.Bottom-client_rectangle.Top)/2-checkmark_size/2;
 895                                                 text_rectangle.X=client_rectangle.X+checkmark_size+checkmark_space;
 896                                                 text_rectangle.Width=client_rectangle.Width-checkmark_size-checkmark_space;
 897                                                 break;
 898                                         }
 899
 900                                         case ContentAlignment.MiddleRight: {
 901                                                 checkbox_rectangle.X=client_rectangle.Right-checkmark_size;
 902                                                 checkbox_rectangle.Y=(client_rectangle.Bottom-client_rectangle.Top)/2-checkmark_size/2;
 903                                                 text_rectangle.X=client_rectangle.X;
 904                                                 text_rectangle.Width=client_rectangle.Width-checkmark_size-checkmark_space;
 905                                                 break;
 906                                         }
 907
 908                                         case ContentAlignment.TopCenter: {
 909                                                 checkbox_rectangle.X=(client_rectangle.Right-client_rectangle.Left)/2-checkmark_size/2;
 910                                                 checkbox_rectangle.Y=client_rectangle.Top;
 911                                                 text_rectangle.X=client_rectangle.X;
 912                                                 text_rectangle.Width=client_rectangle.Width;
 913                                                 text_rectangle.Y=checkmark_size+checkmark_space;
 914                                                 text_rectangle.Height=client_rectangle.Height-checkmark_size-checkmark_space;
 915                                                 break;
 916                                         }
 917
 918                                         case ContentAlignment.TopLeft: {
 919                                                 checkbox_rectangle.X=client_rectangle.Left;
 920                                                 text_rectangle.X=client_rectangle.X+checkmark_size+checkmark_space;
 921                                                 text_rectangle.Width=client_rectangle.Width-checkmark_size-checkmark_space;
 922                                                 break;
 923                                         }
 924
 925                                         case ContentAlignment.TopRight: {
 926                                                 checkbox_rectangle.X=client_rectangle.Right-checkmark_size;
 927                                                 text_rectangle.X=client_rectangle.X;
 928                                                 text_rectangle.Width=client_rectangle.Width-checkmark_size-checkmark_space;
 929                                                 break;
 930                                         }
 931                                 }
 932                         } else {
 933                                 text_rectangle.X=client_rectangle.X;
 934                                 text_rectangle.Width=client_rectangle.Width;
 935                         }
 936
 937                         /* Set the horizontal alignment of our text */
 938                         switch(checkbox.text_alignment) {
 939                                 case ContentAlignment.BottomLeft:
 940                                 case ContentAlignment.MiddleLeft:
 941                                 case ContentAlignment.TopLeft: {
 942                                         text_format.Alignment=StringAlignment.Near;
 943                                         break;
 944                                 }
 945
 946                                 case ContentAlignment.BottomCenter:
 947                                 case ContentAlignment.MiddleCenter:
 948                                 case ContentAlignment.TopCenter: {
 949                                         text_format.Alignment=StringAlignment.Center;
 950                                         break;
 951                                 }
 952
 953                                 case ContentAlignment.BottomRight:
 954                                 case ContentAlignment.MiddleRight:
 955                                 case ContentAlignment.TopRight: {
 956                                         text_format.Alignment=StringAlignment.Far;
 957                                         break;
 958                                 }
 959                         }
 960
 961                         /* Set the vertical alignment of our text */
 962                         switch(checkbox.text_alignment) {
 963                                 case ContentAlignment.TopLeft:
 964                                 case ContentAlignment.TopCenter:
 965                                 case ContentAlignment.TopRight: {
 966                                         text_format.LineAlignment=StringAlignment.Near;
 967                                         break;
 968                                 }
 969
 970                                 case ContentAlignment.BottomLeft:
 971                                 case ContentAlignment.BottomCenter:
 972                                 case ContentAlignment.BottomRight: {
 973                                         text_format.LineAlignment=StringAlignment.Far;
 974                                         break;
 975                                 }
 976
 977                                 case ContentAlignment.MiddleLeft:
 978                                 case ContentAlignment.MiddleCenter:
 979                                 case ContentAlignment.MiddleRight: {
 980                                         text_format.LineAlignment=StringAlignment.Center;
 981                                         break;
 982                                 }
 983                         }
 984
 985                         ButtonState state = ButtonState.Normal;
 986                         if (checkbox.FlatStyle == FlatStyle.Flat) {
 987                                 state |= ButtonState.Flat;
 988                         }
 989
 990                         if (checkbox.Checked) {
 991                                 state |= ButtonState.Checked;
 992                         }
 993
 994                         if (checkbox.ThreeState && (checkbox.CheckState == CheckState.Indeterminate)) {
 995                                 state |= ButtonState.Checked;
 996                                 state |= ButtonState.Pushed;
 997                         }
 998
 999                         // finally make sure the pushed and inavtive states are rendered
1000                         if (!checkbox.Enabled) {
1001                                 state |= ButtonState.Inactive;
1002                         }
1003                         else if (checkbox.is_pressed) {
1004                                 state |= ButtonState.Pushed;
1005                         }
1006
1007                         // Start drawing
1008
1009                         CheckBox_DrawCheckBox(dc, checkbox, state, checkbox_rectangle);
1010
1011                         if ((checkbox.image != null) || (checkbox.image_list != null))
1012                                 ButtonBase_DrawImage(checkbox, dc);
1013
1014                         CheckBox_DrawText(checkbox, text_rectangle, dc, text_format);
1015
1016                         CheckBox_DrawFocus(checkbox, dc, text_rectangle);
1017
1018                         text_format.Dispose ();
1019                 }
1020
1021                 protected virtual void CheckBox_DrawCheckBox( Graphics dc, CheckBox checkbox, ButtonState state, Rectangle checkbox_rectangle )
1022                 {
1023                         Brush brush = checkbox.BackColor.ToArgb () == ColorControl.ToArgb () ? SystemBrushes.Control : ResPool.GetSolidBrush (checkbox.BackColor);
1024                         dc.FillRectangle (brush, checkbox.ClientRectangle);
1025                         // render as per normal button
1026                         if (checkbox.appearance==Appearance.Button) {
1027                                 ButtonBase_DrawButton (checkbox, dc);
1028
1029                                 if ((checkbox.Focused) && checkbox.Enabled)
1030                                         ButtonBase_DrawFocus(checkbox, dc);
1031                         } else {
1032                                 // establish if we are rendering a flat style of some sort
1033                                 if (checkbox.FlatStyle == FlatStyle.Flat || checkbox.FlatStyle == FlatStyle.Popup) {
1034                                         DrawFlatStyleCheckBox (dc, checkbox_rectangle, checkbox);
1035                                 } else {
1036                                         CPDrawCheckBox (dc, checkbox_rectangle, state);
1037                                 }
1038                         }
1039                 }
1040
1041                 protected virtual void CheckBox_DrawText( CheckBox checkbox, Rectangle text_rectangle, Graphics dc, StringFormat text_format )
1042                 {
1043                         DrawCheckBox_and_RadioButtonText (checkbox, text_rectangle, dc,
1044                                                           text_format, checkbox.Appearance, checkbox.Checked);
1045                 }
1046
1047                 protected virtual void CheckBox_DrawFocus( CheckBox checkbox, Graphics dc, Rectangle text_rectangle )
1048                 {
1049                         if ( checkbox.Focused && checkbox.appearance != Appearance.Button && checkbox.Enabled )
1050                                 DrawInnerFocusRectangle( dc, text_rectangle, checkbox.BackColor );
1051                 }
1052
1053                 // renders a checkBox with the Flat and Popup FlatStyle
1054                 protected virtual void DrawFlatStyleCheckBox (Graphics graphics, Rectangle rectangle, CheckBox checkbox)
1055                 {
1056                         Pen                     pen;
1057                         Rectangle       rect;
1058                         Rectangle       checkbox_rectangle;
1059                         Rectangle       fill_rectangle;
1060                         int                     lineWidth;
1061                         int                     Scale;
1062
1063                         // set up our rectangles first
1064                         if (checkbox.FlatStyle == FlatStyle.Popup && checkbox.is_entered) {
1065                                 // clip one pixel from bottom right for non popup rendered checkboxes
1066                                 checkbox_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max(rectangle.Width-1, 0), Math.Max(rectangle.Height-1,0));
1067                                 fill_rectangle = new Rectangle(checkbox_rectangle.X+1, checkbox_rectangle.Y+1, Math.Max(checkbox_rectangle.Width-3, 0), Math.Max(checkbox_rectangle.Height-3,0));
1068                         } else {
1069                                 // clip two pixels from bottom right for non popup rendered checkboxes
1070                                 checkbox_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max(rectangle.Width-2, 0), Math.Max(rectangle.Height-2,0));
1071                                 fill_rectangle = new Rectangle(checkbox_rectangle.X+1, checkbox_rectangle.Y+1, Math.Max(checkbox_rectangle.Width-2, 0), Math.Max(checkbox_rectangle.Height-2,0));
1072                         }
1073
1074
1075                         // if disabled render in disabled state
1076                         if (checkbox.Enabled) {
1077                                 // process the state of the checkbox
1078                                 if (checkbox.is_entered || checkbox.Capture) {
1079                                         // decide on which background color to use
1080                                         if (checkbox.FlatStyle == FlatStyle.Popup && checkbox.is_entered && checkbox.Capture) {
1081                                                 graphics.FillRectangle(ResPool.GetSolidBrush (checkbox.BackColor), fill_rectangle);
1082                                         } else if (checkbox.FlatStyle == FlatStyle.Flat) {
1083                                                 if (!checkbox.is_pressed) {
1084                                                         graphics.FillRectangle(ResPool.GetSolidBrush (checkbox.BackColor), fill_rectangle);
1085                                                 } else
1086                                                         graphics.FillRectangle(ResPool.GetSolidBrush (ControlPaint.LightLight (checkbox.BackColor)), fill_rectangle);
1087                                         } else {
1088                                                 // use regular window background color
1089                                                 graphics.FillRectangle(ResPool.GetSolidBrush (ControlPaint.LightLight (checkbox.BackColor)), fill_rectangle);
1090                                         }
1091
1092                                         // render the outer border
1093                                         if (checkbox.FlatStyle == FlatStyle.Flat) {
1094                                                 ControlPaint.DrawBorder(graphics, checkbox_rectangle, checkbox.ForeColor, ButtonBorderStyle.Solid);
1095                                         } else {
1096                                                 // draw sunken effect
1097                                                 CPDrawBorder3D (graphics, checkbox_rectangle, Border3DStyle.SunkenInner, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, checkbox.BackColor);
1098                                         }
1099                                 } else {
1100                                         graphics.FillRectangle(ResPool.GetSolidBrush (ControlPaint.LightLight (checkbox.BackColor)), fill_rectangle);
1101
1102                                         if (checkbox.FlatStyle == FlatStyle.Flat) {
1103                                                 ControlPaint.DrawBorder(graphics, checkbox_rectangle, checkbox.ForeColor, ButtonBorderStyle.Solid);
1104                                         } else {
1105                                                 // draw the outer border
1106                                                 ControlPaint.DrawBorder(graphics, checkbox_rectangle, ControlPaint.DarkDark (checkbox.BackColor), ButtonBorderStyle.Solid);
1107                                         }
1108                                 }
1109                         } else {
1110                                 if (checkbox.FlatStyle == FlatStyle.Popup) {
1111                                         graphics.FillRectangle(SystemBrushes.Control, fill_rectangle);
1112                                 }
1113
1114                                 // draw disabled state,
1115                                 ControlPaint.DrawBorder(graphics, checkbox_rectangle, ColorControlDark, ButtonBorderStyle.Solid);
1116                         }
1117
1118                         if (checkbox.Checked) {
1119                                 /* Need to draw a check-mark */
1120
1121                                 /* Make sure we've got at least a line width of 1 */
1122                                 lineWidth = Math.Max(3, fill_rectangle.Width/3);
1123                                 Scale=Math.Max(1, fill_rectangle.Width/9);
1124
1125                                 // flat style check box is rendered inside a rectangle shifted down by one
1126                                 rect=new Rectangle(fill_rectangle.X, fill_rectangle.Y+1, fill_rectangle.Width, fill_rectangle.Height);
1127                                 if (checkbox.Enabled) {
1128                                         pen=ResPool.GetPen(checkbox.ForeColor);
1129                                 } else {
1130                                         pen=SystemPens.ControlDark;
1131                                 }
1132
1133                                 for (int i=0; i<lineWidth; i++) {
1134                                         graphics.DrawLine(pen, rect.Left+lineWidth/2, rect.Top+lineWidth+i, rect.Left+lineWidth/2+2*Scale, rect.Top+lineWidth+2*Scale+i);
1135                                         graphics.DrawLine(pen, rect.Left+lineWidth/2+2*Scale, rect.Top+lineWidth+2*Scale+i, rect.Left+lineWidth/2+6*Scale, rect.Top+lineWidth-2*Scale+i);
1136                                 }
1137                         }
1138                 }
1139
1140                 private void DrawCheckBox_and_RadioButtonText (ButtonBase button_base, Rectangle text_rectangle, Graphics dc,
1141                                                                StringFormat text_format, Appearance appearance, bool ischecked)
1142                 {
1143                         // offset the text if it's pressed and a button
1144                         if (appearance == Appearance.Button) {
1145                                 if (ischecked || (button_base.Capture && button_base.FlatStyle != FlatStyle.Flat)) {
1146                                         text_rectangle.X ++;
1147                                         text_rectangle.Y ++;
1148                                 }
1149
1150                                 text_rectangle.Inflate (-4, -4);
1151                         }
1152
1153                         /* Place the text; to be compatible with Windows place it after the checkbox has been drawn */
1154
1155                         // Windows seems to not wrap text in certain situations, this matches as close as I could get it
1156                         if ((float)(button_base.Font.Height * 1.5f) > text_rectangle.Height) {
1157                                 text_format.FormatFlags |= StringFormatFlags.NoWrap;
1158                         }
1159                         if (button_base.Enabled) {
1160                                 dc.DrawString (button_base.Text, button_base.Font, ResPool.GetSolidBrush (button_base.ForeColor), text_rectangle, text_format);
1161                         } else if (button_base.FlatStyle == FlatStyle.Flat || button_base.FlatStyle == FlatStyle.Popup) {
1162                                 dc.DrawString (button_base.Text, button_base.Font, SystemBrushes.ControlDarkDark, text_rectangle, text_format);
1163                         } else {
1164                                 CPDrawStringDisabled (dc, button_base.Text, button_base.Font, button_base.BackColor, text_rectangle, text_format);
1165                         }
1166                 }
1167                 #endregion      // CheckBox
1168
1169                 #region CheckedListBox
1170
1171                 public override void DrawCheckedListBoxItem (CheckedListBox ctrl, DrawItemEventArgs e)
1172                 {
1173                         Color back_color, fore_color;
1174                         Rectangle item_rect = e.Bounds;
1175                         ButtonState state;
1176
1177                         /* Draw checkbox */
1178
1179                         if ((e.State & DrawItemState.Checked) == DrawItemState.Checked) {
1180                                 state = ButtonState.Checked;
1181                                 if ((e.State & DrawItemState.Inactive) == DrawItemState.Inactive)
1182                                         state |= ButtonState.Inactive;
1183                         } else
1184                                 state = ButtonState.Normal;
1185
1186                         if (ctrl.ThreeDCheckBoxes == false)
1187                                 state |= ButtonState.Flat;
1188
1189                         Rectangle checkbox_rect = new Rectangle (2, (item_rect.Height - 11) / 2, 11, 11);
1190                         ControlPaint.DrawCheckBox (e.Graphics,
1191                                 item_rect.X + checkbox_rect.X, item_rect.Y + checkbox_rect.Y,
1192                                 checkbox_rect.Width, checkbox_rect.Height,
1193                                 state);
1194
1195                         item_rect.X += checkbox_rect.Width + checkbox_rect.X * 2;
1196                         item_rect.Width -= checkbox_rect.Width + checkbox_rect.X * 2;
1197
1198                         /* Draw text*/
1199                         if ((e.State & DrawItemState.Selected) == DrawItemState.Selected) {
1200                                 back_color = ColorHighlight;
1201                                 fore_color = ColorHighlightText;
1202                         }
1203                         else {
1204                                 back_color = e.BackColor;
1205                                 fore_color = e.ForeColor;
1206                         }
1207
1208                         e.Graphics.FillRectangle (ResPool.GetSolidBrush
1209                                 (back_color), item_rect);
1210
1211                         e.Graphics.DrawString (ctrl.GetItemText (ctrl.Items[e.Index]), e.Font,
1212                                 ResPool.GetSolidBrush (fore_color),
1213                                 item_rect, ctrl.StringFormat);
1214
1215                         if ((e.State & DrawItemState.Focus) == DrawItemState.Focus) {
1216                                 CPDrawFocusRectangle (e.Graphics, item_rect,
1217                                         fore_color, back_color);
1218                         }
1219                 }
1220
1221                 #endregion // CheckedListBox
1222
1223                 #region ComboBox
1224                 public override void DrawComboBoxItem (ComboBox ctrl, DrawItemEventArgs e)
1225                 {
1226                         Color back_color, fore_color;
1227                         Rectangle text_draw = e.Bounds;
1228                         StringFormat string_format = new StringFormat ();
1229                         string_format.FormatFlags = StringFormatFlags.LineLimit;
1230
1231                         if ((e.State & DrawItemState.Selected) == DrawItemState.Selected) {
1232                                 back_color = ColorHighlight;
1233                                 fore_color = ColorHighlightText;
1234                         }
1235                         else {
1236                                 back_color = e.BackColor;
1237                                 fore_color = e.ForeColor;
1238                         }
1239
1240                         if (!ctrl.Enabled)
1241                                 fore_color = ColorInactiveCaptionText;
1242
1243                         e.Graphics.FillRectangle (ResPool.GetSolidBrush (back_color), e.Bounds);
1244
1245                         if (e.Index != -1) {
1246                                 e.Graphics.DrawString (ctrl.GetItemText (ctrl.Items[e.Index]), e.Font,
1247                                         ResPool.GetSolidBrush (fore_color),
1248                                         text_draw, string_format);
1249                         }
1250
1251                         if ((e.State & DrawItemState.Focus) == DrawItemState.Focus) {
1252                                 CPDrawFocusRectangle (e.Graphics, e.Bounds, fore_color, back_color);
1253                         }
1254
1255                         string_format.Dispose ();
1256                 }
1257
1258                 public override void DrawFlatStyleComboButton (Graphics graphics, Rectangle rectangle, ButtonState state)
1259                 {
1260                         Point[]                 arrow = new Point[3];
1261                         Point                           P1;
1262                         Point                           P2;
1263                         Point                           P3;
1264                         int                             centerX;
1265                         int                             centerY;
1266                         int                             shiftX;
1267                         int                             shiftY;
1268                         Rectangle               rect;
1269
1270                         rect=new Rectangle(rectangle.X+rectangle.Width/4, rectangle.Y+rectangle.Height/4, rectangle.Width/2, rectangle.Height/2);
1271                         centerX=rect.Left+rect.Width/2;
1272                         centerY=rect.Top+rect.Height/2;
1273                         shiftX=Math.Max(1, rect.Width/8);
1274                         shiftY=Math.Max(1, rect.Height/8);
1275
1276                         if ((state & ButtonState.Pushed)!=0) {
1277                                 shiftX++;
1278                                 shiftY++;
1279                         }
1280
1281                         rect.Y-=shiftY;
1282                         centerY-=shiftY;
1283                         P1=new Point(rect.Left + 1, centerY);
1284                         P2=new Point(rect.Right - 1, centerY);
1285                         P3=new Point(centerX, rect.Bottom - 1);
1286
1287                         arrow[0]=P1;
1288                         arrow[1]=P2;
1289                         arrow[2]=P3;
1290
1291                         /* Draw the arrow */
1292                         if ((state & ButtonState.Inactive)!=0) {
1293                                 /* Move away from the shadow */
1294                                 arrow[0].X += 1;        arrow[0].Y += 1;
1295                                 arrow[1].X += 1;        arrow[1].Y += 1;
1296                                 arrow[2].X += 1;        arrow[2].Y += 1;
1297
1298                                 graphics.FillPolygon(SystemBrushes.ControlLightLight, arrow, FillMode.Winding);
1299
1300                                 arrow[0]=P1;
1301                                 arrow[1]=P2;
1302                                 arrow[2]=P3;
1303
1304                                 graphics.FillPolygon(SystemBrushes.ControlDark, arrow, FillMode.Winding);
1305                         } else {
1306                                 graphics.FillPolygon(SystemBrushes.ControlText, arrow, FillMode.Winding);
1307                         }
1308                 }
1309                 #endregion ComboBox
1310
1311                 #region Datagrid
1312                 public override int DataGridPreferredColumnWidth { get { return 75;} }
1313                 public override int DataGridMinimumColumnCheckBoxHeight { get { return 16;} }
1314                 public override int DataGridMinimumColumnCheckBoxWidth { get { return 16;} }
1315                 public override Color DataGridAlternatingBackColor { get { return ColorWindow;} }
1316                 public override Color DataGridBackColor { get  { return  ColorWindow;} }
1317                 public override Color DataGridBackgroundColor { get  { return  ColorAppWorkspace;} }
1318                 public override Color DataGridCaptionBackColor { get  { return ColorActiveCaption;} }
1319                 public override Color DataGridCaptionForeColor { get  { return ColorActiveCaptionText;} }
1320                 public override Color DataGridGridLineColor { get { return ColorControl;} }
1321                 public override Color DataGridHeaderBackColor { get  { return ColorControl;} }
1322                 public override Color DataGridHeaderForeColor { get  { return ColorControlText;} }
1323                 public override Color DataGridLinkColor { get  { return ColorHotTrack;} }
1324                 public override Color DataGridLinkHoverColor { get  { return ColorHotTrack;} }
1325                 public override Color DataGridParentRowsBackColor { get  { return ColorControl;} }
1326                 public override Color DataGridParentRowsForeColor { get  { return ColorWindowText;} }
1327                 public override Color DataGridSelectionBackColor { get  { return ColorActiveCaption;} }
1328                 public override Color DataGridSelectionForeColor { get  { return ColorActiveCaptionText;} }
1329
1330                 public override void DataGridPaint (PaintEventArgs pe, DataGrid grid)
1331                 {
1332                         DataGridPaintCaption (pe.Graphics, pe.ClipRectangle, grid);
1333                         DataGridPaintParentRows (pe.Graphics, pe.ClipRectangle, grid);
1334                         DataGridPaintColumnHeaders (pe.Graphics, pe.ClipRectangle, grid);
1335                         DataGridPaintRows (pe.Graphics, grid.cells_area, pe.ClipRectangle, grid);
1336
1337                         // Paint scrollBar corner
1338                         if (grid.VScrollBar.Visible && grid.HScrollBar.Visible) {
1339
1340                                 Rectangle corner = new Rectangle (grid.ClientRectangle.X + grid.ClientRectangle.Width - grid.VScrollBar.Width,
1341                                                                   grid.ClientRectangle.Y + grid.ClientRectangle.Height - grid.HScrollBar.Height,
1342                                                                   grid.VScrollBar.Width, grid.HScrollBar.Height);
1343
1344                                 if (pe.ClipRectangle.IntersectsWith (corner)) {
1345                                         pe.Graphics.FillRectangle (ResPool.GetSolidBrush (grid.ParentRowsBackColor),
1346                                                                    corner);
1347                                 }
1348                         }
1349                 }
1350
1351                 public override void DataGridPaintCaption (Graphics g, Rectangle clip, DataGrid grid)
1352                 {
1353                         Rectangle modified_area = clip;
1354                         modified_area.Intersect (grid.caption_area);
1355
1356                         g.FillRectangle (ResPool.GetSolidBrush (grid.CaptionBackColor),
1357                                          modified_area);
1358
1359                         Rectangle text_rect = grid.caption_area;
1360                         text_rect.Y += text_rect.Height / 2 - grid.CaptionFont.Height / 2;
1361                         text_rect.Height = grid.CaptionFont.Height;
1362
1363                         g.DrawString (grid.CaptionText, grid.CaptionFont,
1364                                       ResPool.GetSolidBrush (grid.CaptionForeColor),
1365                                       text_rect);
1366
1367                         if (modified_area.IntersectsWith (grid.back_button_rect)) {
1368                                 g.DrawImage (grid.back_button_image, grid.back_button_rect);
1369                                 if (grid.back_button_mouseover) {
1370                                         CPDrawBorder3D (g, grid.back_button_rect, grid.back_button_active ? Border3DStyle.Sunken : Border3DStyle.Raised, all_sides);
1371                                 }
1372                         }
1373                         if (modified_area.IntersectsWith (grid.parent_rows_button_rect)) {
1374                                 g.DrawImage (grid.parent_rows_button_image, grid.parent_rows_button_rect);
1375                                 if (grid.parent_rows_button_mouseover) {
1376                                         CPDrawBorder3D (g, grid.parent_rows_button_rect, grid.parent_rows_button_active ? Border3DStyle.Sunken : Border3DStyle.Raised, all_sides);
1377                                 }
1378                         }
1379                 }
1380
1381                 public override void DataGridPaintColumnHeaders (Graphics g, Rectangle clip, DataGrid grid)
1382                 {
1383                         Rectangle columns_area = grid.column_headers_area;
1384
1385                         if (grid.CurrentTableStyle.CurrentRowHeadersVisible) { // Paint corner shared between row and column header
1386                                 Rectangle rect_bloc = grid.column_headers_area;
1387                                 rect_bloc.Width = grid.RowHeaderWidth;
1388                                 if (clip.IntersectsWith (rect_bloc)) {
1389                                         if (grid.VisibleColumnCount > 0)
1390                                                 g.FillRectangle (ResPool.GetSolidBrush (grid.CurrentTableStyle.CurrentHeaderBackColor), rect_bloc);
1391                                         else
1392                                                 g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor), rect_bloc);
1393                                 }
1394
1395                                 columns_area.X += grid.RowHeaderWidth;
1396                                 columns_area.Width -= grid.RowHeaderWidth;
1397                         }
1398
1399                         // Set unused area
1400                         Rectangle column_headers_area_complete = columns_area;
1401                         column_headers_area_complete.Width = grid.column_headers_max_width;
1402
1403                         if (grid.CurrentTableStyle.CurrentRowHeadersVisible) {
1404                                 column_headers_area_complete.Width -= grid.RowHeaderWidth;
1405                         }
1406
1407                         // Set column painting
1408                         Rectangle rect_columnhdr = new Rectangle ();
1409                         int col_pixel;
1410                         Region current_clip;
1411                         Region prev_clip = g.Clip;
1412                         rect_columnhdr.Y = columns_area.Y;
1413                         rect_columnhdr.Height = columns_area.Height;
1414
1415                         int column_cnt = grid.FirstVisibleColumn + grid.VisibleColumnCount;
1416                         for (int column = grid.FirstVisibleColumn; column < column_cnt; column++) {
1417                                 if (grid.CurrentTableStyle.GridColumnStyles[column].bound == false)
1418                                         continue;
1419
1420                                 col_pixel = grid.GetColumnStartingPixel (column);
1421                                 rect_columnhdr.X = columns_area.X + col_pixel - grid.HorizPixelOffset;
1422                                 rect_columnhdr.Width = grid.CurrentTableStyle.GridColumnStyles[column].Width;
1423
1424                                 if (clip.IntersectsWith (rect_columnhdr) == false)
1425                                         continue;
1426
1427                                 current_clip = new Region (rect_columnhdr);
1428                                 current_clip.Intersect (columns_area);
1429                                 current_clip.Intersect (prev_clip);
1430                                 g.Clip = current_clip;
1431
1432                                 grid.CurrentTableStyle.GridColumnStyles[column].PaintHeader (g, rect_columnhdr, column);
1433
1434                                 current_clip.Dispose ();
1435                         }
1436
1437                         g.Clip = prev_clip;
1438
1439                         Rectangle not_usedarea = column_headers_area_complete;
1440                         not_usedarea.X = rect_columnhdr.X + rect_columnhdr.Width;
1441                         not_usedarea.Width = grid.ClientRectangle.X + grid.ClientRectangle.Width - rect_columnhdr.X - rect_columnhdr.Height;
1442                         g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor), not_usedarea);
1443
1444                 }
1445
1446                 public override void DataGridPaintParentRows (Graphics g, Rectangle clip, DataGrid grid)
1447                 {
1448                         Rectangle rect_row = new Rectangle ();
1449
1450                         rect_row.X = grid.ParentRowsArea.X;
1451                         rect_row.Width = grid.ParentRowsArea.Width;
1452                         rect_row.Height = (grid.CaptionFont.Height + 3);
1453
1454                         object[] parentRows = grid.data_source_stack.ToArray();
1455
1456                         Region current_clip;
1457                         Region prev_clip = g.Clip;
1458                         for (int row = 0; row < parentRows.Length; row++) {
1459                                 rect_row.Y = grid.ParentRowsArea.Y + row * rect_row.Height;
1460
1461                                 if (clip.IntersectsWith (rect_row) == false)
1462                                         continue;
1463
1464                                 current_clip = new Region (rect_row);
1465                                 current_clip.Intersect (prev_clip);
1466                                 g.Clip = current_clip;
1467
1468                                 DataGridPaintParentRow (g, rect_row, (DataGridDataSource)parentRows[parentRows.Length - row - 1], grid);
1469
1470                                 current_clip.Dispose ();
1471                         }
1472
1473                         g.Clip = prev_clip;
1474                 }
1475
1476                 public override void DataGridPaintParentRow (Graphics g, Rectangle bounds, DataGridDataSource row, DataGrid grid)
1477                 {
1478                         //Console.WriteLine ("drawing parent row {0}", row);
1479
1480                         // Background
1481                         g.FillRectangle (ResPool.GetSolidBrush (grid.ParentRowsBackColor),
1482                                          bounds);
1483
1484                         Font bold_font = new Font (grid.Font.FontFamily, grid.Font.Size, grid.Font.Style | FontStyle.Bold);
1485                         // set up some standard string formating variables
1486                         StringFormat text_format = new StringFormat();
1487                         text_format.LineAlignment = StringAlignment.Center;
1488                         text_format.Alignment = StringAlignment.Near;
1489
1490                         string table_name = "";
1491                         if (row.view is DataRowView)
1492                                 table_name = ((ITypedList)((DataRowView)row.view).DataView).GetListName (null) + ": ";
1493                         // XXX else?
1494
1495                         Rectangle       text_rect;
1496                         Size            text_size;
1497
1498                         text_size = g.MeasureString (table_name, bold_font).ToSize();
1499                         text_rect = new Rectangle(new Point(bounds.X + 3, bounds.Y + bounds.Height - text_size.Height), text_size);
1500
1501                         //Console.WriteLine ("drawing text at {0}", text_rect);
1502
1503                         g.DrawString (table_name,
1504                                       bold_font, ResPool.GetSolidBrush (grid.ParentRowsForeColor), text_rect, text_format);
1505
1506                         foreach (PropertyDescriptor pd in ((ICustomTypeDescriptor)row.view).GetProperties()) {
1507                                 if (typeof(IBindingList).IsAssignableFrom (pd.PropertyType))
1508                                         continue;
1509
1510                                 text_rect.X += text_rect.Size.Width + 5;
1511
1512                                 string text = String.Format ("{0}: {1}",
1513                                                              pd.Name,
1514                                                              pd.GetValue (row.view));
1515
1516                                 text_rect.Size = g.MeasureString (text, grid.Font).ToSize();
1517                                 text_rect.Y = bounds.Y + bounds.Height - text_rect.Height; // XXX
1518
1519                                 //Console.WriteLine ("drawing text at {0}", text_rect);
1520
1521                                 g.DrawString (text,
1522                                               grid.Font, ResPool.GetSolidBrush (grid.ParentRowsForeColor), text_rect, text_format);
1523                         }
1524
1525                         if (grid.FlatMode == false) {
1526
1527                                 // Paint Borders
1528                                 g.DrawLine (ResPool.GetPen (ColorControlLight),
1529                                         bounds.X, bounds.Y, bounds.X + bounds.Width, bounds.Y);
1530
1531                                 g.DrawLine (ResPool.GetPen (ColorControlLight),
1532                                         bounds.X, bounds.Y + 1, bounds.X, bounds.Y + bounds.Height - 1);
1533
1534                                 g.DrawLine (ResPool.GetPen (ColorControlDark),
1535                                         bounds.X + bounds.Width - 1, bounds.Y + 1 , bounds.X + bounds.Width - 1, bounds.Y + bounds.Height - 1);
1536
1537                                 g.DrawLine (ResPool.GetPen (ColorControlDark),
1538                                         bounds.X, bounds.Y + bounds.Height -1, bounds.X + bounds.Width, bounds.Y  + bounds.Height -1);
1539                         }
1540                 }
1541
1542                 public override void DataGridPaintRowHeaderArrow (Graphics g, Rectangle bounds, DataGrid grid)
1543                 {
1544                         Point[] arrow = new Point[3];
1545                         Point P1, P2, P3;
1546                         int centerX, centerY, shiftX;
1547                         Rectangle rect;
1548
1549                         rect = new Rectangle (bounds.X + bounds.Width /4,
1550                                 bounds.Y + bounds.Height/4, bounds.Width / 2, bounds.Height / 2);
1551
1552                         centerX = rect.Left + rect.Width / 2;
1553                         centerY = rect.Top + rect.Height / 2;
1554                         shiftX = Math.Max (1, rect.Width / 8);
1555                         rect.X -= shiftX;
1556                         centerX -= shiftX;
1557                         P1 = new Point (centerX, rect.Top - 1);
1558                         P2 = new Point (centerX, rect.Bottom);
1559                         P3 = new Point (rect.Right, centerY);
1560                         arrow[0] = P1;
1561                         arrow[1] = P2;
1562                         arrow[2] = P3;
1563
1564                         g.FillPolygon (ResPool.GetSolidBrush
1565                                 (grid.CurrentTableStyle.CurrentHeaderForeColor), arrow, FillMode.Winding);
1566                 }
1567
1568                 public override void DataGridPaintRowHeader (Graphics g, Rectangle bounds, int row, DataGrid grid)
1569                 {
1570                         bool is_add_row = grid.ShowEditRow && row == grid.DataGridRows.Length - 1;
1571                         bool is_current_row = row == grid.CurrentCell.RowNumber;
1572
1573                         // Background
1574                         g.FillRectangle (ResPool.GetSolidBrush (grid.CurrentTableStyle.CurrentHeaderBackColor),
1575                                          bounds);
1576
1577                         // Draw arrow
1578                         if (is_current_row) {
1579                                 if (grid.IsChanging) {
1580                                         g.DrawString ("...", grid.Font,
1581                                                       ResPool.GetSolidBrush (grid.CurrentTableStyle.CurrentHeaderForeColor),
1582                                                       bounds);
1583                                 } else {
1584                                         Rectangle rect = new Rectangle (bounds.X - 2, bounds.Y, 18, 18);
1585                                         DataGridPaintRowHeaderArrow (g, rect, grid);
1586                                 }
1587                         }
1588                         else if (is_add_row) {
1589                                 g.DrawString ("*", grid.Font, ResPool.GetSolidBrush (grid.CurrentTableStyle.CurrentHeaderForeColor),
1590                                               bounds);
1591                         }
1592
1593                         if (grid.FlatMode == false && !is_add_row) {
1594                                 // Paint Borders
1595                                 g.DrawLine (ResPool.GetPen (ColorControlLight),
1596                                             bounds.X, bounds.Y, bounds.X + bounds.Width, bounds.Y);
1597
1598                                 g.DrawLine (ResPool.GetPen (ColorControlLight),
1599                                             bounds.X, bounds.Y + 1, bounds.X, bounds.Y + bounds.Height - 1);
1600
1601                                 g.DrawLine (ResPool.GetPen (ColorControlDark),
1602                                             bounds.X + bounds.Width - 1, bounds.Y + 1 , bounds.X + bounds.Width - 1, bounds.Y + bounds.Height - 1);
1603
1604                                 g.DrawLine (ResPool.GetPen (ColorControlDark),
1605                                             bounds.X, bounds.Y + bounds.Height -1, bounds.X + bounds.Width, bounds.Y  + bounds.Height -1);
1606                         }
1607                 }
1608
1609                 public override void DataGridPaintRows (Graphics g, Rectangle cells, Rectangle clip, DataGrid grid)
1610                 {
1611                         Rectangle rect_row = new Rectangle ();
1612                         Rectangle not_usedarea = new Rectangle ();
1613
1614                         int rowcnt = grid.VisibleRowCount;
1615
1616                         bool showing_add_row = false;
1617
1618                         if (grid.RowsCount < grid.DataGridRows.Length) {
1619                                 /* the table has an add row */
1620
1621                                 if (grid.FirstVisibleRow + grid.VisibleRowCount >= grid.DataGridRows.Length) {
1622                                         showing_add_row = true;
1623                                 }
1624                         }
1625
1626                         rect_row.Width = cells.Width + grid.RowHeadersArea.Width;
1627                         for (int r = 0; r < rowcnt; r++) {
1628                                 int row = grid.FirstVisibleRow + r;
1629                                 if (row == grid.DataGridRows.Length - 1)
1630                                         rect_row.Height = grid.DataGridRows[row].Height;
1631                                 else
1632                                         rect_row.Height = grid.DataGridRows[row + 1].VerticalOffset - grid.DataGridRows[row].VerticalOffset;
1633                                 rect_row.Y = cells.Y + grid.DataGridRows[row].VerticalOffset - grid.DataGridRows[grid.FirstVisibleRow].VerticalOffset;
1634                                 if (clip.IntersectsWith (rect_row)) {
1635                                         if (grid.CurrentTableStyle.HasRelations
1636                                             && !(showing_add_row && row == grid.DataGridRows.Length - 1))
1637                                                 DataGridPaintRelationRow (g, row, rect_row, false, clip, grid);
1638                                         else
1639                                                 DataGridPaintRow (g, row, rect_row, showing_add_row && row == grid.DataGridRows.Length - 1, clip, grid);
1640                                 }
1641                         }
1642
1643                         not_usedarea.X = 0;
1644                         // the rowcnt == 0 check is needed because
1645                         // otherwise we'd draw over the caption on
1646                         // empty datasources (since rect_row would be
1647                         // Empty)
1648                         if (rowcnt == 0)
1649                                 not_usedarea.Y = cells.Y;
1650                         else
1651                                 not_usedarea.Y = rect_row.Y + rect_row.Height;
1652                         not_usedarea.Height = cells.Y + cells.Height - rect_row.Y - rect_row.Height;
1653                         not_usedarea.Width = cells.Width + grid.RowHeadersArea.Width;
1654
1655                         g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor), not_usedarea);
1656                 }
1657
1658                 public override void DataGridPaintRelationRow (Graphics g, int row, Rectangle row_rect, bool is_newrow,
1659                                                                Rectangle clip, DataGrid grid)
1660                 {
1661                         Rectangle rect_header;
1662                         Rectangle icon_bounds = new Rectangle ();
1663                         Pen pen = ThemeEngine.Current.ResPool.GetPen (grid.CurrentTableStyle.ForeColor);
1664
1665                         /* paint the header if it's visible and intersects the clip */
1666                         if (grid.CurrentTableStyle.CurrentRowHeadersVisible) {
1667                                 rect_header = row_rect;
1668                                 rect_header.Width = grid.RowHeaderWidth;
1669                                 row_rect.X += grid.RowHeaderWidth;
1670                                 if (clip.IntersectsWith (rect_header)) {
1671                                         DataGridPaintRowHeader (g, rect_header, row, grid);
1672                                 }
1673
1674                                 icon_bounds = rect_header;
1675                                 icon_bounds.X += icon_bounds.Width / 2;
1676                                 icon_bounds.Y += 3;
1677                                 icon_bounds.Width = 8;
1678                                 icon_bounds.Height = 8;
1679
1680                                 g.DrawRectangle (pen, icon_bounds);
1681
1682                                 /* the - part of the icon */
1683                                 g.DrawLine (pen,
1684                                             icon_bounds.X + 2, icon_bounds.Y + icon_bounds.Height / 2,
1685                                             icon_bounds.X + icon_bounds.Width - 2, icon_bounds.Y + icon_bounds.Height / 2);
1686
1687                                 if (!grid.IsExpanded (row)) {
1688                                         /* the | part of the icon */
1689                                         g.DrawLine (pen,
1690                                                     icon_bounds.X + icon_bounds.Width / 2, icon_bounds.Y + 2,
1691                                                     icon_bounds.X + icon_bounds.Width / 2, icon_bounds.Y + icon_bounds.Height - 2);
1692                                 }
1693                         }
1694
1695                         Rectangle nested_rect = row_rect;
1696
1697                         if (grid.DataGridRows[row].IsExpanded)
1698                                 nested_rect.Height -= grid.DataGridRows[row].RelationHeight;
1699
1700                         DataGridPaintRowContents (g, row, nested_rect, is_newrow, clip, grid);
1701
1702                         if (grid.DataGridRows[row].IsExpanded) {
1703                                 // XXX we should create this in the
1704                                 // datagrid and cache it for use by
1705                                 // the theme instead of doing it each
1706                                 // time through here
1707                                 string[] relations = grid.CurrentTableStyle.Relations;
1708                                 StringBuilder relation_builder = new StringBuilder ("");
1709
1710                                 for (int i = 0; i < relations.Length; i ++) {
1711                                         if (i > 0)
1712                                                 relation_builder.Append ("\n");
1713
1714                                         relation_builder.Append (relations[i]);
1715                                 }
1716                                 string relation_text = relation_builder.ToString ();
1717
1718                                 StringFormat string_format = new StringFormat ();
1719                                 string_format.FormatFlags |= StringFormatFlags.NoWrap;
1720
1721
1722                                 //Region prev_clip = g.Clip;
1723                                 //Region current_clip;
1724                                 Rectangle rect_cell = row_rect;
1725
1726                                 rect_cell.X = nested_rect.X + grid.GetColumnStartingPixel (grid.FirstVisibleColumn) - grid.HorizPixelOffset;
1727                                 rect_cell.Y += nested_rect.Height;
1728                                 rect_cell.Height = grid.DataGridRows[row].RelationHeight;
1729
1730                                 rect_cell.Width = 0;
1731                                 int column_cnt = grid.FirstVisibleColumn + grid.VisibleColumnCount;
1732                                 for (int column = grid.FirstVisibleColumn; column < column_cnt; column++) {
1733                                         if (grid.CurrentTableStyle.GridColumnStyles[column].bound == false)
1734                                                 continue;
1735                                         rect_cell.Width += grid.CurrentTableStyle.GridColumnStyles[column].Width;
1736                                 }
1737                                 rect_cell.Width = Math.Max (rect_cell.Width, grid.DataGridRows[row].relation_area.Width);
1738
1739                                 g.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (grid.CurrentTableStyle.BackColor),
1740                                                  rect_cell);
1741
1742
1743                                 /* draw the line leading from the +/- to the relation area */
1744                                 Rectangle outline = grid.DataGridRows[row].relation_area;
1745                                 outline.Y = rect_cell.Y;
1746                                 outline.Height --;
1747
1748                                 g.DrawLine (pen,
1749                                             icon_bounds.X + icon_bounds.Width / 2, icon_bounds.Y + icon_bounds.Height,
1750                                             icon_bounds.X + icon_bounds.Width / 2, outline.Y + outline.Height / 2);
1751
1752                                 g.DrawLine (pen,
1753                                             icon_bounds.X + icon_bounds.Width / 2, outline.Y + outline.Height / 2,
1754                                             outline.X, outline.Y + outline.Height / 2);
1755
1756                                 g.DrawRectangle (pen, outline);
1757
1758                                 g.DrawString (relation_text, grid.LinkFont, ResPool.GetSolidBrush (grid.LinkColor),
1759                                               outline, string_format);
1760
1761                                 if (row_rect.X + row_rect.Width > rect_cell.X + rect_cell.Width) {
1762                                         Rectangle not_usedarea = new Rectangle ();
1763                                         not_usedarea.X = rect_cell.X + rect_cell.Width;
1764                                         not_usedarea.Width = row_rect.X + row_rect.Width - rect_cell.X - rect_cell.Width;
1765                                         not_usedarea.Y = row_rect.Y;
1766                                         not_usedarea.Height = row_rect.Height;
1767                                         if (clip.IntersectsWith (not_usedarea))
1768                                                 g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor),
1769                                                                  not_usedarea);
1770                                 }
1771                         }
1772                 }
1773
1774                 public override void DataGridPaintRowContents (Graphics g, int row, Rectangle row_rect, bool is_newrow,
1775                                                                Rectangle clip, DataGrid grid)
1776                 {
1777                         Rectangle rect_cell = new Rectangle ();
1778                         int col_pixel;
1779                         Color backcolor, forecolor;
1780                         Brush backBrush, foreBrush;
1781                         Rectangle not_usedarea = Rectangle.Empty;
1782
1783                         rect_cell.Y = row_rect.Y;
1784                         rect_cell.Height = row_rect.Height;
1785
1786                         if (grid.IsSelected (row)) {
1787                                 backcolor =  grid.SelectionBackColor;
1788                                 forecolor =  grid.SelectionForeColor;
1789                         } else {
1790                                 if (row % 2 == 0) {
1791                                         backcolor =  grid.BackColor;
1792                                 } else {
1793                                         backcolor =  grid.AlternatingBackColor;
1794                                 }
1795
1796                                 forecolor =  grid.ForeColor;
1797                         }
1798
1799
1800                         backBrush = ResPool.GetSolidBrush (backcolor);
1801                         foreBrush = ResPool.GetSolidBrush (forecolor);
1802
1803                         // PaintCells at row, column
1804                         int column_cnt = grid.FirstVisibleColumn + grid.VisibleColumnCount;
1805
1806                         if (column_cnt > 0) {
1807                                 Region prev_clip = g.Clip;
1808                                 Region current_clip;
1809
1810                                 for (int column = grid.FirstVisibleColumn; column < column_cnt; column++) {
1811                                         if (grid.CurrentTableStyle.GridColumnStyles[column].bound == false)
1812                                                 continue;
1813
1814                                         col_pixel = grid.GetColumnStartingPixel (column);
1815
1816                                         rect_cell.X = row_rect.X + col_pixel - grid.HorizPixelOffset;
1817                                         rect_cell.Width = grid.CurrentTableStyle.GridColumnStyles[column].Width;
1818
1819                                         if (clip.IntersectsWith (rect_cell)) {
1820                                                 current_clip = new Region (rect_cell);
1821                                                 current_clip.Intersect (row_rect);
1822                                                 current_clip.Intersect (prev_clip);
1823                                                 g.Clip = current_clip;
1824
1825                                                 if (is_newrow) {
1826                                                         grid.CurrentTableStyle.GridColumnStyles[column].PaintNewRow (g, rect_cell,
1827                                                                                                                      backBrush,
1828                                                                                                                      foreBrush);
1829                                                 } else {
1830                                                         grid.CurrentTableStyle.GridColumnStyles[column].Paint (g, rect_cell, grid.ListManager, row,
1831                                                                                                                backBrush,
1832                                                                                                                foreBrush,
1833                                                                                                                grid.RightToLeft == RightToLeft.Yes);
1834                                                 }
1835
1836                                                 current_clip.Dispose ();
1837                                         }
1838                                 }
1839
1840                                 g.Clip = prev_clip;
1841
1842                                 if (row_rect.X + row_rect.Width > rect_cell.X + rect_cell.Width) {
1843                                         not_usedarea.X = rect_cell.X + rect_cell.Width;
1844                                         not_usedarea.Width = row_rect.X + row_rect.Width - rect_cell.X - rect_cell.Width;
1845                                         not_usedarea.Y = row_rect.Y;
1846                                         not_usedarea.Height = row_rect.Height;
1847                                 }
1848                         }
1849                         else {
1850                                 not_usedarea = row_rect;
1851                         }
1852
1853                         if (!not_usedarea.IsEmpty && clip.IntersectsWith (not_usedarea))
1854                                 g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor),
1855                                                  not_usedarea);
1856                 }
1857
1858                 public override void DataGridPaintRow (Graphics g, int row, Rectangle row_rect, bool is_newrow,
1859                                                        Rectangle clip, DataGrid grid)
1860                 {
1861                         /* paint the header if it's visible and intersects the clip */
1862                         if (grid.CurrentTableStyle.CurrentRowHeadersVisible) {
1863                                 Rectangle rect_header = row_rect;
1864                                 rect_header.Width = grid.RowHeaderWidth;
1865                                 row_rect.X += grid.RowHeaderWidth;
1866                                 if (clip.IntersectsWith (rect_header)) {
1867                                         DataGridPaintRowHeader (g, rect_header, row, grid);
1868                                 }
1869                         }
1870
1871                         DataGridPaintRowContents (g, row, row_rect, is_newrow, clip, grid);
1872                 }
1873
1874                 #endregion // Datagrid
1875
1876                 #region DateTimePicker
1877
1878                 public override void DrawDateTimePicker(Graphics dc, Rectangle clip_rectangle, DateTimePicker dtp)
1879                 {
1880
1881                         if (!clip_rectangle.IntersectsWith (dtp.ClientRectangle))
1882                                 return;
1883
1884                         // draw the outer border
1885                         Rectangle button_bounds = dtp.ClientRectangle;
1886                         this.CPDrawBorder3D (dc, button_bounds, Border3DStyle.Sunken, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, dtp.BackColor);
1887
1888                         // deflate by the border width
1889                         if (clip_rectangle.IntersectsWith (dtp.drop_down_arrow_rect)) {
1890                                 button_bounds.Inflate (-2,-2);
1891                                 if (!dtp.ShowUpDown) {
1892                                         ButtonState state = dtp.is_drop_down_visible ? ButtonState.Pushed : ButtonState.Normal;
1893                                         dc.FillRectangle (ResPool.GetSolidBrush (ColorControl), dtp.drop_down_arrow_rect);
1894                                         this.CPDrawComboButton (
1895                                           dc,
1896                                           dtp.drop_down_arrow_rect,
1897                                           state);
1898                                 } else {
1899                                         ButtonState up_state = dtp.is_up_pressed ? ButtonState.Pushed : ButtonState.Normal;
1900                                         ButtonState down_state = dtp.is_down_pressed ? ButtonState.Pushed : ButtonState.Normal;
1901                                         Rectangle up_bounds = dtp.drop_down_arrow_rect;
1902                                         Rectangle down_bounds = dtp.drop_down_arrow_rect;
1903
1904                                         up_bounds.Height = up_bounds.Height / 2;
1905                                         down_bounds.Y = up_bounds.Height;
1906                                         down_bounds.Height = dtp.Height - up_bounds.Height;
1907                                         if (down_bounds.Height > up_bounds.Height)
1908                                         {
1909                                                 down_bounds.Y += 1;
1910                                                 down_bounds.Height -= 1;
1911                                         }
1912
1913                                         up_bounds.Inflate (-1, -1);
1914                                         down_bounds.Inflate (-1, -1);
1915
1916                                         ControlPaint.DrawScrollButton (dc, up_bounds, ScrollButton.Up, up_state);
1917                                         ControlPaint.DrawScrollButton (dc, down_bounds, ScrollButton.Down, down_state);
1918                                 }
1919                         }
1920
1921                         // render the date part
1922                         if (!clip_rectangle.IntersectsWith (dtp.date_area_rect))
1923                                 return;
1924
1925                         // fill the background
1926                         dc.FillRectangle (SystemBrushes.Window, dtp.date_area_rect);
1927
1928                         // Update date_area_rect if we are drawing the checkbox
1929                         Rectangle date_area_rect = dtp.date_area_rect;
1930                         if (dtp.ShowCheckBox) {
1931                                 Rectangle check_box_rect = dtp.CheckBoxRect;
1932                                 date_area_rect.X = date_area_rect.X + check_box_rect.Width + DateTimePicker.check_box_space * 2;
1933                                 date_area_rect.Width = date_area_rect.Width - check_box_rect.Width - DateTimePicker.check_box_space * 2;
1934
1935                                 ButtonState bs = dtp.Checked ? ButtonState.Checked : ButtonState.Normal;
1936                                 CPDrawCheckBox(dc, check_box_rect, bs);
1937
1938                                 if (dtp.is_checkbox_selected)
1939                                         CPDrawFocusRectangle (dc, check_box_rect, dtp.foreground_color, dtp.background_color);
1940                         }
1941
1942                         // render each text part
1943                         using (StringFormat text_format = StringFormat.GenericTypographic)
1944                         {
1945                                 text_format.LineAlignment = StringAlignment.Near;
1946                                 text_format.Alignment = StringAlignment.Near;
1947                                 text_format.FormatFlags = text_format.FormatFlags | StringFormatFlags.MeasureTrailingSpaces | StringFormatFlags.NoWrap | StringFormatFlags.FitBlackBox;
1948                                 text_format.FormatFlags &= ~StringFormatFlags.NoClip;
1949
1950                                 // Calculate the rectangles for each part
1951                                 if (dtp.part_data.Length > 0 && dtp.part_data[0].drawing_rectangle.IsEmpty)
1952                                 {
1953                                         Graphics gr = dc;
1954                                         for (int i = 0; i < dtp.part_data.Length; i++)
1955                                         {
1956                                                 DateTimePicker.PartData fd = dtp.part_data[i];
1957                                                 RectangleF text_rect = new RectangleF();
1958                                                 string text = fd.GetText(dtp.Value);
1959                                                 text_rect.Size = gr.MeasureString (text, dtp.Font, 250, text_format);
1960                                                 if (!fd.is_literal)
1961                                                         text_rect.Width = Math.Max (dtp.CalculateMaxWidth(fd.value, gr, text_format), text_rect.Width);
1962
1963                                                 if (i > 0) {
1964                                                         text_rect.X = dtp.part_data[i - 1].drawing_rectangle.Right;
1965                                                 } else {
1966                                                         text_rect.X = date_area_rect.X;
1967                                                 }
1968                                                 text_rect.Y = 2;
1969                                                 text_rect.Inflate (1, 0);
1970                                                 fd.drawing_rectangle = text_rect;
1971                                         }
1972                                 }
1973
1974                                 // draw the text part
1975                                 Brush text_brush = ResPool.GetSolidBrush (dtp.ShowCheckBox && dtp.Checked == false ?
1976                                                 SystemColors.GrayText : dtp.ForeColor); // Use GrayText if Checked is false
1977                                 RectangleF clip_rectangleF = clip_rectangle;
1978
1979                                 for (int i = 0; i < dtp.part_data.Length; i++)
1980                                 {
1981                                         DateTimePicker.PartData fd = dtp.part_data [i];
1982                                         string text;
1983
1984                                         if (!clip_rectangleF.IntersectsWith (fd.drawing_rectangle))
1985                                                 continue;
1986
1987                                         text = fd.GetText (dtp.Value);
1988
1989                                         PointF text_position = new PointF ();
1990                                         SizeF text_size;
1991                                         RectangleF text_rect;
1992
1993                                         text_size = dc.MeasureString (text, dtp.Font, 250, text_format);
1994                                         text_position.X = (fd.drawing_rectangle.Left + fd.drawing_rectangle.Width / 2) - text_size.Width / 2;
1995                                         text_position.Y = (fd.drawing_rectangle.Top + fd.drawing_rectangle.Height / 2) - text_size.Height / 2;
1996                                         text_rect = new RectangleF (text_position, text_size);
1997                                         text_rect = RectangleF.Intersect (text_rect, date_area_rect);
1998
1999                                         if (text_rect.IsEmpty)
2000                                                 break;
2001
2002                                         if (text_rect.Right >= date_area_rect.Right)
2003                                                 text_format.FormatFlags &= ~StringFormatFlags.NoClip;
2004                                         else
2005                                                 text_format.FormatFlags |= StringFormatFlags.NoClip;
2006
2007                                         if (fd.is_selected) {
2008                                                 dc.FillRectangle (SystemBrushes.Highlight, text_rect);
2009                                                 dc.DrawString (text, dtp.Font, SystemBrushes.HighlightText, text_rect, text_format);
2010
2011                                         } else {
2012                                                 dc.DrawString (text, dtp.Font, text_brush, text_rect, text_format);
2013                                         }
2014
2015                                         if (fd.drawing_rectangle.Right > date_area_rect.Right)
2016                                                 break; // the next part would be not be visible, so don't draw anything more.
2017                                 }
2018                         }
2019                 }
2020
2021                 #endregion // DateTimePicker
2022
2023                 #region GroupBox
2024                 public override void DrawGroupBox (Graphics dc,  Rectangle area, GroupBox box) {
2025                         StringFormat    text_format;
2026                         SizeF           size;
2027                         int             width;
2028                         int             y;
2029
2030                         dc.FillRectangle (GetControlBackBrush (box.BackColor), box.ClientRectangle);
2031
2032                         text_format = new StringFormat();
2033                         text_format.HotkeyPrefix = HotkeyPrefix.Show;
2034
2035                         size = dc.MeasureString (box.Text, box.Font);
2036                         width = 0;
2037
2038                         if (size.Width > 0) {
2039                                 width = ((int) size.Width) + 7;
2040
2041                                 if (width > box.Width - 16)
2042                                         width = box.Width - 16;
2043                         }
2044
2045                         y = box.Font.Height / 2;
2046
2047                         // Clip the are that the text will be in
2048                         Region prev_clip = dc.Clip;
2049                         dc.SetClip (new Rectangle (10, 0, width, box.Font.Height), CombineMode.Exclude);
2050                         /* Draw group box*/
2051                         CPDrawBorder3D (dc, new Rectangle (0, y, box.Width, box.Height - y), Border3DStyle.Etched, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, box.BackColor);
2052                         dc.Clip = prev_clip;
2053
2054                         /* Text */
2055                         if (box.Text.Length != 0) {
2056                                 if (box.Enabled) {
2057                                         dc.DrawString (box.Text, box.Font, ResPool.GetSolidBrush (box.ForeColor), 10, 0, text_format);
2058                                 } else {
2059                                         CPDrawStringDisabled (dc, box.Text, box.Font, box.BackColor,
2060                                                               new RectangleF (10, 0, width,  box.Font.Height), text_format);
2061                                 }
2062                         }
2063
2064                         text_format.Dispose ();
2065                 }
2066
2067                 public override Size GroupBoxDefaultSize {
2068                         get {
2069                                 return new Size (200,100);
2070                         }
2071                 }
2072                 #endregion
2073
2074                 #region HScrollBar
2075                 public override Size HScrollBarDefaultSize {
2076                         get {
2077                                 return new Size (80, this.ScrollBarButtonSize);
2078                         }
2079                 }
2080
2081                 #endregion      // HScrollBar
2082
2083                 #region Label
2084                 public  override void DrawLabel (Graphics dc, Rectangle clip_rectangle, Label label)
2085                 {
2086                         dc.FillRectangle (GetControlBackBrush (label.BackColor), clip_rectangle);
2087
2088                         if (label.Enabled) {
2089                                 dc.DrawString (label.Text, label.Font, ResPool.GetSolidBrush (label.ForeColor), clip_rectangle, label.string_format);
2090                         } else {
2091                                 ControlPaint.DrawStringDisabled (dc, label.Text, label.Font, label.BackColor, clip_rectangle, label.string_format);
2092                         }
2093
2094                 }
2095
2096                 public override Size LabelDefaultSize {
2097                         get {
2098                                 return new Size (100, 23);
2099                         }
2100                 }
2101                 #endregion      // Label
2102
2103                 #region LinkLabel
2104
2105                 private Color LinkLabelGetPieceColor (LinkLabel label, LinkLabel.Piece piece, int i)
2106                 {
2107                         if (!label.Enabled)
2108                                 return label.DisabledLinkColor;
2109
2110                         if (piece.link == null)
2111                                 return label.ForeColor;
2112
2113                         if (!piece.link.Enabled)
2114                                 return label.DisabledLinkColor;
2115
2116                         if (piece.link.Active)
2117                                 return label.ActiveLinkColor;
2118
2119                         if ((label.LinkVisited && i == 0) || piece.link.Visited)
2120                                 return label.VisitedLinkColor;
2121
2122                         return label.LinkColor;
2123                 }
2124
2125                 public override void DrawLinkLabel (Graphics dc, Rectangle clip_rectangle, LinkLabel label)
2126                 {
2127                         dc.FillRectangle (GetControlBackBrush (label.BackColor), clip_rectangle);
2128
2129                         if (label.pieces == null)
2130                                 return;
2131
2132                         // Paint all text as disabled.
2133                         if (!label.Enabled) {
2134                                 dc.SetClip (clip_rectangle);
2135                                 CPDrawStringDisabled (dc, label.Text, label.Font, label.BackColor, label.ClientRectangle, label.string_format);
2136                                 return;
2137                         }
2138
2139                         Font font, link_font = GetLinkFont (label);
2140
2141                         Region text_region = new Region (new Rectangle());
2142
2143                         // Draw links.
2144                         for (int i = 0; i < label.pieces.Length; i ++) {
2145                                 LinkLabel.Piece piece = label.pieces[i];
2146
2147                                 if (piece.link == null) {
2148                                         text_region.Union (piece.region);
2149                                         continue;
2150                                 }
2151
2152                                 Color color = LinkLabelGetPieceColor (label, piece, i);
2153
2154                                 if ( (label.LinkBehavior == LinkBehavior.AlwaysUnderline) ||
2155                                          (label.LinkBehavior == LinkBehavior.SystemDefault) ||
2156                                          ((label.LinkBehavior == LinkBehavior.HoverUnderline) && piece.link.Hovered) )
2157                                         font = link_font;
2158                                 else
2159                                         font = label.Font;
2160
2161                                 dc.Clip = piece.region;
2162                                 dc.Clip.Intersect (clip_rectangle);
2163                                 dc.DrawString (label.Text, font, ResPool.GetSolidBrush (color), label.ClientRectangle, label.string_format);
2164
2165                                 // Draw focus rectangle
2166                                 if ((piece.link != null) && piece.link.Focused) {
2167                                         foreach (RectangleF rect in piece.region.GetRegionScans (dc.Transform))
2168                                                 ControlPaint.DrawFocusRectangle (dc, Rectangle.Round (rect), label.ForeColor, label.BackColor);
2169                                 }
2170                         }
2171
2172                         // Draw normal text (without links).
2173                         if (!text_region.IsEmpty (dc)) {
2174                                 dc.Clip = text_region;
2175                                 dc.Clip.Intersect (clip_rectangle);
2176                                 if (!dc.Clip.IsEmpty (dc))
2177                                         dc.DrawString(label.Text, label.Font, ResPool.GetSolidBrush(label.ForeColor), label.ClientRectangle, label.string_format);
2178                         }
2179                 }
2180
2181                 #endregion      // LinkLabel
2182
2183                 #region ListBox
2184
2185                 public override void DrawListBoxItem (ListBox ctrl, DrawItemEventArgs e)
2186                 {
2187                         Color back_color, fore_color;
2188
2189                         if ((e.State & DrawItemState.Selected) == DrawItemState.Selected) {
2190                                 back_color = ColorHighlight;
2191                                 fore_color = ColorHighlightText;
2192                         } else {
2193                                 back_color = e.BackColor;
2194                                 fore_color = e.ForeColor;
2195                         }
2196
2197                         e.Graphics.FillRectangle (ResPool.GetSolidBrush (back_color), e.Bounds);
2198
2199                         e.Graphics.DrawString (ctrl.GetItemText (ctrl.Items[e.Index]), e.Font,
2200                                                ResPool.GetSolidBrush (fore_color),
2201                                                e.Bounds.X, e.Bounds.Y, ctrl.StringFormat);
2202
2203                         if ((e.State & DrawItemState.Focus) == DrawItemState.Focus)
2204                                 CPDrawFocusRectangle (e.Graphics, e.Bounds, fore_color, back_color);
2205                 }
2206
2207                 #endregion ListBox
2208
2209                 #region ListView
2210                 // Drawing
2211                 public override void DrawListViewItems (Graphics dc, Rectangle clip, ListView control)
2212                 {
2213                         bool details = control.View == View.Details;
2214
2215                         if (control.Enabled)
2216                                 dc.FillRectangle (GetControlBackBrush (control.BackColor), clip);
2217                         else
2218                                 dc.FillRectangle (ResPool.GetSolidBrush (ColorControl), clip);
2219
2220                         int first = control.FirstVisibleIndex;
2221
2222                         for (int i = first; i <= control.LastVisibleIndex; i ++) {
2223                                 if (clip.IntersectsWith (control.Items[i].GetBounds (ItemBoundsPortion.Entire)))
2224                                         DrawListViewItem (dc, control, control.Items [i]);
2225                         }
2226
2227                         // draw the gridlines
2228                         if (details && control.GridLines) {
2229                                 int top = (control.HeaderStyle == ColumnHeaderStyle.None) ?
2230                                         2 : control.Font.Height + 2;
2231
2232                                 // draw vertical gridlines
2233                                 foreach (ColumnHeader col in control.Columns)
2234                                         dc.DrawLine (SystemPens.Control,
2235                                                      col.Rect.Right, top,
2236                                                      col.Rect.Right, control.TotalHeight);
2237                                 // draw horizontal gridlines
2238                                 ListViewItem last_item = null;
2239                                 foreach (ListViewItem item in control.Items) {
2240                                         dc.DrawLine (SystemPens.Control,
2241                                                      item.GetBounds (ItemBoundsPortion.Entire).Left, item.GetBounds (ItemBoundsPortion.Entire).Top,
2242                                                      control.TotalWidth, item.GetBounds (ItemBoundsPortion.Entire).Top);
2243                                         last_item = item;
2244                                 }
2245
2246                                 // draw a line after at the bottom of the last item
2247                                 if (last_item != null) {
2248                                         dc.DrawLine (SystemPens.Control,
2249                                                      last_item.GetBounds (ItemBoundsPortion.Entire).Left,
2250                                                      last_item.GetBounds (ItemBoundsPortion.Entire).Bottom,
2251                                                      control.TotalWidth,
2252                                                      last_item.GetBounds (ItemBoundsPortion.Entire).Bottom);
2253                                 }
2254                         }
2255
2256                         // Draw corner between the two scrollbars
2257                         if (control.h_scroll.Visible == true && control.v_scroll.Visible == true) {
2258                                 Rectangle rect = new Rectangle ();
2259                                 rect.X = control.h_scroll.Location.X + control.h_scroll.Width;
2260                                 rect.Width = control.v_scroll.Width;
2261                                 rect.Y = control.v_scroll.Location.Y + control.v_scroll.Height;
2262                                 rect.Height = control.h_scroll.Height;
2263                                 dc.FillRectangle (SystemBrushes.Control, rect);
2264                         }
2265
2266                         Rectangle box_select_rect = control.item_control.BoxSelectRectangle;
2267                         if (!box_select_rect.Size.IsEmpty)
2268                                 dc.DrawRectangle (ResPool.GetDashPen (ColorControlText, DashStyle.Dot), box_select_rect);
2269
2270                 }
2271
2272                 public override void DrawListViewHeader (Graphics dc, Rectangle clip, ListView control)
2273                 {
2274                         bool details = (control.View == View.Details);
2275
2276                         // border is drawn directly in the Paint method
2277                         if (details && control.HeaderStyle != ColumnHeaderStyle.None) {
2278                                 dc.FillRectangle (GetControlBackBrush (control.BackColor),
2279                                                   0, 0, control.TotalWidth, control.Font.Height + 5);
2280                                 if (control.Columns.Count > 0) {
2281                                         foreach (ColumnHeader col in control.Columns) {
2282                                                 Rectangle rect = col.Rect;
2283                                                 rect.X -= control.h_marker;
2284                                                 ButtonState state;
2285                                                 if (control.HeaderStyle == ColumnHeaderStyle.Clickable)
2286                                                         state = col.Pressed ? ButtonState.Pushed : ButtonState.Normal;
2287                                                 else
2288                                                         state = ButtonState.Flat;
2289                                                 this.CPDrawButton (dc, rect, state);
2290                                                 rect.X += 8;
2291                                                 rect.Width -= 13;
2292                                                 if (rect.Width <= 0)
2293                                                         continue;
2294
2295                                                 dc.DrawString (col.Text, DefaultFont,
2296                                                                SystemBrushes.ControlText,
2297                                                                rect, col.Format);
2298                                         }
2299                                         int right = control.GetReorderedColumn (control.Columns.Count - 1).Rect.Right - control.h_marker;
2300                                         if (right < control.Right) {
2301                                                 Rectangle rect = control.Columns [0].Rect;
2302                                                 rect.X = right;
2303                                                 rect.Width = control.Right - right;
2304                                                 ButtonState state;
2305                                                 if (control.HeaderStyle == ColumnHeaderStyle.Clickable)
2306                                                         state = ButtonState.Normal;
2307                                                 else
2308                                                         state = ButtonState.Flat;
2309                                                 CPDrawButton (dc, rect, state);
2310                                         }
2311                                 }
2312                         }
2313                 }
2314
2315                 public override void DrawListViewHeaderDragDetails (Graphics dc, ListView view, ColumnHeader col, int target_x)
2316                 {
2317                         Rectangle rect = col.Rect;
2318                         rect.X -= view.h_marker;
2319                         Color color = Color.FromArgb (0x7f, ColorControlDark.R, ColorControlDark.G, ColorControlDark.B);
2320                         dc.FillRectangle (ResPool.GetSolidBrush (color), rect);
2321                         rect.X += 3;
2322                         rect.Width -= 8;
2323                         if (rect.Width <= 0)
2324                                 return;
2325                         color = Color.FromArgb (0x7f, ColorControlText.R, ColorControlText.G, ColorControlText.B);
2326                         dc.DrawString (col.Text, DefaultFont, ResPool.GetSolidBrush (color), rect, col.Format);
2327                         dc.DrawLine (ResPool.GetSizedPen (ColorHighlight, 2), target_x, 0, target_x, col.Rect.Height);
2328                 }
2329
2330                 protected virtual void DrawListViewItem (Graphics dc, ListView control, ListViewItem item)
2331                 {
2332                         int col_offset;
2333                         if (control.View == View.Details && control.Columns.Count > 0)
2334                                 col_offset = control.Columns [0].Rect.X;
2335                         else
2336                                 col_offset = 0;
2337
2338                         Rectangle rect_checkrect = item.CheckRectReal;
2339                         rect_checkrect.X += col_offset;
2340                         Rectangle icon_rect = item.GetBounds (ItemBoundsPortion.Icon);
2341                         icon_rect.X += col_offset;
2342                         Rectangle full_rect = item.GetBounds (ItemBoundsPortion.Entire);
2343                         full_rect.X += col_offset;
2344                         Rectangle text_rect = item.GetBounds (ItemBoundsPortion.Label);
2345                         text_rect.X += col_offset;
2346
2347 #if NET_2_0
2348                         // Tile view doesn't support CheckBoxes
2349                         if (control.CheckBoxes && control.View != View.Tile) {
2350 #else
2351                         if (control.CheckBoxes) {
2352 #endif
2353                                 if (control.StateImageList == null) {
2354                                         // Make sure we've got at least a line width of 1
2355                                         int check_wd = Math.Max (3, rect_checkrect.Width / 6);
2356                                         int scale = Math.Max (1, rect_checkrect.Width / 12);
2357
2358                                         // set the checkbox background
2359                                         dc.FillRectangle (SystemBrushes.Window,
2360                                                           rect_checkrect);
2361                                         // define a rectangle inside the border area
2362                                         Rectangle rect = new Rectangle (rect_checkrect.X + 2,
2363                                                                         rect_checkrect.Y + 2,
2364                                                                         rect_checkrect.Width - 4,
2365                                                                         rect_checkrect.Height - 4);
2366                                         Pen pen = ResPool.GetSizedPen (this.ColorWindowText, 2);
2367                                         dc.DrawRectangle (pen, rect);
2368
2369                                         // Need to draw a check-mark
2370                                         if (item.Checked) {
2371                                                 Pen check_pen = ResPool.GetSizedPen (this.ColorWindowText, 1);
2372                                                 // adjustments to get the check-mark at the right place
2373                                                 rect.X ++; rect.Y ++;
2374                                                 // following logic is taken from DrawFrameControl method
2375                                                 for (int i = 0; i < check_wd; i++) {
2376                                                         dc.DrawLine (check_pen, rect.Left + check_wd / 2,
2377                                                                      rect.Top + check_wd + i,
2378                                                                      rect.Left + check_wd / 2 + 2 * scale,
2379                                                                      rect.Top + check_wd + 2 * scale + i);
2380                                                         dc.DrawLine (check_pen,
2381                                                                      rect.Left + check_wd / 2 + 2 * scale,
2382                                                                      rect.Top + check_wd + 2 * scale + i,
2383                                                                      rect.Left + check_wd / 2 + 6 * scale,
2384                                                                      rect.Top + check_wd - 2 * scale + i);
2385                                                 }
2386                                         }
2387                                 }
2388                                 else {
2389                                         if (item.Checked && control.StateImageList.Images.Count > 1)
2390                                                 control.StateImageList.Draw (dc,
2391                                                                              rect_checkrect.Location, 1);
2392                                         else if (! item.Checked && control.StateImageList.Images.Count > 0)
2393                                                 control.StateImageList.Draw (dc,
2394                                                                              rect_checkrect.Location, 0);
2395                                 }
2396                         }
2397
2398                         ImageList image_list = control.View == View.LargeIcon
2399 #if NET_2_0
2400                                 || control.View == View.Tile
2401 #endif
2402                                 ? control.LargeImageList : control.SmallImageList;
2403                         if (image_list != null) {
2404                                 int idx;
2405
2406 #if NET_2_0
2407                                 if (item.ImageKey != String.Empty)
2408                                         idx = image_list.Images.IndexOfKey (item.ImageKey);
2409                                 else
2410 #endif
2411                                         idx = item.ImageIndex;
2412
2413                                 if (idx > -1 && idx < image_list.Images.Count)
2414                                         image_list.Draw (dc, icon_rect.Location, idx);
2415                         }
2416
2417                         // draw the item text
2418                         // format for the item text
2419                         StringFormat format = new StringFormat ();
2420                         if (control.View == View.SmallIcon)
2421                                 format.LineAlignment = StringAlignment.Near;
2422                         else
2423                                 format.LineAlignment = StringAlignment.Center;
2424                         if (control.View == View.LargeIcon)
2425                                 format.Alignment = StringAlignment.Center;
2426                         else
2427                                 format.Alignment = StringAlignment.Near;
2428
2429                         if (control.LabelWrap)
2430                                 format.FormatFlags = StringFormatFlags.LineLimit;
2431                         else
2432                                 format.FormatFlags = StringFormatFlags.NoWrap;
2433
2434                         Rectangle highlight_rect = text_rect;
2435                         if (control.View == View.Details) { // Adjustments for Details view
2436                                 Size text_size = Size.Ceiling (dc.MeasureString (item.Text, item.Font));
2437
2438                                 if (!control.FullRowSelect) // Selection shouldn't be outside the item bounds
2439                                         highlight_rect.Width = Math.Min (text_size.Width + 4, text_rect.Width);
2440
2441                                 if (text_size.Width > text_rect.Width)
2442                                         format.Trimming = StringTrimming.EllipsisCharacter;
2443                         }
2444
2445                         if (item.Selected && control.Focused)
2446                                 dc.FillRectangle (SystemBrushes.Highlight, highlight_rect);
2447                         else if (item.Selected && !control.HideSelection)
2448                                 dc.FillRectangle (SystemBrushes.Control, highlight_rect);
2449                         else
2450                                 dc.FillRectangle (ResPool.GetSolidBrush (item.BackColor), text_rect);
2451
2452                         Brush textBrush =
2453                                 !control.Enabled ? SystemBrushes.ControlLight :
2454                                 (item.Selected && control.Focused) ? SystemBrushes.HighlightText :
2455                                 this.ResPool.GetSolidBrush (item.ForeColor);
2456
2457 #if NET_2_0
2458                         // Tile view renders its Text in a different fashion
2459                         if (control.View == View.Tile) {
2460                                 // Item.Text is drawn using its first subitem's bounds
2461                                 dc.DrawString (item.Text, item.Font, textBrush, item.SubItems [0].Bounds, format);
2462
2463                                 int count = Math.Min (control.Columns.Count, item.SubItems.Count);
2464                                 for (int i = 1; i < count; i++) {
2465                                         ListViewItem.ListViewSubItem sub_item = item.SubItems [i];
2466                                         if (sub_item.Text == null || sub_item.Text.Length == 0)
2467                                                 continue;
2468
2469                                         Brush itemBrush = item.Selected && control.Focused ?
2470                                                 SystemBrushes.HighlightText : GetControlForeBrush (sub_item.ForeColor);
2471                                         dc.DrawString (sub_item.Text, sub_item.Font, itemBrush, sub_item.Bounds, format);
2472                                 }
2473                         } else
2474 #endif
2475
2476                         if (item.Text != null && item.Text.Length > 0) {
2477                                 if (item.Selected && control.Focused)
2478                                         dc.DrawString (item.Text, item.Font, textBrush, highlight_rect, format);
2479                                 else
2480                                         dc.DrawString (item.Text, item.Font, textBrush, text_rect, format);
2481                         }
2482
2483                         if (control.View == View.Details && control.Columns.Count > 0) {
2484                                 // draw subitems for details view
2485                                 ListViewItem.ListViewSubItemCollection subItems = item.SubItems;
2486                                 int count = (control.Columns.Count < subItems.Count ?
2487                                              control.Columns.Count : subItems.Count);
2488
2489                                 if (count > 0) {
2490                                         ColumnHeader col;
2491                                         ListViewItem.ListViewSubItem subItem;
2492                                         Rectangle sub_item_rect = text_rect;
2493
2494                                         // set the format for subitems
2495                                         format.FormatFlags = StringFormatFlags.NoWrap;
2496
2497                                         // 0th subitem is the item already drawn
2498                                         for (int index = 1; index < count; index++) {
2499                                                 subItem = subItems [index];
2500                                                 col = control.Columns [index];
2501                                                 format.Alignment = col.Format.Alignment;
2502                                                 sub_item_rect.X = col.Rect.X - control.h_marker;
2503                                                 sub_item_rect.Width = col.Wd;
2504                                                 Rectangle sub_item_text_rect = sub_item_rect;
2505                                                 sub_item_text_rect.X += 3;
2506                                                 sub_item_text_rect.Width -= 6;
2507
2508                                                 SolidBrush sub_item_back_br = null;
2509                                                 SolidBrush sub_item_fore_br = null;
2510                                                 Font sub_item_font = null;
2511
2512                                                 if (item.UseItemStyleForSubItems) {
2513                                                         sub_item_back_br = ResPool.GetSolidBrush (item.BackColor);
2514                                                         sub_item_fore_br = ResPool.GetSolidBrush (item.ForeColor);
2515                                                         sub_item_font = item.Font;
2516                                                 } else {
2517                                                         sub_item_back_br = ResPool.GetSolidBrush (subItem.BackColor);
2518                                                         sub_item_fore_br = ResPool.GetSolidBrush (subItem.ForeColor);
2519                                                         sub_item_font = subItem.Font;
2520                                                 }
2521
2522                                                 int sub_item_text_width = (int) Math.Ceiling (control.DeviceContext.MeasureString (subItem.Text,
2523                                                                 sub_item_font).Width);
2524
2525                                                 format.Trimming = sub_item_text_width > sub_item_text_rect.Width ? StringTrimming.EllipsisCharacter :
2526                                                         StringTrimming.None;
2527
2528                                                 if (item.Selected && (control.Focused || !control.HideSelection) && control.FullRowSelect) {
2529                                                         Brush bg, text;
2530                                                         if (control.Focused) {
2531                                                                 bg = SystemBrushes.Highlight;
2532                                                                 text = SystemBrushes.HighlightText;
2533                                                         } else {
2534                                                                 bg = SystemBrushes.Control;
2535                                                                 text = sub_item_fore_br;
2536                                                         }
2537
2538                                                         dc.FillRectangle (bg, sub_item_rect);
2539                                                         if (subItem.Text != null && subItem.Text.Length > 0)
2540                                                                 dc.DrawString (subItem.Text, sub_item_font,
2541                                                                                text, sub_item_text_rect, format);
2542                                                 } else {
2543                                                         dc.FillRectangle (sub_item_back_br, sub_item_rect);
2544                                                         if (subItem.Text != null && subItem.Text.Length > 0)
2545                                                                 dc.DrawString (subItem.Text, sub_item_font,
2546                                                                                sub_item_fore_br,
2547                                                                                sub_item_text_rect, format);
2548                                                 }
2549                                         }
2550
2551                                         // Fill in selection for remaining columns if Column.Count > SubItems.Count
2552                                         if (item.Selected && (control.Focused || !control.HideSelection) && control.FullRowSelect) {
2553                                                 for (int index = count; index < control.Columns.Count; index++)
2554                                                 {
2555                                                         col = control.Columns [index];
2556                                                         sub_item_rect.X = col.Rect.X - control.h_marker;
2557                                                         sub_item_rect.Width = col.Wd;
2558                                                         if (control.Focused)
2559                                                                 dc.FillRectangle (SystemBrushes.Highlight, sub_item_rect);
2560                                                         else
2561                                                                 dc.FillRectangle (SystemBrushes.Control, sub_item_rect);
2562                                                 }
2563                                         }
2564                                 }
2565                         }
2566
2567                         if (item.Focused && control.Focused) {
2568                                 Rectangle focus_rect = highlight_rect;
2569                                 if (control.FullRowSelect && control.View == View.Details) {
2570                                         int width = 0;
2571                                         foreach (ColumnHeader col in control.Columns)
2572                                                 width += col.Width;
2573                                         focus_rect = new Rectangle (0, full_rect.Y, width, full_rect.Height);
2574                                 }
2575                                 if (item.Selected)
2576                                         CPDrawFocusRectangle (dc, focus_rect, ColorHighlightText, ColorHighlight);
2577                                 else
2578                                         CPDrawFocusRectangle (dc, focus_rect, control.ForeColor, control.BackColor);
2579                         }
2580
2581                         format.Dispose ();
2582                 }
2583
2584                 // Sizing
2585                 public override Size ListViewCheckBoxSize {
2586                         get { return new Size (16, 16); }
2587                 }
2588
2589                 public override int ListViewColumnHeaderHeight {
2590                         get { return 16; }
2591                 }
2592
2593                 public override int ListViewDefaultColumnWidth {
2594                         get { return 60; }
2595                 }
2596
2597                 public override int ListViewVerticalSpacing {
2598                         get { return 22; }
2599                 }
2600
2601                 public override int ListViewEmptyColumnWidth {
2602                         get { return 10; }
2603                 }
2604
2605                 public override int ListViewHorizontalSpacing {
2606                         get { return 10; }
2607                 }
2608
2609                 public override Size ListViewDefaultSize {
2610                         get { return new Size (121, 97); }
2611                 }
2612
2613                 public override int ListViewGroupHeight {
2614                         get { return 20; }
2615                 }
2616
2617                 public override int ListViewTileWidthFactor {
2618                         get { return 22; }
2619                 }
2620
2621                 public override int ListViewTileHeightFactor {
2622                         get { return 3; }
2623                 }
2624                 #endregion      // ListView
2625
2626                 #region Menus
2627
2628                 public override bool MenuAccessKeysUnderlined {
2629                         get { return false;     }
2630                 }
2631
2632                 public override void CalcItemSize (Graphics dc, MenuItem item, int y, int x, bool menuBar)
2633                 {
2634                         item.X = x;
2635                         item.Y = y;
2636
2637                         if (item.Visible == false) {
2638                                 item.Width = 0;
2639                                 item.Height = 0;
2640                                 return;
2641                         }
2642
2643                         if (item.Separator == true) {
2644                                 item.Height = SEPARATOR_HEIGHT;
2645                                 item.Width = SEPARATOR_MIN_WIDTH;
2646                                 return;
2647                         }
2648
2649                         if (item.MeasureEventDefined) {
2650                                 MeasureItemEventArgs mi = new MeasureItemEventArgs (dc, item.Index);
2651                                 item.PerformMeasureItem (mi);
2652                                 item.Height = mi.ItemHeight;
2653                                 item.Width = mi.ItemWidth;
2654                                 return;
2655                         } else {
2656                                 SizeF size;
2657                                 size =  dc.MeasureString (item.Text, MenuFont);
2658                                 item.Width = (int) size.Width;
2659                                 item.Height = (int) size.Height;
2660
2661                                 if (!menuBar) {
2662                                         if (item.Shortcut != Shortcut.None && item.ShowShortcut) {
2663                                                 item.XTab = MenuCheckSize.Width + MENU_TAB_SPACE + (int) size.Width;
2664                                                 size =  dc.MeasureString (" " + item.GetShortCutText (), MenuFont);
2665                                                 item.Width += MENU_TAB_SPACE + (int) size.Width;
2666                                         }
2667
2668                                         item.Width += 4 + (MenuCheckSize.Width * 2);
2669                                 } else {
2670                                         item.Width += MENU_BAR_ITEMS_SPACE;
2671                                         x += item.Width;
2672                                 }
2673
2674                                 if (item.Height < MenuHeight)
2675                                         item.Height = MenuHeight;
2676                         }
2677                 }
2678
2679                 // Updates the menu rect and returns the height
2680                 public override int CalcMenuBarSize (Graphics dc, Menu menu, int width)
2681                 {
2682                         int x = 0;
2683                         int y = 0;
2684                         menu.Height = 0;
2685
2686                         foreach (MenuItem item in menu.MenuItems) {
2687
2688                                 CalcItemSize (dc, item, y, x, true);
2689
2690                                 if (x + item.Width > width) {
2691                                         item.X = 0;
2692                                         y += item.Height;
2693                                         item.Y = y;
2694                                         x = 0;
2695                                 }
2696
2697                                 x += item.Width;
2698                                 item.MenuBar = true;
2699
2700                                 if (y + item.Height > menu.Height)
2701                                         menu.Height = item.Height + y;
2702                         }
2703
2704                         menu.Width = width;
2705                         return menu.Height;
2706                 }
2707
2708                 public override void CalcPopupMenuSize (Graphics dc, Menu menu)
2709                 {
2710                         int x = 3;
2711                         int start = 0;
2712                         int i, n, y, max;
2713
2714                         menu.Height = 0;
2715
2716                         while (start < menu.MenuItems.Count) {
2717                                 y = 3;
2718                                 max = 0;
2719                                 for (i = start; i < menu.MenuItems.Count; i++) {
2720                                         MenuItem item = menu.MenuItems [i];
2721
2722                                         if ((i != start) && (item.Break || item.BarBreak))
2723                                                 break;
2724
2725                                         CalcItemSize (dc, item, y, x, false);
2726                                         y += item.Height;
2727
2728                                         if (item.Width > max)
2729                                                 max = item.Width;
2730                                 }
2731
2732                                 // Replace the -1 by the menu width (separators)
2733                                 for (n = start; n < i; n++, start++)
2734                                         menu.MenuItems [n].Width = max;
2735
2736                                 if (y > menu.Height)
2737                                         menu.Height = y;
2738
2739                                 x+= max;
2740                         }
2741
2742                         menu.Width = x;
2743
2744                         //space for border
2745                         menu.Width += 2;
2746                         menu.Height += 2;
2747
2748                         menu.Width += SM_CXBORDER;
2749                 menu.Height += SM_CYBORDER;
2750                 }
2751
2752                 // Draws a menu bar in a window
2753                 public override void DrawMenuBar (Graphics dc, Menu menu, Rectangle rect)
2754                 {
2755                         if (menu.Height == 0)
2756                                 CalcMenuBarSize (dc, menu, rect.Width);
2757
2758                         bool keynav = (menu as MainMenu).tracker.hotkey_active;
2759                         HotkeyPrefix hp = MenuAccessKeysUnderlined || keynav ? HotkeyPrefix.Show : HotkeyPrefix.Hide;
2760                         string_format_menu_menubar_text.HotkeyPrefix = hp;
2761                         string_format_menu_text.HotkeyPrefix = hp;
2762
2763                         rect.Height = menu.Height;
2764                         dc.FillRectangle (SystemBrushes.Menu, rect);
2765
2766                         for (int i = 0; i < menu.MenuItems.Count; i++) {
2767                                 MenuItem item = menu.MenuItems [i];
2768                                 Rectangle item_rect = item.bounds;
2769                                 item_rect.X += rect.X;
2770                                 item_rect.Y += rect.Y;
2771                                 item.MenuHeight = menu.Height;
2772                                 item.PerformDrawItem (new DrawItemEventArgs (dc, MenuFont, item_rect, i, item.Status));
2773                         }
2774                 }
2775
2776                 protected Bitmap CreateGlyphBitmap (Size size, MenuGlyph glyph, Color color)
2777                 {
2778                         Color bg_color;
2779                         if (color.R == 0 && color.G == 0 && color.B == 0)
2780                                 bg_color = Color.White;
2781                         else
2782                                 bg_color = Color.Black;
2783
2784                         Bitmap  bmp = new Bitmap (size.Width, size.Height);
2785                         Graphics gr = Graphics.FromImage (bmp);
2786                         Rectangle rect = new Rectangle (Point.Empty, size);
2787                         gr.FillRectangle (ResPool.GetSolidBrush (bg_color), rect);
2788                         CPDrawMenuGlyph (gr, rect, glyph, color);
2789                         bmp.MakeTransparent (bg_color);
2790                         gr.Dispose ();
2791
2792                         return bmp;
2793                 }
2794
2795                 public override void DrawMenuItem (MenuItem item, DrawItemEventArgs e)
2796                 {
2797                         StringFormat string_format;
2798                         Rectangle rect_text = e.Bounds;
2799
2800                         if (item.Visible == false)
2801                                 return;
2802
2803                         if (item.MenuBar)
2804                                 string_format = string_format_menu_menubar_text;
2805                         else
2806                                 string_format = string_format_menu_text;
2807
2808                         if (item.Separator == true) {
2809                                 int liney = e.Bounds.Y + (e.Bounds.Height / 2);
2810
2811                                 e.Graphics.DrawLine (SystemPens.ControlDark,
2812                                         e.Bounds.X, liney, e.Bounds.X + e.Bounds.Width, liney);
2813
2814                                 e.Graphics.DrawLine (SystemPens.ControlLight,
2815                                         e.Bounds.X, liney + 1, e.Bounds.X + e.Bounds.Width, liney + 1);
2816
2817                                 return;
2818                         }
2819
2820                         if (!item.MenuBar)
2821                                 rect_text.X += MenuCheckSize.Width;
2822
2823                         if (item.BarBreak) { /* Draw vertical break bar*/
2824                                 Rectangle rect = e.Bounds;
2825                                 rect.Y++;
2826                                 rect.Width = 3;
2827                                 rect.Height = item.MenuHeight - 6;
2828
2829                                 e.Graphics.DrawLine (SystemPens.ControlDark,
2830                                         rect.X, rect.Y , rect.X, rect.Y + rect.Height);
2831
2832                                 e.Graphics.DrawLine (SystemPens.ControlLight,
2833                                         rect.X + 1, rect.Y , rect.X +1, rect.Y + rect.Height);
2834                         }
2835
2836                         Color color_text;
2837                         Color color_back;
2838                         Brush brush_text = null;
2839                         Brush brush_back = null;
2840
2841                         if ((e.State & DrawItemState.Selected) == DrawItemState.Selected && !item.MenuBar) {
2842                                 color_text = ColorHighlightText;
2843                                 color_back = ColorHighlight;
2844                                 brush_text = SystemBrushes.HighlightText;
2845                                 brush_back = SystemBrushes.Highlight;
2846                         } else {
2847                                 color_text = ColorMenuText;
2848                                 color_back = ColorMenu;
2849                                 brush_text = ResPool.GetSolidBrush (ColorMenuText);
2850                                 brush_back = SystemBrushes.Menu;
2851                         }
2852
2853                         /* Draw background */
2854                         if (!item.MenuBar)
2855                                 e.Graphics.FillRectangle (brush_back, e.Bounds);
2856
2857                         if (item.Enabled) {
2858                                 e.Graphics.DrawString (item.Text, e.Font,
2859                                         brush_text,
2860                                         rect_text, string_format);
2861
2862                                 if (!item.MenuBar && item.Shortcut != Shortcut.None && item.ShowShortcut) {
2863                                         string str = item.GetShortCutText ();
2864                                         Rectangle rect = rect_text;
2865                                         rect.X = item.XTab;
2866                                         rect.Width -= item.XTab;
2867
2868                                         e.Graphics.DrawString (str, e.Font, brush_text,
2869                                                 rect, string_format_menu_shortcut);
2870                                 }
2871
2872                                 if (item.MenuBar) {
2873                                         Border3DStyle border_style = Border3DStyle.Adjust;
2874                                         if ((item.Status & DrawItemState.HotLight) != 0)
2875                                                 border_style = Border3DStyle.RaisedInner;
2876                                         else if ((item.Status & DrawItemState.Selected) != 0)
2877                                                 border_style = Border3DStyle.SunkenOuter;
2878
2879                                         if (border_style != Border3DStyle.Adjust)
2880                                                 CPDrawBorder3D(e.Graphics, e.Bounds, border_style,  Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, ColorMenu);
2881                                 }
2882                         } else {
2883                                 if ((item.Status & DrawItemState.Selected) != DrawItemState.Selected) {
2884                                         e.Graphics.DrawString (item.Text, e.Font, Brushes.White,
2885                                                                new RectangleF(rect_text.X + 1, rect_text.Y + 1, rect_text.Width, rect_text.Height),
2886                                                                string_format);
2887                                 }
2888
2889                                 e.Graphics.DrawString (item.Text, e.Font, ResPool.GetSolidBrush(ColorGrayText), rect_text, string_format);
2890                         }
2891
2892                         /* Draw arrow */
2893                         if (item.MenuBar == false && (item.IsPopup || item.MdiList)) {
2894
2895                                 int cx = MenuCheckSize.Width;
2896                                 int cy = MenuCheckSize.Height;
2897                                 Bitmap  bmp = CreateGlyphBitmap (new Size (cx, cy), MenuGlyph.Arrow, color_text);
2898
2899                                 if (item.Enabled) {
2900                                         e.Graphics.DrawImage (bmp, e.Bounds.X + e.Bounds.Width - cx,
2901                                                 e.Bounds.Y + ((e.Bounds.Height - cy) /2));
2902                                 } else {
2903                                         ControlPaint.DrawImageDisabled (e.Graphics, bmp, e.Bounds.X + e.Bounds.Width - cx,
2904                                                 e.Bounds.Y + ((e.Bounds.Height - cy) /2),  color_back);
2905                                 }
2906
2907                                 bmp.Dispose ();
2908                         }
2909
2910                         /* Draw checked or radio */
2911                         if (item.MenuBar == false && item.Checked) {
2912
2913                                 Rectangle area = e.Bounds;
2914                                 int cx = MenuCheckSize.Width;
2915                                 int cy = MenuCheckSize.Height;
2916                                 Bitmap  bmp = CreateGlyphBitmap (new Size (cx, cy), item.RadioCheck ? MenuGlyph.Bullet : MenuGlyph.Checkmark, color_text);
2917
2918                                 e.Graphics.DrawImage (bmp, area.X, e.Bounds.Y + ((e.Bounds.Height - cy) / 2));
2919
2920                                 bmp.Dispose ();
2921                         }
2922                 }
2923
2924                 public override void DrawPopupMenu (Graphics dc, Menu menu, Rectangle cliparea, Rectangle rect)
2925                 {
2926                         // Fill rectangle area
2927                         dc.FillRectangle (SystemBrushes.Menu, cliparea);
2928
2929                         // Draw menu borders
2930                         CPDrawBorder3D (dc, rect, Border3DStyle.Raised, all_sides);
2931
2932                         // Draw menu items
2933                         for (int i = 0; i < menu.MenuItems.Count; i++) {
2934                                 if (cliparea.IntersectsWith (menu.MenuItems [i].bounds)) {
2935                                         MenuItem item = menu.MenuItems [i];
2936                                         item.MenuHeight = menu.Height;
2937                                         item.PerformDrawItem (new DrawItemEventArgs (dc, MenuFont, item.bounds, i, item.Status));
2938                                 }
2939                         }
2940                 }
2941
2942                 #endregion // Menus
2943
2944                 #region MonthCalendar
2945
2946                 // draw the month calendar
2947                 public override void DrawMonthCalendar(Graphics dc, Rectangle clip_rectangle, MonthCalendar mc)
2948                 {
2949                         Rectangle client_rectangle = mc.ClientRectangle;
2950                         Size month_size = mc.SingleMonthSize;
2951                         // cache local copies of Marshal-by-ref internal members (gets around error CS0197)
2952                         Size calendar_spacing = (Size)((object)mc.calendar_spacing);
2953                         Size date_cell_size = (Size)((object)mc.date_cell_size);
2954
2955                         // draw the singlecalendars
2956                         int x_offset = 1;
2957                         int y_offset = 1;
2958                         // adjust for the position of the specific month
2959                         for (int i=0; i < mc.CalendarDimensions.Height; i++)
2960                         {
2961                                 if (i > 0)
2962                                 {
2963                                         y_offset += month_size.Height + calendar_spacing.Height;
2964                                 }
2965                                 // now adjust for x position
2966                                 for (int j=0; j < mc.CalendarDimensions.Width; j++)
2967                                 {
2968                                         if (j > 0)
2969                                         {
2970                                                 x_offset += month_size.Width + calendar_spacing.Width;
2971                                         }
2972                                         else
2973                                         {
2974                                                 x_offset = 1;
2975                                         }
2976
2977                                         Rectangle month_rect = new Rectangle (x_offset, y_offset, month_size.Width, month_size.Height);
2978                                         if (month_rect.IntersectsWith (clip_rectangle)) {
2979                                                 DrawSingleMonth (
2980                                                         dc,
2981                                                         clip_rectangle,
2982                                                         month_rect,
2983                                                         mc,
2984                                                         i,
2985                                                         j);
2986                                         }
2987                                 }
2988                         }
2989
2990                         Rectangle bottom_rect = new Rectangle (
2991                                                 client_rectangle.X,
2992                                                 Math.Max(client_rectangle.Bottom - date_cell_size.Height - 3, 0),
2993                                                 client_rectangle.Width,
2994                                                 date_cell_size.Height + 2);
2995                         // draw the today date if it's set
2996                         if (mc.ShowToday && bottom_rect.IntersectsWith (clip_rectangle))
2997                         {
2998                                 dc.FillRectangle (GetControlBackBrush (mc.BackColor), bottom_rect);
2999                                 if (mc.ShowToday) {
3000                                         int today_offset = 5;
3001                                         if (mc.ShowTodayCircle)
3002                                         {
3003                                                 Rectangle today_circle_rect = new Rectangle (
3004                                                         client_rectangle.X + 5,
3005                                                         Math.Max(client_rectangle.Bottom - date_cell_size.Height - 2, 0),
3006                                                         date_cell_size.Width,
3007                                                         date_cell_size.Height);
3008                                                         DrawTodayCircle (dc, today_circle_rect);
3009                                                 today_offset += date_cell_size.Width + 5;
3010                                         }
3011                                         // draw today's date
3012                                         StringFormat text_format = new StringFormat();
3013                                         text_format.LineAlignment = StringAlignment.Center;
3014                                         text_format.Alignment = StringAlignment.Near;
3015                                         Rectangle today_rect = new Rectangle (
3016                                                         today_offset + client_rectangle.X,
3017                                                         Math.Max(client_rectangle.Bottom - date_cell_size.Height, 0),
3018                                                         Math.Max(client_rectangle.Width - today_offset, 0),
3019                                                         date_cell_size.Height);
3020                                         dc.DrawString ("Today: " + DateTime.Now.ToShortDateString(), mc.bold_font, GetControlForeBrush (mc.ForeColor), today_rect, text_format);
3021                                         text_format.Dispose ();
3022                                 }
3023                         }
3024
3025                         // finally paint the borders of the calendars as required
3026                         for (int i = 0; i <= mc.CalendarDimensions.Width; i++) {
3027                                 if (i == 0 && clip_rectangle.X == client_rectangle.X) {
3028                                         dc.FillRectangle (GetControlBackBrush (mc.BackColor), client_rectangle.X, client_rectangle.Y, 1, client_rectangle.Height);
3029                                 } else if (i == mc.CalendarDimensions.Width && clip_rectangle.Right == client_rectangle.Right) {
3030                                         dc.FillRectangle (GetControlBackBrush (mc.BackColor), client_rectangle.Right-1, client_rectangle.Y, 1, client_rectangle.Height);
3031                                 } else {
3032                                         Rectangle rect = new Rectangle (
3033                                                 client_rectangle.X + (month_size.Width*i) + (calendar_spacing.Width * (i-1)) + 1,
3034                                                 client_rectangle.Y,
3035                                                 calendar_spacing.Width,
3036                                                 client_rectangle.Height);
3037                                         if (i < mc.CalendarDimensions.Width && i > 0 && clip_rectangle.IntersectsWith (rect)) {
3038                                                 dc.FillRectangle (GetControlBackBrush (mc.BackColor), rect);
3039                                         }
3040                                 }
3041                         }
3042                         for (int i = 0; i <= mc.CalendarDimensions.Height; i++) {
3043                                 if (i == 0 && clip_rectangle.Y == client_rectangle.Y) {
3044                                         dc.FillRectangle (GetControlBackBrush (mc.BackColor), client_rectangle.X, client_rectangle.Y, client_rectangle.Width, 1);
3045                                 } else if (i == mc.CalendarDimensions.Height && clip_rectangle.Bottom == client_rectangle.Bottom) {
3046                                         dc.FillRectangle (GetControlBackBrush (mc.BackColor), client_rectangle.X, client_rectangle.Bottom-1, client_rectangle.Width, 1);
3047                                 } else {
3048                                         Rectangle rect = new Rectangle (
3049                                                 client_rectangle.X,
3050                                                 client_rectangle.Y + (month_size.Height*i) + (calendar_spacing.Height*(i-1)) + 1,
3051                                                 client_rectangle.Width,
3052                                                 calendar_spacing.Height);
3053                                         if (i < mc.CalendarDimensions.Height && i > 0 && clip_rectangle.IntersectsWith (rect)) {
3054                                                 dc.FillRectangle (GetControlBackBrush (mc.BackColor), rect);
3055                                         }
3056                                 }
3057                         }
3058
3059                         // draw the drop down border if need
3060                         if (mc.owner != null) {
3061                                 Rectangle bounds = mc.ClientRectangle;
3062                                 if (clip_rectangle.Contains (mc.Location)) {
3063                                         // find out if top or left line to draw
3064                                         if(clip_rectangle.Contains (new Point (bounds.Left, bounds.Bottom))) {
3065
3066                                                 dc.DrawLine (SystemPens.ControlText, bounds.X, bounds.Y, bounds.X, bounds.Bottom-1);
3067                                         }
3068                                         if(clip_rectangle.Contains (new Point (bounds.Right, bounds.Y))) {
3069                                                 dc.DrawLine (SystemPens.ControlText, bounds.X, bounds.Y, bounds.Right-1, bounds.Y);
3070                                         }
3071                                 }
3072                                 if (clip_rectangle.Contains (new Point(bounds.Right, bounds.Bottom))) {
3073                                         // find out if bottom or right line to draw
3074                                         if(clip_rectangle.Contains (new Point (bounds.Left, bounds.Bottom))) {
3075                                                 dc.DrawLine (SystemPens.ControlText, bounds.X, bounds.Bottom-1, bounds.Right-1, bounds.Bottom-1);
3076                                         }
3077                                         if(clip_rectangle.Contains (new Point (bounds.Right, bounds.Y))) {
3078                                                 dc.DrawLine (SystemPens.ControlText, bounds.Right-1, bounds.Y, bounds.Right-1, bounds.Bottom-1);
3079                                         }
3080                                 }
3081                         }
3082                 }
3083
3084                 // darws a single part of the month calendar (with one month)
3085                 private void DrawSingleMonth(Graphics dc, Rectangle clip_rectangle, Rectangle rectangle, MonthCalendar mc, int row, int col)
3086                 {
3087                         // cache local copies of Marshal-by-ref internal members (gets around error CS0197)
3088                         Size title_size = (Size)((object)mc.title_size);
3089                         Size date_cell_size = (Size)((object)mc.date_cell_size);
3090                         DateTime current_month = (DateTime)((object)mc.current_month);
3091                         DateTime sunday = new DateTime(2006, 10, 1);
3092
3093                         // draw the title back ground
3094                         DateTime this_month = current_month.AddMonths (row*mc.CalendarDimensions.Width+col);
3095                         Rectangle title_rect = new Rectangle(rectangle.X, rectangle.Y, title_size.Width, title_size.Height);
3096                         if (title_rect.IntersectsWith (clip_rectangle)) {
3097                                 dc.FillRectangle (ResPool.GetSolidBrush (mc.TitleBackColor), title_rect);
3098                                 // draw the title
3099                                 string title_text = this_month.ToString ("MMMM yyyy");
3100                                 dc.DrawString (title_text, mc.bold_font, ResPool.GetSolidBrush (mc.TitleForeColor), title_rect, mc.centered_format);
3101
3102                                 if (mc.ShowYearUpDown) {
3103                                         Rectangle year_rect;
3104                                         Rectangle upRect, downRect;
3105                                         ButtonState upState, downState;
3106
3107                                         mc.GetYearNameRectangles (title_rect, row * mc.CalendarDimensions.Width + col, out year_rect, out upRect, out downRect);
3108                                         dc.FillRectangle (ResPool.GetSolidBrush (SystemColors.Control), year_rect);
3109                                         dc.DrawString (this_month.ToString ("yyyy"), mc.bold_font, ResPool.GetSolidBrush (Color.Black), year_rect, mc.centered_format);
3110
3111                                         upState = mc.IsYearGoingUp ? ButtonState.Pushed : ButtonState.Normal;
3112                                         downState = mc.IsYearGoingDown ? ButtonState.Pushed : ButtonState.Normal;
3113
3114                                         ControlPaint.DrawScrollButton (dc, upRect, ScrollButton.Up, upState);
3115                                         ControlPaint.DrawScrollButton (dc, downRect, ScrollButton.Down, downState);
3116                                 }
3117
3118                                 // draw previous and next buttons if it's time
3119                                 if (row == 0 && col == 0)
3120                                 {
3121                                         // draw previous button
3122                                         DrawMonthCalendarButton (
3123                                                 dc,
3124                                                 rectangle,
3125                                                 mc,
3126                                                 title_size,
3127                                                 mc.button_x_offset,
3128                                                 (System.Drawing.Size)((object)mc.button_size),
3129                                                 true);
3130                                 }
3131                                 if (row == 0 && col == mc.CalendarDimensions.Width-1)
3132                                 {
3133                                         // draw next button
3134                                         DrawMonthCalendarButton (
3135                                                 dc,
3136                                                 rectangle,
3137                                                 mc,
3138                                                 title_size,
3139                                                 mc.button_x_offset,
3140                                                 (System.Drawing.Size)((object)mc.button_size),
3141                                                 false);
3142                                 }
3143                         }
3144
3145                         // set the week offset and draw week nums if needed
3146                         int col_offset = (mc.ShowWeekNumbers) ? 1 : 0;
3147                         Rectangle day_name_rect = new Rectangle(
3148                                 rectangle.X,
3149                                 rectangle.Y + title_size.Height,
3150                                 (7 + col_offset) * date_cell_size.Width,
3151                                 date_cell_size.Height);
3152                         if (day_name_rect.IntersectsWith (clip_rectangle)) {
3153                                 dc.FillRectangle (GetControlBackBrush (mc.BackColor), day_name_rect);
3154                                 // draw the day names
3155                                 DayOfWeek first_day_of_week = mc.GetDayOfWeek(mc.FirstDayOfWeek);
3156                                 for (int i=0; i < 7; i++)
3157                                 {
3158                                         int position = i - (int) first_day_of_week;
3159                                         if (position < 0)
3160                                         {
3161                                                 position = 7 + position;
3162                                         }
3163                                         // draw it
3164                                         Rectangle day_rect = new Rectangle(
3165                                                 day_name_rect.X + ((i + col_offset)* date_cell_size.Width),
3166                                                 day_name_rect.Y,
3167                                                 date_cell_size.Width,
3168                                                 date_cell_size.Height);
3169                                         dc.DrawString (sunday.AddDays (i + (int) first_day_of_week).ToString ("ddd"), mc.Font, ResPool.GetSolidBrush (mc.TitleBackColor), day_rect, mc.centered_format);
3170                                 }
3171
3172                                 // draw the vertical divider
3173                                 int vert_divider_y = Math.Max(title_size.Height+ date_cell_size.Height-1, 0);
3174                                 dc.DrawLine (
3175                                         ResPool.GetPen (mc.ForeColor),
3176                                         rectangle.X + (col_offset * date_cell_size.Width) + mc.divider_line_offset,
3177                                         rectangle.Y + vert_divider_y,
3178                                         rectangle.Right - mc.divider_line_offset,
3179                                         rectangle.Y + vert_divider_y);
3180                         }
3181
3182
3183                         // draw the actual date items in the grid (including the week numbers)
3184                         Rectangle date_rect = new Rectangle (
3185                                 rectangle.X,
3186                                 rectangle.Y + title_size.Height + date_cell_size.Height,
3187                                 date_cell_size.Width,
3188                                 date_cell_size.Height);
3189                         int month_row_count = 0;
3190                         bool draw_week_num_divider = false;
3191                         DateTime current_date = mc.GetFirstDateInMonthGrid ( new DateTime (this_month.Year, this_month.Month, 1));
3192                         for (int i=0; i < 6; i++)
3193                         {
3194                                 // establish if this row is in our clip_area
3195                                 Rectangle row_rect = new Rectangle (
3196                                         rectangle.X,
3197                                         rectangle.Y + title_size.Height + (date_cell_size.Height * (i+1)),
3198                                         date_cell_size.Width * 7,
3199                                         date_cell_size.Height);
3200                                 if (mc.ShowWeekNumbers) {
3201                                         row_rect.Width += date_cell_size.Width;
3202                                 }
3203
3204                                 bool draw_row = row_rect.IntersectsWith (clip_rectangle);
3205                                 if (draw_row) {
3206                                         dc.FillRectangle (GetControlBackBrush (mc.BackColor), row_rect);
3207                                 }
3208                                 // establish if this is a valid week to draw
3209                                 if (mc.IsValidWeekToDraw (this_month, current_date, row, col)) {
3210                                         month_row_count = i;
3211                                 }
3212
3213                                 // draw the week number if required
3214                                 if (mc.ShowWeekNumbers && month_row_count == i) {
3215                                         if (!draw_week_num_divider) {
3216                                                 draw_week_num_divider = draw_row;
3217                                         }
3218                                         // get the week for this row
3219                                         int week = mc.GetWeekOfYear (current_date);
3220
3221                                         if (draw_row) {
3222                                                 dc.DrawString (
3223                                                         week.ToString(),
3224                                                         mc.Font,
3225                                                         ResPool.GetSolidBrush (mc.TitleBackColor),
3226                                                         date_rect,
3227                                                         mc.centered_format);
3228                                         }
3229                                         date_rect.Offset(date_cell_size.Width, 0);
3230                                 }
3231
3232                                 // only draw the days if we have to
3233                                 if(month_row_count == i) {
3234                                         for (int j=0; j < 7; j++)
3235                                         {
3236                                                 if (draw_row) {
3237                                                         DrawMonthCalendarDate (
3238                                                                 dc,
3239                                                                 date_rect,
3240                                                                 mc,
3241                                                                 current_date,
3242                                                                 this_month,
3243                                                                 row,
3244                                                                 col);
3245                                                 }
3246
3247                                                 // move the day on
3248                                                 current_date = current_date.AddDays(1);
3249                                                 date_rect.Offset(date_cell_size.Width, 0);
3250                                         }
3251
3252                                         // shift the rectangle down one row
3253                                         int offset = (mc.ShowWeekNumbers) ? -8 : -7;
3254                                         date_rect.Offset(offset*date_cell_size.Width, date_cell_size.Height);
3255                                 }
3256                         }
3257
3258                         // month_row_count is zero based, so add one
3259                         month_row_count++;
3260
3261                         // draw week numbers if required
3262                         if (draw_week_num_divider) {
3263                                 col_offset = 1;
3264                                 dc.DrawLine (
3265                                         ResPool.GetPen (mc.ForeColor),
3266                                         rectangle.X + date_cell_size.Width - 1,
3267                                         rectangle.Y + title_size.Height + date_cell_size.Height + mc.divider_line_offset,
3268                                         rectangle.X + date_cell_size.Width - 1,
3269                                         rectangle.Y + title_size.Height + date_cell_size.Height + (month_row_count * date_cell_size.Height) - mc.divider_line_offset);
3270                         }
3271                 }
3272
3273                 // draws the pervious or next button
3274                 private void DrawMonthCalendarButton (Graphics dc, Rectangle rectangle, MonthCalendar mc, Size title_size, int x_offset, Size button_size, bool is_previous)
3275                 {
3276                         bool is_clicked = false;
3277                         Rectangle button_rect;
3278                         Rectangle arrow_rect = new Rectangle (rectangle.X, rectangle.Y, 4, 7);
3279                         Point[] arrow_path = new Point[3];
3280                         // prepare the button
3281                         if (is_previous)
3282                         {
3283                                 is_clicked = mc.is_previous_clicked;
3284                                 button_rect = new Rectangle (
3285                                         rectangle.X + 1 + x_offset,
3286                                         rectangle.Y + 1 + ((title_size.Height - button_size.Height)/2),
3287                                         Math.Max(button_size.Width - 1, 0),
3288                                         Math.Max(button_size.Height - 1, 0));
3289                                 arrow_rect.X = button_rect.X + ((button_rect.Width - arrow_rect.Width)/2);
3290                                 arrow_rect.Y = button_rect.Y + ((button_rect.Height - arrow_rect.Height)/2);
3291                                 if (is_clicked) {
3292                                         arrow_rect.Offset(1,1);
3293                                 }
3294                                 arrow_path[0] = new Point (arrow_rect.Right, arrow_rect.Y);
3295                                 arrow_path[1] = new Point (arrow_rect.X, arrow_rect.Y + arrow_rect.Height/2);
3296                                 arrow_path[2] = new Point (arrow_rect.Right, arrow_rect.Bottom);
3297                         }
3298                         else
3299                         {
3300                                 is_clicked = mc.is_next_clicked;
3301                                 button_rect = new Rectangle (
3302                                         rectangle.Right - 1 - x_offset - button_size.Width,
3303                                         rectangle.Y + 1 + ((title_size.Height - button_size.Height)/2),
3304                                         Math.Max(button_size.Width - 1, 0),
3305                                         Math.Max(button_size.Height - 1, 0));
3306                                 arrow_rect.X = button_rect.X + ((button_rect.Width - arrow_rect.Width)/2);
3307                                 arrow_rect.Y = button_rect.Y + ((button_rect.Height - arrow_rect.Height)/2);
3308                                 if (is_clicked) {
3309                                         arrow_rect.Offset(1,1);
3310                                 }
3311                                 arrow_path[0] = new Point (arrow_rect.X, arrow_rect.Y);
3312                                 arrow_path[1] = new Point (arrow_rect.Right, arrow_rect.Y + arrow_rect.Height/2);
3313                                 arrow_path[2] = new Point (arrow_rect.X, arrow_rect.Bottom);
3314                         }
3315
3316                         // fill the background
3317                         dc.FillRectangle (SystemBrushes.Control, button_rect);
3318                         // draw the border
3319                         if (is_clicked) {
3320                                 dc.DrawRectangle (SystemPens.ControlDark, button_rect);
3321                         }
3322                         else {
3323                                 CPDrawBorder3D (dc, button_rect, Border3DStyle.Raised, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom);
3324                         }
3325                         // draw the arrow
3326                         dc.FillPolygon (SystemBrushes.ControlText, arrow_path);
3327                 }
3328
3329
3330                 // draws one day in the calendar grid
3331                 private void DrawMonthCalendarDate (Graphics dc, Rectangle rectangle, MonthCalendar mc, DateTime date, DateTime month, int row, int col) {
3332                         Color date_color = mc.ForeColor;
3333                         Rectangle interior = new Rectangle (rectangle.X, rectangle.Y, Math.Max(rectangle.Width - 1, 0), Math.Max(rectangle.Height - 1, 0));
3334
3335                         // find out if we are the lead of the first calendar or the trail of the last calendar
3336                         if (date.Year != month.Year || date.Month != month.Month) {
3337                                 DateTime check_date = month.AddMonths (-1);
3338                                 // check if it's the month before
3339                                 if (check_date.Year == date.Year && check_date.Month == date.Month && row == 0 && col == 0) {
3340                                         date_color = mc.TrailingForeColor;
3341                                 } else {
3342                                         // check if it's the month after
3343                                         check_date = month.AddMonths (1);
3344                                         if (check_date.Year == date.Year && check_date.Month == date.Month && row == mc.CalendarDimensions.Height-1 && col == mc.CalendarDimensions.Width-1) {
3345                                                 date_color = mc.TrailingForeColor;
3346                                         } else {
3347                                                 return;
3348                                         }
3349                                 }
3350                         } else {
3351                                 date_color = mc.ForeColor;
3352                         }
3353
3354                         const int inflate = -1;
3355                         if (date == mc.SelectionStart && date == mc.SelectionEnd) {
3356                                 // see if the date is in the start of selection
3357                                 date_color = mc.BackColor;
3358                                 // draw the left hand of the back ground
3359                                 Rectangle selection_rect = Rectangle.Inflate (rectangle, inflate, inflate);
3360                                 dc.FillPie (ResPool.GetSolidBrush (mc.TitleBackColor), selection_rect, 0, 360);
3361                         } else if (date == mc.SelectionStart) {
3362                                 // see if the date is in the start of selection
3363                                 date_color = mc.BackColor;
3364                                 // draw the left hand of the back ground
3365                                 Rectangle selection_rect = Rectangle.Inflate (rectangle, inflate, inflate);
3366                                 dc.FillPie (ResPool.GetSolidBrush (mc.TitleBackColor), selection_rect, 90, 180);
3367                                 // fill the other side as a straight rect
3368                                 if (date < mc.SelectionEnd)
3369                                 {
3370                                         // use rectangle instead of rectangle to go all the way to edge of rect
3371                                         selection_rect.X = (int) Math.Floor((double)(rectangle.X + rectangle.Width / 2));
3372                                         selection_rect.Width = Math.Max(rectangle.Right - selection_rect.X, 0);
3373                                         dc.FillRectangle (ResPool.GetSolidBrush (mc.TitleBackColor), selection_rect);
3374                                 }
3375                         } else if (date == mc.SelectionEnd) {
3376                                 // see if it is the end of selection
3377                                 date_color = mc.BackColor;
3378                                 // draw the left hand of the back ground
3379                                 Rectangle selection_rect = Rectangle.Inflate (rectangle, inflate, inflate);
3380                                 dc.FillPie (ResPool.GetSolidBrush (mc.TitleBackColor), selection_rect, 270, 180);
3381                                 // fill the other side as a straight rect
3382                                 if (date > mc.SelectionStart) {
3383                                         selection_rect.X = rectangle.X;
3384                                         selection_rect.Width = rectangle.Width - (rectangle.Width / 2);
3385                                         dc.FillRectangle (ResPool.GetSolidBrush (mc.TitleBackColor), selection_rect);
3386                                 }
3387                         } else if (date > mc.SelectionStart && date < mc.SelectionEnd) {
3388                                 // now see if it's in the middle
3389                                 date_color = mc.BackColor;
3390                                 // draw the left hand of the back ground
3391                                 Rectangle selection_rect = Rectangle.Inflate (rectangle, 0, inflate);
3392                                 dc.FillRectangle (ResPool.GetSolidBrush (mc.TitleBackColor), selection_rect);
3393                         }
3394
3395                         // establish if it's a bolded font
3396                         Font font = mc.IsBoldedDate (date) ? mc.bold_font : mc.Font;
3397
3398                         // just draw the date now
3399                         dc.DrawString (date.Day.ToString(), font, ResPool.GetSolidBrush (date_color), rectangle, mc.centered_format);
3400
3401                         // today circle if needed
3402                         if (mc.ShowTodayCircle && date == DateTime.Now.Date) {
3403                                 DrawTodayCircle (dc, interior);
3404                         }
3405
3406                         // draw the selection grid
3407                         if (mc.is_date_clicked && mc.clicked_date == date) {
3408                                 Pen pen = ResPool.GetDashPen (Color.Black, DashStyle.Dot);
3409                                 dc.DrawRectangle (pen, interior);
3410                         }
3411                 }
3412
3413                 private void DrawTodayCircle (Graphics dc, Rectangle rectangle) {
3414                         Color circle_color = Color.FromArgb (248, 0, 0);
3415                         // draw the left hand of the circle
3416                         Rectangle lhs_circle_rect = new Rectangle (rectangle.X + 1, rectangle.Y + 4, Math.Max(rectangle.Width - 2, 0), Math.Max(rectangle.Height - 5, 0));
3417                         Rectangle rhs_circle_rect = new Rectangle (rectangle.X + 1, rectangle.Y + 1, Math.Max(rectangle.Width - 2, 0), Math.Max(rectangle.Height - 2, 0));
3418                         Point [] curve_points = new Point [3];
3419                         curve_points [0] = new Point (lhs_circle_rect.X, rhs_circle_rect.Y + rhs_circle_rect.Height/12);
3420                         curve_points [1] = new Point (lhs_circle_rect.X + lhs_circle_rect.Width/9, rhs_circle_rect.Y);
3421                         curve_points [2] = new Point (lhs_circle_rect.X + lhs_circle_rect.Width/2 + 1, rhs_circle_rect.Y);
3422
3423                         Pen pen = ResPool.GetSizedPen(circle_color, 2);
3424                         dc.DrawArc (pen, lhs_circle_rect, 90, 180);
3425                         dc.DrawArc (pen, rhs_circle_rect, 270, 180);
3426                         dc.DrawCurve (pen, curve_points);
3427                         dc.DrawLine (ResPool.GetPen (circle_color), curve_points [2], new Point (curve_points [2].X, lhs_circle_rect.Y));
3428                 }
3429
3430                 #endregion      // MonthCalendar
3431
3432                 #region Panel
3433                 public override Size PanelDefaultSize {
3434                         get {
3435                                 return new Size (200, 100);
3436                         }
3437                 }
3438                 #endregion      // Panel
3439
3440                 #region PictureBox
3441                 public override void DrawPictureBox (Graphics dc, Rectangle clip, PictureBox pb) {
3442                         Rectangle client = pb.ClientRectangle;
3443
3444                         // FIXME - instead of drawing the whole picturebox every time
3445                         // intersect the clip rectangle with the drawn picture and only draw what's needed,
3446                         // Also, we only need a background fill where no image goes
3447                         if (pb.Image != null) {
3448                                 switch (pb.SizeMode) {
3449                                 case PictureBoxSizeMode.StretchImage:
3450                                         dc.DrawImage (pb.Image, 0, 0, client.Width, client.Height);
3451                                         break;
3452
3453                                 case PictureBoxSizeMode.CenterImage:
3454                                         dc.FillRectangle(GetControlBackBrush (pb.BackColor), clip);
3455                                         dc.DrawImage (pb.Image, (client.Width / 2) - (pb.Image.Width / 2), (client.Height / 2) - (pb.Image.Height / 2));
3456                                         break;
3457                                 default:
3458                                         dc.FillRectangle(GetControlBackBrush (pb.BackColor), clip);
3459                                         // Normal, AutoSize
3460                                         dc.DrawImage(pb.Image, 0, 0, pb.Image.Width, pb.Image.Height);
3461                                         break;
3462                                 }
3463
3464                                 return;
3465                         }
3466
3467                         // We only get here if no image is set. At least paint the background
3468                         dc.FillRectangle(GetControlBackBrush (pb.BackColor), clip);
3469                 }
3470
3471                 public override Size PictureBoxDefaultSize {
3472                         get {
3473                                 return new Size (100, 50);
3474                         }
3475                 }
3476                 #endregion      // PictureBox
3477
3478                 #region PrintPreviewControl
3479                 public override int PrintPreviewControlPadding {
3480                         get { return 8; }
3481                 }
3482
3483                 public override Size PrintPreviewControlGetPageSize (PrintPreviewControl preview)
3484                 {
3485                         int page_width, page_height;
3486                         int padding = PrintPreviewControlPadding;
3487                         PreviewPageInfo[] pis = preview.page_infos;
3488
3489                         if (preview.AutoZoom) {
3490                                 int height_available = preview.ClientRectangle.Height - (preview.Rows) * padding - 2 * padding;
3491                                 int width_available = preview.ClientRectangle.Width - (preview.Columns - 1) * padding - 2 * padding;
3492
3493                                 float image_ratio = (float)pis[0].Image.Width / pis[0].Image.Height;
3494
3495                                 /* try to lay things out using the width to determine the size */
3496                                 page_width = width_available / preview.Columns;
3497                                 page_height = (int)(page_width / image_ratio);
3498
3499                                 /* does the height fit? */
3500                                 if (page_height * (preview.Rows + 1) > height_available) {
3501                                         /* no, lay things out via the height */
3502                                         page_height = height_available / (preview.Rows + 1);
3503                                         page_width = (int)(page_height * image_ratio);
3504                                 }
3505                         }
3506                         else {
3507                                 page_width = (int)(pis[0].Image.Width * preview.Zoom);
3508                                 page_height = (int)(pis[0].Image.Height * preview.Zoom);
3509                         }
3510
3511                         return new Size (page_width, page_height);
3512                 }
3513
3514                 public override void PrintPreviewControlPaint (PaintEventArgs pe, PrintPreviewControl preview, Size page_size)
3515                 {
3516                         int padding = 8;
3517                         PreviewPageInfo[] pis = preview.page_infos;
3518                         if (pis == null)
3519                                 return;
3520
3521                         int page_x, page_y;
3522
3523                         int width = page_size.Width * preview.Columns + padding * (preview.Columns - 1) + 2 * padding;
3524                         int height = page_size.Height * (preview.Rows + 1) + padding * preview.Rows + 2 * padding;
3525
3526                         Rectangle viewport = preview.ViewPort;
3527
3528                         pe.Graphics.Clip = new Region (viewport);
3529
3530                         /* center things if we can */
3531                         int off_x = viewport.Width / 2 - width / 2;
3532                         if (off_x < 0) off_x = 0;
3533                         int off_y = viewport.Height / 2 - height / 2;
3534                         if (off_y < 0) off_y = 0;
3535
3536                         page_y = off_y + padding - preview.vbar_value;
3537
3538                         if (preview.StartPage > 0) {
3539                                 int p = preview.StartPage - 1;
3540                                 for (int py = 0; py < preview.Rows + 1; py ++) {
3541                                         page_x = off_x + padding - preview.hbar_value;
3542                                         for (int px = 0; px < preview.Columns; px ++) {
3543                                                 if (p >= pis.Length)
3544                                                         continue;
3545                                                 Image image = preview.image_cache[p];
3546                                                 if (image == null)
3547                                                         image = pis[p].Image;
3548                                                 Rectangle dest = new Rectangle (new Point (page_x, page_y), page_size);
3549
3550                                                 pe.Graphics.DrawImage (image, dest, 0, 0, image.Width, image.Height, GraphicsUnit.Pixel);
3551
3552                                                 page_x += padding + page_size.Width;
3553                                                 p++;
3554                                         }
3555                                         page_y += padding + page_size.Height;
3556                                 }
3557                         }
3558                 }
3559                 #endregion      // PrintPreviewControl
3560
3561                 #region ProgressBar
3562                 public override void DrawProgressBar (Graphics dc, Rectangle clip_rect, ProgressBar ctrl)
3563                 {
3564                         Rectangle       block_rect;
3565                         Rectangle       client_area = ctrl.client_area;
3566                         int             space_betweenblocks     = 2;
3567                         int             block_width;
3568                         int             increment;
3569                         int             barpos_pixels;
3570
3571                         block_width = (client_area.Height * 2 ) / 3;
3572                         barpos_pixels = ((ctrl.Value - ctrl.Minimum) * client_area.Width) / (ctrl.Maximum - ctrl.Minimum);
3573                         increment = block_width + space_betweenblocks;
3574
3575                         /* Draw border */
3576                         CPDrawBorder3D (dc, ctrl.ClientRectangle, Border3DStyle.SunkenOuter, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom & ~Border3DSide.Middle, ColorControl);
3577
3578                         /* Draw Blocks */
3579                         block_rect = new Rectangle (client_area.X, client_area.Y, block_width, client_area.Height);
3580                         while ((block_rect.X - client_area.X) < barpos_pixels) {
3581
3582                                 if (clip_rect.IntersectsWith (block_rect) == true) {
3583                                         dc.FillRectangle (ResPool.GetSolidBrush (progressbarblock_color), block_rect);
3584                                 }
3585
3586                                 block_rect.X  += increment;
3587                         }
3588                 }
3589
3590                 public override Size ProgressBarDefaultSize {
3591                         get {
3592                                 return new Size (100, 23);
3593                         }
3594                 }
3595
3596                 #endregion      // ProgressBar
3597
3598                 #region RadioButton
3599                 public override void DrawRadioButton (Graphics dc, Rectangle clip_rectangle, RadioButton radio_button) {
3600                         StringFormat    text_format;
3601                         Rectangle       client_rectangle;
3602                         Rectangle       text_rectangle;
3603                         Rectangle       radiobutton_rectangle;
3604                         int             radiobutton_size = 13;
3605                         int     radiobutton_space = 4;
3606
3607                         client_rectangle = radio_button.ClientRectangle;
3608                         text_rectangle = client_rectangle;
3609                         radiobutton_rectangle = new Rectangle(text_rectangle.X, text_rectangle.Y, radiobutton_size, radiobutton_size);
3610
3611                         text_format = new StringFormat();
3612                         text_format.Alignment = StringAlignment.Near;
3613                         text_format.LineAlignment = StringAlignment.Center;
3614                         text_format.HotkeyPrefix = HotkeyPrefix.Show;
3615
3616                         /* Calculate the position of text and checkbox rectangle */
3617                         if (radio_button.appearance!=Appearance.Button) {
3618                                 switch(radio_button.radiobutton_alignment) {
3619                                 case ContentAlignment.BottomCenter: {
3620                                         radiobutton_rectangle.X=(client_rectangle.Right-client_rectangle.Left)/2-radiobutton_size/2;
3621                                         radiobutton_rectangle.Y=client_rectangle.Bottom-radiobutton_size;
3622                                         text_rectangle.X=client_rectangle.X;
3623                                         text_rectangle.Width=client_rectangle.Width;
3624                                         text_rectangle.Height=client_rectangle.Height-radiobutton_size-radiobutton_space;
3625                                         break;
3626                                 }
3627
3628                                 case ContentAlignment.BottomLeft: {
3629                                         radiobutton_rectangle.X=client_rectangle.Left;
3630                                         radiobutton_rectangle.Y=client_rectangle.Bottom-radiobutton_size;
3631                                         text_rectangle.X=client_rectangle.X+radiobutton_size+radiobutton_space;
3632                                         text_rectangle.Width=client_rectangle.Width-radiobutton_size-radiobutton_space;
3633                                         break;
3634                                 }
3635
3636                                 case ContentAlignment.BottomRight: {
3637                                         radiobutton_rectangle.X=client_rectangle.Right-radiobutton_size;
3638                                         radiobutton_rectangle.Y=client_rectangle.Bottom-radiobutton_size;
3639                                         text_rectangle.X=client_rectangle.X;
3640                                         text_rectangle.Width=client_rectangle.Width-radiobutton_size-radiobutton_space;
3641                                         break;
3642                                 }
3643
3644                                 case ContentAlignment.MiddleCenter: {
3645                                         radiobutton_rectangle.X=(client_rectangle.Right-client_rectangle.Left)/2-radiobutton_size/2;
3646                                         radiobutton_rectangle.Y=(client_rectangle.Bottom-client_rectangle.Top)/2-radiobutton_size/2;
3647                                         text_rectangle.X=client_rectangle.X;
3648                                         text_rectangle.Width=client_rectangle.Width;
3649                                         break;
3650                                 }
3651
3652                                 default:
3653                                 case ContentAlignment.MiddleLeft: {
3654                                         radiobutton_rectangle.X=client_rectangle.Left;
3655                                         radiobutton_rectangle.Y=(client_rectangle.Bottom-client_rectangle.Top)/2-radiobutton_size/2;
3656                                         text_rectangle.X=client_rectangle.X+radiobutton_size+radiobutton_space;
3657                                         text_rectangle.Width=client_rectangle.Width-radiobutton_size-radiobutton_space;
3658                                         break;
3659                                 }
3660
3661                                 case ContentAlignment.MiddleRight: {
3662                                         radiobutton_rectangle.X=client_rectangle.Right-radiobutton_size;
3663                                         radiobutton_rectangle.Y=(client_rectangle.Bottom-client_rectangle.Top)/2-radiobutton_size/2;
3664                                         text_rectangle.X=client_rectangle.X;
3665                                         text_rectangle.Width=client_rectangle.Width-radiobutton_size-radiobutton_space;
3666                                         break;
3667                                 }
3668
3669                                 case ContentAlignment.TopCenter: {
3670                                         radiobutton_rectangle.X=(client_rectangle.Right-client_rectangle.Left)/2-radiobutton_size/2;
3671                                         radiobutton_rectangle.Y=client_rectangle.Top;
3672                                         text_rectangle.X=client_rectangle.X;
3673                                         text_rectangle.Y=radiobutton_size+radiobutton_space;
3674                                         text_rectangle.Width=client_rectangle.Width;
3675                                         text_rectangle.Height=client_rectangle.Height-radiobutton_size-radiobutton_space;
3676                                         break;
3677                                 }
3678
3679                                 case ContentAlignment.TopLeft: {
3680                                         radiobutton_rectangle.X=client_rectangle.Left;
3681                                         radiobutton_rectangle.Y=client_rectangle.Top;
3682                                         text_rectangle.X=client_rectangle.X+radiobutton_size+radiobutton_space;
3683                                         text_rectangle.Width=client_rectangle.Width-radiobutton_size-radiobutton_space;
3684                                         break;
3685                                 }
3686
3687                                 case ContentAlignment.TopRight: {
3688                                         radiobutton_rectangle.X=client_rectangle.Right-radiobutton_size;
3689                                         radiobutton_rectangle.Y=client_rectangle.Top;
3690                                         text_rectangle.X=client_rectangle.X;
3691                                         text_rectangle.Width=client_rectangle.Width-radiobutton_size-radiobutton_space;
3692                                         break;
3693                                 }
3694                                 }
3695                         } else {
3696                                 text_rectangle.X=client_rectangle.X;
3697                                 text_rectangle.Width=client_rectangle.Width;
3698                         }
3699
3700                         /* Set the horizontal alignment of our text */
3701                         switch(radio_button.text_alignment) {
3702                                 case ContentAlignment.BottomLeft:
3703                                 case ContentAlignment.MiddleLeft:
3704                                 case ContentAlignment.TopLeft: {
3705                                         text_format.Alignment=StringAlignment.Near;
3706                                         break;
3707                                 }
3708
3709                                 case ContentAlignment.BottomCenter:
3710                                 case ContentAlignment.MiddleCenter:
3711                                 case ContentAlignment.TopCenter: {
3712                                         text_format.Alignment=StringAlignment.Center;
3713                                         break;
3714                                 }
3715
3716                                 case ContentAlignment.BottomRight:
3717                                 case ContentAlignment.MiddleRight:
3718                                 case ContentAlignment.TopRight: {
3719                                         text_format.Alignment=StringAlignment.Far;
3720                                         break;
3721                                 }
3722                         }
3723
3724                         /* Set the vertical alignment of our text */
3725                         switch(radio_button.text_alignment) {
3726                                 case ContentAlignment.TopLeft:
3727                                 case ContentAlignment.TopCenter:
3728                                 case ContentAlignment.TopRight: {
3729                                         text_format.LineAlignment=StringAlignment.Near;
3730                                         break;
3731                                 }
3732
3733                                 case ContentAlignment.BottomLeft:
3734                                 case ContentAlignment.BottomCenter:
3735                                 case ContentAlignment.BottomRight: {
3736                                         text_format.LineAlignment=StringAlignment.Far;
3737                                         break;
3738                                 }
3739
3740                                 case ContentAlignment.MiddleLeft:
3741                                 case ContentAlignment.MiddleCenter:
3742                                 case ContentAlignment.MiddleRight: {
3743                                         text_format.LineAlignment=StringAlignment.Center;
3744                                         break;
3745                                 }
3746                         }
3747
3748                         ButtonState state = ButtonState.Normal;
3749                         if (radio_button.FlatStyle == FlatStyle.Flat) {
3750                                 state |= ButtonState.Flat;
3751                         }
3752
3753                         if (radio_button.Checked) {
3754                                 state |= ButtonState.Checked;
3755                         }
3756
3757                         if (!radio_button.Enabled) {
3758                                 state |= ButtonState.Inactive;
3759                         }
3760
3761                         // Start drawing
3762                         RadioButton_DrawButton(radio_button, dc, state, radiobutton_rectangle);
3763
3764                         if ((radio_button.image != null) || (radio_button.image_list != null))
3765                                 ButtonBase_DrawImage(radio_button, dc);
3766
3767                         RadioButton_DrawText(radio_button, text_rectangle, dc, text_format);
3768
3769                         RadioButton_DrawFocus(radio_button, dc, text_rectangle);
3770
3771                         text_format.Dispose ();
3772                 }
3773
3774                 protected virtual void RadioButton_DrawButton(RadioButton radio_button, Graphics dc, ButtonState state, Rectangle radiobutton_rectangle)
3775                 {
3776                         dc.FillRectangle(GetControlBackBrush (radio_button.BackColor), radio_button.ClientRectangle);
3777
3778                         if (radio_button.appearance==Appearance.Button) {
3779                                 ButtonBase_DrawButton (radio_button, dc);
3780
3781                                 if ((radio_button.Focused) && radio_button.Enabled)
3782                                         ButtonBase_DrawFocus(radio_button, dc);
3783                         } else {
3784                                 // establish if we are rendering a flat style of some sort
3785                                 if (radio_button.FlatStyle == FlatStyle.Flat || radio_button.FlatStyle == FlatStyle.Popup) {
3786                                         DrawFlatStyleRadioButton (dc, radiobutton_rectangle, radio_button);
3787                                 } else {
3788                                         CPDrawRadioButton(dc, radiobutton_rectangle, state);
3789                                 }
3790                         }
3791                 }
3792
3793                 protected virtual void RadioButton_DrawText(RadioButton radio_button, Rectangle text_rectangle, Graphics dc, StringFormat text_format)
3794                 {
3795                         DrawCheckBox_and_RadioButtonText (radio_button, text_rectangle, dc,
3796                                                           text_format, radio_button.Appearance, radio_button.Checked);
3797                 }
3798
3799                 protected virtual void RadioButton_DrawFocus(RadioButton radio_button, Graphics dc, Rectangle text_rectangle)
3800                 {
3801                         if ( radio_button.Focused && radio_button.appearance != Appearance.Button && radio_button.Enabled )
3802                                 DrawInnerFocusRectangle( dc, text_rectangle, radio_button.BackColor );
3803                 }
3804
3805
3806                 // renders a radio button with the Flat and Popup FlatStyle
3807                 protected virtual void DrawFlatStyleRadioButton (Graphics graphics, Rectangle rectangle, RadioButton radio_button)
3808                 {
3809                         int     lineWidth;
3810
3811                         if (radio_button.Enabled) {
3812
3813                                 // draw the outer flatstyle arcs
3814                                 if (radio_button.FlatStyle == FlatStyle.Flat) {
3815                                         graphics.DrawArc (SystemPens.ControlDarkDark, rectangle, 0, 359);
3816
3817                                         // fill in the area depending on whether or not the mouse is hovering
3818                                         if ((radio_button.is_entered || radio_button.Capture) && !radio_button.is_pressed) {
3819                                                 graphics.FillPie (SystemBrushes.ControlLight, rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2, 0, 359);
3820                                         } else {
3821                                                 graphics.FillPie (SystemBrushes.ControlLightLight, rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2, 0, 359);
3822                                         }
3823                                 } else {
3824                                         // must be a popup radio button
3825                                         // fill the control
3826                                         graphics.FillPie (SystemBrushes.ControlLightLight, rectangle, 0, 359);
3827
3828                                         if (radio_button.is_entered || radio_button.Capture) {
3829                                                 // draw the popup 3d button knob
3830                                                 graphics.DrawArc (SystemPens.ControlLight, rectangle.X+1, rectangle.Y+1, rectangle.Width-2, rectangle.Height-2, 0, 359);
3831
3832                                                 graphics.DrawArc (SystemPens.ControlDark, rectangle, 135, 180);
3833                                                 graphics.DrawArc (SystemPens.ControlLightLight, rectangle, 315, 180);
3834
3835                                         } else {
3836                                                 // just draw lighter flatstyle outer circle
3837                                                 graphics.DrawArc (SystemPens.ControlDark, rectangle, 0, 359);
3838                                         }
3839                                 }
3840                         } else {
3841                                 // disabled
3842                                 // fill control background color regardless of actual backcolor
3843                                 graphics.FillPie (SystemBrushes.Control, rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2, 0, 359);
3844                                 // draw the ark as control dark
3845                                 graphics.DrawArc (SystemPens.ControlDark, rectangle, 0, 359);
3846                         }
3847
3848                         // draw the check
3849                         if (radio_button.Checked) {
3850                                 lineWidth = Math.Max (1, Math.Min(rectangle.Width, rectangle.Height)/3);
3851
3852                                 Pen dot_pen = SystemPens.ControlDarkDark;
3853                                 Brush dot_brush = SystemBrushes.ControlDarkDark;
3854
3855                                 if (!radio_button.Enabled || ((radio_button.FlatStyle == FlatStyle.Popup) && radio_button.is_pressed)) {
3856                                         dot_pen = SystemPens.ControlDark;
3857                                         dot_brush = SystemBrushes.ControlDark;
3858                                 }
3859
3860                                 if (rectangle.Height >  13) {
3861                                         graphics.FillPie (dot_brush, rectangle.X + lineWidth, rectangle.Y + lineWidth, rectangle.Width - lineWidth * 2, rectangle.Height - lineWidth * 2, 0, 359);
3862                                 } else {
3863                                         int x_half_pos = (rectangle.Width / 2) + rectangle.X;
3864                                         int y_half_pos = (rectangle.Height / 2) + rectangle.Y;
3865
3866                                         graphics.DrawLine (dot_pen, x_half_pos - 1, y_half_pos, x_half_pos + 2, y_half_pos);
3867                                         graphics.DrawLine (dot_pen, x_half_pos - 1, y_half_pos + 1, x_half_pos + 2, y_half_pos + 1);
3868
3869                                         graphics.DrawLine (dot_pen, x_half_pos, y_half_pos - 1, x_half_pos, y_half_pos + 2);
3870                                         graphics.DrawLine (dot_pen, x_half_pos + 1, y_half_pos - 1, x_half_pos + 1, y_half_pos + 2);
3871                                 }
3872                         }
3873                 }
3874
3875                 public override Size RadioButtonDefaultSize {
3876                         get {
3877                                 return new Size (104,24);
3878                         }
3879                 }
3880                 #endregion      // RadioButton
3881
3882                 #region ScrollBar
3883                 public override void DrawScrollBar (Graphics dc, Rectangle clip, ScrollBar bar)
3884                 {
3885                         int             scrollbutton_width = bar.scrollbutton_width;
3886                         int             scrollbutton_height = bar.scrollbutton_height;
3887                         Rectangle       first_arrow_area;
3888                         Rectangle       second_arrow_area;
3889                         Rectangle       thumb_pos;
3890
3891                         thumb_pos = bar.ThumbPos;
3892
3893                         if (bar.vert) {
3894                                 first_arrow_area = new Rectangle(0, 0, bar.Width, scrollbutton_height);
3895                                 bar.FirstArrowArea = first_arrow_area;
3896
3897                                 second_arrow_area = new Rectangle(0, bar.ClientRectangle.Height - scrollbutton_height, bar.Width, scrollbutton_height);
3898                                 bar.SecondArrowArea = second_arrow_area;
3899
3900                                 thumb_pos.Width = bar.Width;
3901                                 bar.ThumbPos = thumb_pos;
3902
3903                                 /* Buttons */
3904                                 if (clip.IntersectsWith (first_arrow_area))
3905                                         CPDrawScrollButton (dc, first_arrow_area, ScrollButton.Up, bar.firstbutton_state);
3906                                 if (clip.IntersectsWith (second_arrow_area))
3907                                         CPDrawScrollButton (dc, second_arrow_area, ScrollButton.Down, bar.secondbutton_state);
3908
3909                                 /* Background */
3910                                 switch (bar.thumb_moving) {
3911                                 case ScrollBar.ThumbMoving.None: {
3912                                         ScrollBar_Vertical_Draw_ThumbMoving_None(scrollbutton_height, bar, clip, dc);
3913                                         break;
3914                                 }
3915                                 case ScrollBar.ThumbMoving.Forward: {
3916                                         ScrollBar_Vertical_Draw_ThumbMoving_Forward(scrollbutton_height, bar, thumb_pos, clip, dc);
3917                                         break;
3918                                 }
3919
3920                                 case ScrollBar.ThumbMoving.Backwards: {
3921                                         ScrollBar_Vertical_Draw_ThumbMoving_Backwards(scrollbutton_height, bar, thumb_pos, clip, dc);
3922                                         break;
3923                                 }
3924
3925                                 default:
3926                                         break;
3927                                 }
3928                         } else {
3929                                 first_arrow_area = new Rectangle(0, 0, scrollbutton_width, bar.Height);
3930                                 bar.FirstArrowArea = first_arrow_area;
3931
3932                                 second_arrow_area = new Rectangle (bar.ClientRectangle.Width - scrollbutton_width, 0, scrollbutton_width, bar.Height);
3933                                 bar.SecondArrowArea = second_arrow_area;
3934
3935                                 thumb_pos.Height = bar.Height;
3936                                 bar.ThumbPos = thumb_pos;
3937
3938                                 /* Buttons */
3939                                 if (clip.IntersectsWith (first_arrow_area))
3940                                         CPDrawScrollButton (dc, first_arrow_area, ScrollButton.Left, bar.firstbutton_state);
3941                                 if (clip.IntersectsWith (second_arrow_area))
3942                                         CPDrawScrollButton (dc, second_arrow_area, ScrollButton.Right, bar.secondbutton_state);
3943
3944                                 /* Background */
3945                                 switch (bar.thumb_moving) {
3946                                 case ScrollBar.ThumbMoving.None: {
3947                                         ScrollBar_Horizontal_Draw_ThumbMoving_None(scrollbutton_width, bar, clip, dc);
3948                                         break;
3949                                 }
3950
3951                                 case ScrollBar.ThumbMoving.Forward: {
3952                                         ScrollBar_Horizontal_Draw_ThumbMoving_Forward(scrollbutton_width, thumb_pos, bar, clip, dc);
3953                                         break;
3954                                 }
3955
3956                                 case ScrollBar.ThumbMoving.Backwards: {
3957                                         ScrollBar_Horizontal_Draw_ThumbMoving_Backwards(scrollbutton_width, thumb_pos, bar, clip, dc);
3958                                         break;
3959                                 }
3960                                 }
3961                         }
3962
3963                         /* Thumb */
3964                         ScrollBar_DrawThumb(bar, thumb_pos, clip, dc);
3965                 }
3966
3967                 protected virtual void ScrollBar_DrawThumb(ScrollBar bar, Rectangle thumb_pos, Rectangle clip, Graphics dc)
3968                 {
3969                         if (bar.Enabled && thumb_pos.Width > 0 && thumb_pos.Height > 0 && clip.IntersectsWith(thumb_pos))
3970                                 DrawScrollButtonPrimitive(dc, thumb_pos, ButtonState.Normal);
3971                 }
3972
3973                 protected virtual void ScrollBar_Vertical_Draw_ThumbMoving_None( int scrollbutton_height, ScrollBar bar, Rectangle clip, Graphics dc )
3974                 {
3975                         Rectangle r = new Rectangle( 0,
3976                                                     scrollbutton_height, bar.ClientRectangle.Width, bar.ClientRectangle.Height - ( scrollbutton_height * 2 ) );
3977                         Rectangle intersect = Rectangle.Intersect( clip, r );
3978
3979                         if ( intersect != Rectangle.Empty )
3980                         {
3981                                 Brush h = ResPool.GetHatchBrush( HatchStyle.Percent50, ColorScrollBar, Color.White);
3982                                 dc.FillRectangle( h, intersect );
3983                         }
3984                 }
3985
3986                 protected virtual void ScrollBar_Vertical_Draw_ThumbMoving_Forward( int scrollbutton_height, ScrollBar bar, Rectangle thumb_pos, Rectangle clip, Graphics dc )
3987                 {
3988                         Rectangle r = new Rectangle( 0,  scrollbutton_height,
3989                                                     bar.ClientRectangle.Width, thumb_pos.Y - scrollbutton_height );
3990                         Rectangle intersect = Rectangle.Intersect( clip, r );
3991
3992                         if ( intersect != Rectangle.Empty )
3993                                 dc.FillRectangle( ResPool.GetHatchBrush( HatchStyle.Percent50, ColorScrollBar, Color.White ), intersect );
3994
3995                         r.X = 0;
3996                         r.Y = thumb_pos.Y + thumb_pos.Height;
3997                         r.Width = bar.ClientRectangle.Width;
3998                         r.Height = bar.ClientRectangle.Height -  ( thumb_pos.Y + thumb_pos.Height ) - scrollbutton_height;
3999
4000                         intersect = Rectangle.Intersect( clip, r );
4001                         if ( intersect != Rectangle.Empty )
4002                                 dc.FillRectangle( ResPool.GetHatchBrush( HatchStyle.Percent50, Color.FromArgb( 255, 63, 63, 63 ), Color.Black ), intersect );
4003                 }
4004
4005                 protected virtual void ScrollBar_Vertical_Draw_ThumbMoving_Backwards( int scrollbutton_height, ScrollBar bar, Rectangle thumb_pos, Rectangle clip, Graphics dc )
4006                 {
4007                         Rectangle r = new Rectangle( 0,  scrollbutton_height,
4008                                                     bar.ClientRectangle.Width, thumb_pos.Y - scrollbutton_height );
4009                         Rectangle intersect = Rectangle.Intersect( clip, r );
4010
4011                         if ( intersect != Rectangle.Empty )
4012                                 dc.FillRectangle( ResPool.GetHatchBrush( HatchStyle.Percent50, Color.FromArgb( 255, 63, 63, 63 ), Color.Black ), intersect );
4013
4014                         r.X = 0;
4015                         r.Y = thumb_pos.Y + thumb_pos.Height;
4016                         r.Width = bar.ClientRectangle.Width;
4017                         r.Height = bar.ClientRectangle.Height -  ( thumb_pos.Y + thumb_pos.Height ) - scrollbutton_height;
4018
4019                         intersect = Rectangle.Intersect( clip, r );
4020                         if ( intersect != Rectangle.Empty )
4021                                 dc.FillRectangle( ResPool.GetHatchBrush( HatchStyle.Percent50, ColorScrollBar, Color.White), intersect );
4022                 }
4023
4024                 protected virtual void ScrollBar_Horizontal_Draw_ThumbMoving_None( int scrollbutton_width, ScrollBar bar, Rectangle clip, Graphics dc )
4025                 {
4026                         Rectangle r = new Rectangle( scrollbutton_width,
4027                                                     0, bar.ClientRectangle.Width - ( scrollbutton_width * 2 ), bar.ClientRectangle.Height );
4028                         Rectangle intersect = Rectangle.Intersect( clip, r );
4029
4030                         if ( intersect != Rectangle.Empty )
4031                                 dc.FillRectangle( ResPool.GetHatchBrush( HatchStyle.Percent50, ColorScrollBar, Color.White), intersect );
4032                 }
4033
4034                 protected virtual void ScrollBar_Horizontal_Draw_ThumbMoving_Forward( int scrollbutton_width, Rectangle thumb_pos, ScrollBar bar, Rectangle clip, Graphics dc )
4035                 {
4036                         Rectangle r = new Rectangle( scrollbutton_width,  0,
4037                                                     thumb_pos.X - scrollbutton_width, bar.ClientRectangle.Height );
4038                         Rectangle intersect = Rectangle.Intersect( clip, r );
4039
4040                         if ( intersect != Rectangle.Empty )
4041                                 dc.FillRectangle( ResPool.GetHatchBrush( HatchStyle.Percent50, ColorScrollBar, Color.White), intersect );
4042
4043                         r.X = thumb_pos.X + thumb_pos.Width;
4044                         r.Y = 0;
4045                         r.Width = bar.ClientRectangle.Width -  ( thumb_pos.X + thumb_pos.Width ) - scrollbutton_width;
4046                         r.Height = bar.ClientRectangle.Height;
4047
4048                         intersect = Rectangle.Intersect( clip, r );
4049                         if ( intersect != Rectangle.Empty )
4050                                 dc.FillRectangle( ResPool.GetHatchBrush( HatchStyle.Percent50, Color.FromArgb( 255, 63, 63, 63 ), Color.Black ), intersect );
4051                 }
4052
4053                 protected virtual void ScrollBar_Horizontal_Draw_ThumbMoving_Backwards( int scrollbutton_width, Rectangle thumb_pos, ScrollBar bar, Rectangle clip, Graphics dc )
4054                 {
4055                         Rectangle r = new Rectangle( scrollbutton_width,  0,
4056                                                     thumb_pos.X - scrollbutton_width, bar.ClientRectangle.Height );
4057                         Rectangle intersect = Rectangle.Intersect( clip, r );
4058
4059                         if ( intersect != Rectangle.Empty )
4060                                 dc.FillRectangle( ResPool.GetHatchBrush( HatchStyle.Percent50, Color.FromArgb( 255, 63, 63, 63 ), Color.Black ), intersect );
4061
4062                         r.X = thumb_pos.X + thumb_pos.Width;
4063                         r.Y = 0;
4064                         r.Width = bar.ClientRectangle.Width -  ( thumb_pos.X + thumb_pos.Width ) - scrollbutton_width;
4065                         r.Height = bar.ClientRectangle.Height;
4066
4067                         intersect = Rectangle.Intersect( clip, r );
4068                         if ( intersect != Rectangle.Empty )
4069                                 dc.FillRectangle( ResPool.GetHatchBrush( HatchStyle.Percent50, ColorScrollBar, Color.White), intersect );
4070                 }
4071
4072                 public override int ScrollBarButtonSize {
4073                         get { return 16; }
4074                 }
4075                 #endregion      // ScrollBar
4076
4077                 #region StatusBar
4078                 public  override void DrawStatusBar (Graphics dc, Rectangle clip, StatusBar sb) {
4079                         Rectangle area = sb.ClientRectangle;
4080                         int horz_border = 2;
4081                         int vert_border = 2;
4082
4083                         bool is_color_control = sb.BackColor.ToArgb () == ColorControl.ToArgb ();
4084
4085                         Brush brush = is_color_control ? SystemBrushes.Control : ResPool.GetSolidBrush (sb.BackColor);
4086                         dc.FillRectangle (brush, clip);
4087
4088                         if (!sb.ShowPanels && sb.Text != String.Empty) {
4089                                 string text = sb.Text;
4090                                 StringFormat string_format = new StringFormat ();
4091                                 string_format.Trimming = StringTrimming.Character;
4092                                 string_format.FormatFlags = StringFormatFlags.NoWrap;
4093
4094                                 if (text.Length > 127)
4095                                         text = text.Substring (0, 127);
4096
4097                                 if (text [0] == '\t') {
4098                                         string_format.Alignment = StringAlignment.Center;
4099                                         text = text.Substring (1);
4100                                         if (text [0] == '\t') {
4101                                                 string_format.Alignment = StringAlignment.Far;
4102                                                 text = text.Substring (1);
4103                                         }
4104                                 }
4105
4106                                 dc.DrawString (text, sb.Font, ResPool.GetSolidBrush (sb.ForeColor),
4107                                                 new Rectangle(area.X + 2, area.Y + 2, area.Width - 4, area.Height - 4), string_format);
4108                                 string_format.Dispose ();
4109                         } else if (sb.ShowPanels) {
4110                                 Brush br_forecolor = GetControlForeBrush (sb.ForeColor);
4111                                 int prev_x = area.X + horz_border;
4112                                 int y = area.Y + vert_border;
4113                                 for (int i = 0; i < sb.Panels.Count; i++) {
4114                                         Rectangle pr = new Rectangle (prev_x, y,
4115                                                 sb.Panels [i].Width, area.Height);
4116                                         prev_x += pr.Width + StatusBarHorzGapWidth;
4117                                         if (pr.IntersectsWith (clip))
4118                                                 DrawStatusBarPanel (dc, pr, i, br_forecolor, sb.Panels [i]);
4119                                 }
4120                         }
4121
4122                         if (sb.SizingGrip) {
4123                                 area = new Rectangle (area.Right - 16 - 2, area.Bottom - 12 - 1, 16, 16);
4124                                 CPDrawSizeGrip (dc, ColorControl, area);
4125                         }
4126
4127                 }
4128
4129
4130                 protected virtual void DrawStatusBarPanel (Graphics dc, Rectangle area, int index,
4131                         Brush br_forecolor, StatusBarPanel panel) {
4132                         int border_size = 3; // this is actually const, even if the border style is none
4133                         int icon_width = 16;
4134
4135                         area.Height -= border_size;
4136
4137                         if (panel.BorderStyle != StatusBarPanelBorderStyle.None) {
4138                                 Border3DStyle border_style = Border3DStyle.SunkenOuter;
4139                                 if (panel.BorderStyle == StatusBarPanelBorderStyle.Raised)
4140                                         border_style = Border3DStyle.RaisedInner;
4141
4142                                 CPDrawBorder3D(dc, area, border_style, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, panel.Parent.BackColor);
4143                         }
4144
4145                         if (panel.Style == StatusBarPanelStyle.OwnerDraw) {
4146                                 StatusBarDrawItemEventArgs e = new StatusBarDrawItemEventArgs (
4147                                         dc, panel.Parent.Font, area, index, DrawItemState.Default,
4148                                         panel, panel.Parent.ForeColor, panel.Parent.BackColor);
4149                                 panel.Parent.OnDrawItemInternal (e);
4150                                 return;
4151                         }
4152
4153                         if (panel.Text == String.Empty)
4154                                         return;
4155
4156                         string text = panel.Text;
4157                         StringFormat string_format = new StringFormat ();
4158                         string_format.Trimming = StringTrimming.Character;
4159                         string_format.FormatFlags = StringFormatFlags.NoWrap;
4160
4161
4162                         if (text [0] == '\t') {
4163                                 string_format.Alignment = StringAlignment.Center;
4164                                 text = text.Substring (1);
4165                                 if (text [0] == '\t') {
4166                                         string_format.Alignment = StringAlignment.Far;
4167                                         text = text.Substring (1);
4168                                 }
4169                         }
4170
4171                         Rectangle string_rect = Rectangle.Empty;
4172                         int x;
4173                         int len;
4174                         int icon_x = 0;
4175                         int y = (area.Height / 2 - (int) panel.Parent.Font.Size / 2) - 1;
4176
4177                         switch (panel.Alignment) {
4178                         case HorizontalAlignment.Right:
4179                                 len = (int) dc.MeasureString (text, panel.Parent.Font).Width;
4180                                 x = area.Right - len - 4;
4181                                 string_rect = new Rectangle (x, y,
4182                                                 area.Right - x - border_size,
4183                                                 area.Bottom - y - border_size);
4184                                 if (panel.Icon != null) {
4185                                         icon_x = x - icon_width - 2;
4186                                 }
4187                                 break;
4188                         case HorizontalAlignment.Center:
4189                                 len = (int) dc.MeasureString (text, panel.Parent.Font).Width;
4190                                 x = (panel.Width / 2) + (len / 2);
4191                                 string_rect = new Rectangle (x, y,
4192                                                 area.Right - x - border_size,
4193                                                 area.Bottom - y - border_size);
4194
4195                                 if (panel.Icon != null) {
4196                                         icon_x = x - icon_width - 2;
4197                                 }
4198                                 break;
4199
4200
4201                         default:
4202                                 int left = area.Left + border_size;;
4203                                 if (panel.Icon != null) {
4204                                         icon_x = area.Left + 2;
4205                                         left = icon_x + icon_width + 2;
4206                                 }
4207
4208                                 x = left;
4209                                 string_rect = new Rectangle (x, y,
4210                                                 area.Right - x - border_size,
4211                                                 area.Bottom - y - border_size);
4212                                 break;
4213                         }
4214
4215                         RectangleF clip_bounds = dc.ClipBounds;
4216                         dc.SetClip (area);
4217                         dc.DrawString (text, panel.Parent.Font, br_forecolor, string_rect, string_format);
4218                         dc.SetClip (clip_bounds);
4219
4220                         if (panel.Icon != null) {
4221                                 dc.DrawIcon (panel.Icon, new Rectangle (icon_x, y, icon_width, icon_width));
4222                         }
4223                 }
4224
4225                 public override int StatusBarSizeGripWidth {
4226                         get { return 15; }
4227                 }
4228
4229                 public override int StatusBarHorzGapWidth {
4230                         get { return 3; }
4231                 }
4232
4233                 public override Size StatusBarDefaultSize {
4234                         get {
4235                                 return new Size (100, 22);
4236                         }
4237                 }
4238                 #endregion      // StatusBar
4239
4240                 public override void DrawTabControl (Graphics dc, Rectangle area, TabControl tab)
4241                 {
4242                         Brush brush = SystemBrushes.Control;
4243                         dc.FillRectangle (brush, area);
4244                         Rectangle panel_rect = GetTabPanelRectExt (tab);
4245
4246                         if (tab.Appearance == TabAppearance.Normal) {
4247                                 CPDrawBorder3D (dc, panel_rect, Border3DStyle.RaisedInner, Border3DSide.Left | Border3DSide.Top, ColorControl);
4248                                 CPDrawBorder3D (dc, panel_rect, Border3DStyle.Raised, Border3DSide.Right | Border3DSide.Bottom, ColorControl);
4249                         }
4250
4251                         if (tab.Alignment == TabAlignment.Top) {
4252                                 for (int r = tab.TabPages.Count; r > 0; r--) {
4253                                         for (int i = tab.SliderPos; i < tab.TabPages.Count; i++) {
4254                                                 if (i == tab.SelectedIndex)
4255                                                         continue;
4256                                                 if (r != tab.TabPages [i].Row)
4257                                                         continue;
4258                                                 Rectangle rect = tab.GetTabRect (i);
4259                                                 if (!rect.IntersectsWith (area))
4260                                                         continue;
4261                                                 DrawTab (dc, tab.TabPages [i], tab, rect, false);
4262                                         }
4263                                 }
4264                         } else {
4265                                 for (int r = 0; r < tab.TabPages.Count; r++) {
4266                                         for (int i = tab.SliderPos; i < tab.TabPages.Count; i++) {
4267                                                 if (i == tab.SelectedIndex)
4268                                                         continue;
4269                                                 if (r != tab.TabPages [i].Row)
4270                                                         continue;
4271                                                 Rectangle rect = tab.GetTabRect (i);
4272                                                 if (!rect.IntersectsWith (area))
4273                                                         continue;
4274                                                 DrawTab (dc, tab.TabPages [i], tab, rect, false);
4275                                         }
4276                                 }
4277                         }
4278
4279                         if (tab.SelectedIndex != -1 && tab.SelectedIndex >= tab.SliderPos) {
4280                                 Rectangle rect = tab.GetTabRect (tab.SelectedIndex);
4281                                 if (rect.IntersectsWith (area))
4282                                         DrawTab (dc, tab.TabPages [tab.SelectedIndex], tab, rect, true);
4283                         }
4284
4285                         if (tab.ShowSlider) {
4286                                 Rectangle right = GetTabControlRightScrollRect (tab);
4287                                 Rectangle left = GetTabControlLeftScrollRect (tab);
4288                                 CPDrawScrollButton (dc, right, ScrollButton.Right, tab.RightSliderState);
4289                                 CPDrawScrollButton (dc, left, ScrollButton.Left, tab.LeftSliderState);
4290                         }
4291                 }
4292
4293                 public override Rectangle GetTabControlLeftScrollRect (TabControl tab)
4294                 {
4295                         switch (tab.Alignment) {
4296                         case TabAlignment.Top:
4297                                 return new Rectangle (tab.ClientRectangle.Right - 34, tab.ClientRectangle.Top + 1, 17, 17);
4298                         default:
4299                                 Rectangle panel_rect = GetTabPanelRectExt (tab);
4300                                 return new Rectangle (tab.ClientRectangle.Right - 34, panel_rect.Bottom + 2, 17, 17);
4301                         }
4302                 }
4303
4304                 public override Rectangle GetTabControlRightScrollRect (TabControl tab)
4305                 {
4306                         switch (tab.Alignment) {
4307                         case TabAlignment.Top:
4308                                 return new Rectangle (tab.ClientRectangle.Right - 17, tab.ClientRectangle.Top + 1, 17, 17);
4309                         default:
4310                                 Rectangle panel_rect = GetTabPanelRectExt (tab);
4311                                 return new Rectangle (tab.ClientRectangle.Right - 17, panel_rect.Bottom + 2, 17, 17);
4312                         }
4313                 }
4314
4315                 public override Size TabControlDefaultItemSize {
4316                         get { return new Size (42, 21); }
4317                 }
4318
4319                 public override Point TabControlDefaultPadding {
4320                         get { return new Point (6, 3); }
4321                 }
4322
4323                 public override int TabControlMinimumTabWidth {
4324                         get { return 42; }
4325                 }
4326
4327                 public override Rectangle GetTabControlDisplayRectangle (TabControl tab)
4328                 {
4329                         Rectangle ext = GetTabPanelRectExt (tab);
4330                         // Account for border size
4331                         return new Rectangle (ext.Left + 2, ext.Top + 1, ext.Width - 6, ext.Height - 4);
4332                 }
4333
4334                 public override Size TabControlGetSpacing (TabControl tab) {
4335                         switch (tab.Appearance) {
4336                                 case TabAppearance.Normal:
4337                                         return new Size (1, -2);
4338                                 case TabAppearance.Buttons:
4339                                         return new Size (3, 3);
4340                                 case TabAppearance.FlatButtons:
4341                                         return new Size (9, 3);
4342                                 default:
4343                                         throw new Exception ("Invalid Appearance value: " + tab.Appearance);
4344                                 }
4345                 }
4346
4347                 protected virtual Rectangle GetTabPanelRectExt (TabControl tab)
4348                 {
4349                         // Offset the tab from the top corner
4350                         Rectangle res = new Rectangle (tab.ClientRectangle.X + 2,
4351                                         tab.ClientRectangle.Y,
4352                                         tab.ClientRectangle.Width - 2,
4353                                         tab.ClientRectangle.Height - 1);
4354
4355                         if (tab.TabCount == 0)
4356                                 return res;
4357
4358                         int spacing = TabControlGetSpacing (tab).Height;
4359                         int offset = (tab.ItemSize.Height + spacing) * tab.RowCount + 3;
4360
4361                         switch (tab.Alignment) {
4362                         case TabAlignment.Left:
4363                                 res.X += offset;
4364                                 res.Width -= offset;
4365                                 break;
4366                         case TabAlignment.Right:
4367                                 res.Width -= offset;
4368                                 break;
4369                         case TabAlignment.Top:
4370                                 res.Y += offset;
4371                                 res.Height -= offset;
4372                                 break;
4373                         case TabAlignment.Bottom:
4374                                 res.Height -= offset;
4375                                 break;
4376                         }
4377
4378                         return res;
4379                 }
4380
4381                 protected virtual int DrawTab (Graphics dc, TabPage page, TabControl tab, Rectangle bounds, bool is_selected)
4382                 {
4383                         int FlatButtonSpacing = 8;
4384                         Rectangle interior;
4385                         int res = bounds.Width;
4386
4387
4388
4389                         // we can't fill the background right away because the bounds might be adjusted if the tab is selected
4390
4391                         StringFormat string_format = new StringFormat ();
4392                         if (tab.Appearance == TabAppearance.Buttons || tab.Appearance == TabAppearance.FlatButtons) {
4393                                 dc.FillRectangle (ResPool.GetSolidBrush (tab.BackColor), bounds);
4394
4395                                 // Separators
4396                                 if (tab.Appearance == TabAppearance.FlatButtons) {
4397                                         int width = bounds.Width;
4398                                         bounds.Width += (FlatButtonSpacing - 2);
4399                                         res = bounds.Width;
4400                                         CPDrawBorder3D (dc, bounds, Border3DStyle.Etched, Border3DSide.Right);
4401                                         bounds.Width = width;
4402                                 }
4403
4404                                 if (is_selected) {
4405                                         CPDrawBorder3D (dc, bounds, Border3DStyle.Sunken, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom);
4406                                 } else if (tab.Appearance != TabAppearance.FlatButtons) {
4407                                         CPDrawBorder3D (dc, bounds, Border3DStyle.Raised, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom);
4408                                 }
4409
4410                                 interior = new Rectangle (bounds.Left + 2, bounds.Top + 2, bounds.Width - 4, bounds.Height - 4);
4411
4412
4413                                 string_format.Alignment = StringAlignment.Center;
4414                                 string_format.LineAlignment = StringAlignment.Center;
4415                                 string_format.FormatFlags = StringFormatFlags.NoWrap;
4416                         } else {
4417                                 CPColor cpcolor = ResPool.GetCPColor (tab.BackColor);
4418
4419                                 Pen light = ResPool.GetPen (cpcolor.LightLight);
4420
4421                                 switch (tab.Alignment) {
4422
4423                                 case TabAlignment.Top:
4424
4425                                         dc.FillRectangle (ResPool.GetSolidBrush (tab.BackColor), bounds);
4426
4427                                         dc.DrawLine (light, bounds.Left, bounds.Bottom, bounds.Left, bounds.Top + 3);
4428                                         dc.DrawLine (light, bounds.Left, bounds.Top + 3, bounds.Left + 3, bounds.Top);
4429                                         dc.DrawLine (light, bounds.Left + 3, bounds.Top, bounds.Right - 3, bounds.Top);
4430
4431                                         dc.DrawLine (SystemPens.ControlDark, bounds.Right - 1, bounds.Top + 1, bounds.Right - 1, bounds.Bottom);
4432                                         dc.DrawLine (SystemPens.ControlDarkDark, bounds.Right - 1, bounds.Top + 2, bounds.Right, bounds.Top + 3);
4433                                         dc.DrawLine (SystemPens.ControlDarkDark, bounds.Right, bounds.Top + 3, bounds.Right, bounds.Bottom);
4434
4435                                         interior = new Rectangle (bounds.Left + 4, bounds.Top + 4, bounds.Width - 8, bounds.Height - 8);
4436
4437                                         string_format.Alignment = StringAlignment.Center;
4438                                         string_format.LineAlignment = StringAlignment.Center;
4439                                         string_format.FormatFlags = StringFormatFlags.NoWrap;
4440
4441                                         break;
4442
4443                                 case TabAlignment.Bottom:
4444
4445                                         dc.FillRectangle (ResPool.GetSolidBrush (tab.BackColor), bounds);
4446
4447                                         dc.DrawLine (light, bounds.Left, bounds.Top, bounds.Left, bounds.Bottom - 3);
4448                                         dc.DrawLine (light, bounds.Left, bounds.Bottom - 3, bounds.Left + 2, bounds.Bottom - 1);
4449
4450                                         dc.DrawLine (SystemPens.ControlDark, bounds.Left + 3, bounds.Bottom - 1, bounds.Right - 3, bounds.Bottom - 1);
4451                                         dc.DrawLine (SystemPens.ControlDark, bounds.Right - 1, bounds.Bottom - 3, bounds.Right - 1, bounds.Top);
4452
4453                                         dc.DrawLine (SystemPens.ControlDarkDark, bounds.Left + 3, bounds.Bottom, bounds.Right - 3, bounds.Bottom);
4454                                         dc.DrawLine (SystemPens.ControlDarkDark, bounds.Right - 3, bounds.Bottom, bounds.Right, bounds.Bottom - 3);
4455                                         dc.DrawLine (SystemPens.ControlDarkDark, bounds.Right, bounds.Bottom - 3, bounds.Right, bounds.Top);
4456
4457                                         interior = new Rectangle (bounds.Left + 4, bounds.Top + 4, bounds.Width - 8, bounds.Height - 8);
4458
4459                                         string_format.Alignment = StringAlignment.Center;
4460                                         string_format.LineAlignment = StringAlignment.Center;
4461                                         string_format.FormatFlags = StringFormatFlags.NoWrap;
4462
4463                                         break;
4464
4465                                 case TabAlignment.Left:
4466
4467                                         dc.FillRectangle (ResPool.GetSolidBrush (tab.BackColor), bounds);
4468
4469                                         dc.DrawLine (light, bounds.Left, bounds.Bottom - 3, bounds.Left, bounds.Top + 3);
4470                                         dc.DrawLine (light, bounds.Left, bounds.Top + 3, bounds.Left + 3, bounds.Top);
4471                                         dc.DrawLine (light, bounds.Left + 3, bounds.Top, bounds.Right, bounds.Top);
4472
4473                                         dc.DrawLine (SystemPens.ControlDark, bounds.Right, bounds.Bottom - 1, bounds.Left + 2, bounds.Bottom - 1);
4474
4475                                         dc.DrawLine (SystemPens.ControlDarkDark, bounds.Right, bounds.Bottom, bounds.Left + 2, bounds.Bottom);
4476                                         dc.DrawLine (SystemPens.ControlDarkDark, bounds.Left + 2, bounds.Bottom, bounds.Left, bounds.Bottom - 3);
4477
4478                                         interior = new Rectangle (bounds.Left + 4, bounds.Top + 4, bounds.Width - 8, bounds.Height - 8);
4479
4480                                         string_format.Alignment = StringAlignment.Center;
4481                                         string_format.LineAlignment = StringAlignment.Center;
4482                                         string_format.FormatFlags = StringFormatFlags.NoWrap;
4483                                         string_format.FormatFlags = StringFormatFlags.DirectionVertical;
4484
4485                                         break;
4486
4487                                 default:
4488                                         // TabAlignment.Right
4489
4490                                         dc.FillRectangle (ResPool.GetSolidBrush (tab.BackColor), bounds);
4491
4492                                         dc.DrawLine (light, bounds.Left, bounds.Top, bounds.Right - 3, bounds.Top);
4493                                         dc.DrawLine (light, bounds.Right - 3, bounds.Top, bounds.Right, bounds.Top + 3);
4494
4495                                         dc.DrawLine (SystemPens.ControlDark, bounds.Right - 1, bounds.Top + 1, bounds.Right - 1, bounds.Bottom - 1);
4496                                         dc.DrawLine (SystemPens.ControlDark, bounds.Left, bounds.Bottom - 1, bounds.Right - 2, bounds.Bottom - 1);
4497
4498                                         dc.DrawLine (SystemPens.ControlDarkDark, bounds.Right, bounds.Top + 3, bounds.Right, bounds.Bottom - 3);
4499                                         dc.DrawLine (SystemPens.ControlDarkDark, bounds.Left, bounds.Bottom, bounds.Right - 3, bounds.Bottom);
4500
4501                                         interior = new Rectangle (bounds.Left + 4, bounds.Top + 4, bounds.Width - 8, bounds.Height - 8);
4502
4503                                         string_format.Alignment = StringAlignment.Center;
4504                                         string_format.LineAlignment = StringAlignment.Center;
4505                                         string_format.FormatFlags = StringFormatFlags.NoWrap;
4506                                         string_format.FormatFlags = StringFormatFlags.DirectionVertical;
4507
4508                                         break;
4509                                 }
4510                         }
4511
4512                         if (tab.DrawMode == TabDrawMode.Normal && page.Text != null) {
4513                                 if (tab.Alignment == TabAlignment.Left) {
4514                                         int wo = interior.Width / 2;
4515                                         int ho = interior.Height / 2;
4516                                         dc.TranslateTransform (interior.X + wo, interior.Y + ho);
4517                                         dc.RotateTransform (180);
4518                                         dc.DrawString (page.Text, page.Font, SystemBrushes.ControlText, 0, 0, string_format);
4519                                         dc.ResetTransform ();
4520                                 } else {
4521                                         Rectangle str_rect = interior;
4522
4523                                         if (tab.ImageList != null && page.ImageIndex >= 0 && page.ImageIndex < tab.ImageList.Images.Count) {
4524                                                 tab.ImageList.Draw (dc, new Point (interior.X, interior.Y), page.ImageIndex);
4525                                                 str_rect.X += tab.ImageList.ImageSize.Width + 2;
4526                                                 str_rect.Width -= tab.ImageList.ImageSize.Width + 2;
4527                                         }
4528                                         dc.DrawString (page.Text, page.Font,
4529                                                        SystemBrushes.ControlText,
4530                                                         str_rect, string_format);
4531                                 }
4532                         } else if (page.Text != null) {
4533                                 DrawItemState state = DrawItemState.None;
4534                                 if (page == tab.SelectedTab)
4535                                         state |= DrawItemState.Selected;
4536                                 DrawItemEventArgs e = new DrawItemEventArgs (dc,
4537                                                 tab.Font, bounds, tab.IndexForTabPage (page),
4538                                                 state, page.ForeColor, page.BackColor);
4539                                 tab.OnDrawItemInternal (e);
4540                                 return res;
4541                         }
4542
4543                         if (page.Parent.Focused && is_selected) {
4544                                 CPDrawFocusRectangle (dc, interior, tab.ForeColor, tab.BackColor);
4545                         }
4546
4547                         return res;
4548                 }
4549
4550                 #region ToolBar
4551                 public  override void DrawToolBar (Graphics dc, Rectangle clip_rectangle, ToolBar control)
4552                 {
4553                         StringFormat format = new StringFormat ();
4554                         format.Trimming = StringTrimming.EllipsisCharacter;
4555                         format.LineAlignment = StringAlignment.Center;
4556                         format.HotkeyPrefix = MenuAccessKeysUnderlined ? HotkeyPrefix.Show : HotkeyPrefix.Hide;
4557                         if (control.TextAlign == ToolBarTextAlign.Underneath)
4558                                 format.Alignment = StringAlignment.Center;
4559                         else
4560                                 format.Alignment = StringAlignment.Near;
4561
4562                         if (control is PropertyGrid.PropertyToolBar) {
4563                                 dc.FillRectangle (ResPool.GetSolidBrush(control.BackColor), clip_rectangle);
4564
4565                                 if (clip_rectangle.X == 0) {
4566                                         dc.DrawLine (SystemPens.ControlLightLight, clip_rectangle.X, 1, clip_rectangle.X, control.Bottom);
4567                                 }
4568
4569                                 if (clip_rectangle.Y < 2) {
4570                                         dc.DrawLine (SystemPens.ControlLightLight, clip_rectangle.X, 1, clip_rectangle.Right, 1);
4571                                 }
4572
4573                                 if (clip_rectangle.Bottom == control.Bottom) {
4574                                         dc.DrawLine (SystemPens.ControlDark, clip_rectangle.X, clip_rectangle.Bottom - 1, clip_rectangle.Right, clip_rectangle.Bottom - 1);
4575                                 }
4576
4577                                 if (clip_rectangle.Right == control.Right) {
4578                                         dc.DrawLine (SystemPens.ControlDark, clip_rectangle.Right - 1, 1, clip_rectangle.Right - 1, control.Bottom - 1);
4579                                 }
4580                         } else {
4581
4582                                 if (control.Appearance == ToolBarAppearance.Flat && control.Parent != null) {
4583                                         if (control.Parent.BackgroundImage != null) {
4584                                                 using (TextureBrush b = new TextureBrush (control.Parent.BackgroundImage, WrapMode.Tile))
4585                                                         dc.FillRectangle (b, clip_rectangle);
4586                                         } else {
4587                                                 dc.FillRectangle (ResPool.GetSolidBrush (control.Parent.BackColor), clip_rectangle);
4588                                         }
4589                                 } else {
4590                                         dc.FillRectangle (SystemBrushes.Control, clip_rectangle);
4591                                 }
4592
4593                                 if (control.Divider && clip_rectangle.Y < 2) {
4594                                         if (clip_rectangle.Y < 1) {
4595                                                 dc.DrawLine (SystemPens.ControlDark, clip_rectangle.X, 0, clip_rectangle.Right, 0);
4596                                         }
4597                                         dc.DrawLine (SystemPens.ControlLightLight, clip_rectangle.X, 1, clip_rectangle.Right, 1);
4598                                 }
4599                         }
4600
4601                         foreach (ToolBarButton button in control.Buttons)
4602                                 if (button.Visible && clip_rectangle.IntersectsWith (button.Rectangle))
4603                                         DrawToolBarButton (dc, control, button, format);
4604
4605                         format.Dispose ();
4606                 }
4607
4608                 protected virtual void DrawToolBarButton (Graphics dc, ToolBar control, ToolBarButton button, StringFormat format)
4609                 {
4610                         bool is_flat = control.Appearance == ToolBarAppearance.Flat;
4611
4612                         DrawToolBarButtonBorder (dc, button, is_flat);
4613
4614                         switch (button.Style) {
4615                         case ToolBarButtonStyle.DropDownButton:
4616                                 if (control.DropDownArrows)
4617                                         DrawToolBarDropDownArrow (dc, button, is_flat);
4618                                 DrawToolBarButtonContents (dc, control, button, format);
4619                                 break;
4620
4621                         case ToolBarButtonStyle.Separator:
4622                                 if (is_flat)
4623                                         DrawToolBarSeparator (dc, button);
4624                                 break;
4625
4626                         case ToolBarButtonStyle.ToggleButton:
4627                                 DrawToolBarToggleButtonBackground (dc, button);
4628                                 DrawToolBarButtonContents (dc, control, button, format);
4629                                 break;
4630
4631                         default:
4632                                 DrawToolBarButtonContents (dc, control, button, format);
4633                                 break;
4634                         }
4635                 }
4636
4637                 const Border3DSide all_sides = Border3DSide.Left | Border3DSide.Top | Border3DSide.Right | Border3DSide.Bottom;
4638
4639                 protected virtual void DrawToolBarButtonBorder (Graphics dc, ToolBarButton button, bool is_flat)
4640                 {
4641                         if (button.Style == ToolBarButtonStyle.Separator)
4642                                 return;
4643
4644                         Border3DStyle style;
4645
4646                         if (is_flat) {
4647                                 if (button.Pushed || button.Pressed)
4648                                         style = Border3DStyle.SunkenOuter;
4649                                 else if (button.Hilight)
4650                                         style = Border3DStyle.RaisedInner;
4651                                 else
4652                                         return;
4653
4654                         } else {
4655                                 if (button.Pushed || button.Pressed)
4656                                         style = Border3DStyle.Sunken;
4657                                 else
4658                                         style = Border3DStyle.Raised;
4659                         }
4660
4661                         Rectangle rect = button.Rectangle;
4662                         if ((button.Style == ToolBarButtonStyle.DropDownButton) && (button.Parent.DropDownArrows) && is_flat)
4663                                 rect.Width -= ToolBarDropDownWidth;
4664
4665                         CPDrawBorder3D (dc, rect, style, all_sides);
4666                 }
4667
4668                 protected virtual void DrawToolBarSeparator (Graphics dc, ToolBarButton button)
4669                 {
4670                         Rectangle area = button.Rectangle;
4671                         int offset = (int) SystemPens.Control.Width + 1;
4672                         dc.DrawLine (SystemPens.ControlDark, area.X + 1, area.Y, area.X + 1, area.Bottom);
4673                         dc.DrawLine (SystemPens.ControlLight, area.X + offset, area.Y, area.X + offset, area.Bottom);
4674                 }
4675
4676                 protected virtual void DrawToolBarToggleButtonBackground (Graphics dc, ToolBarButton button)
4677                 {
4678                         Brush brush;
4679                         Rectangle area = button.Rectangle;
4680                         area.X += ToolBarImageGripWidth;
4681                         area.Y += ToolBarImageGripWidth;
4682                         area.Width -= 2 * ToolBarImageGripWidth;
4683                         area.Height -= 2 * ToolBarImageGripWidth;
4684
4685                         if (button.Pushed)
4686                                 brush = (Brush) ResPool.GetHatchBrush (HatchStyle.Percent50, ColorScrollBar, ColorControlLightLight);
4687                         else if (button.PartialPush)
4688                                 brush = SystemBrushes.ControlLight;
4689                         else
4690                                 brush = SystemBrushes.Control;
4691
4692                         dc.FillRectangle (brush, area);
4693                 }
4694
4695                 protected virtual void DrawToolBarDropDownArrow (Graphics dc, ToolBarButton button, bool is_flat)
4696                 {
4697                         Rectangle rect = button.Rectangle;
4698                         rect.X = button.Rectangle.Right - ToolBarDropDownWidth;
4699                         rect.Width = ToolBarDropDownWidth;
4700
4701                         if (is_flat) {
4702                                 if (button.dd_pressed)
4703                                         CPDrawBorder3D (dc, rect, Border3DStyle.SunkenOuter, all_sides);
4704                                 else if (button.Pushed || button.Pressed)
4705                                         CPDrawBorder3D (dc, rect, Border3DStyle.SunkenOuter, all_sides);
4706                                 else if (button.Hilight)
4707                                         CPDrawBorder3D (dc, rect, Border3DStyle.RaisedInner, all_sides);
4708                         } else {
4709                                 if (button.dd_pressed)
4710                                         CPDrawBorder3D (dc, rect, Border3DStyle.Flat, all_sides);
4711                                 else if (button.Pushed || button.Pressed)
4712                                         CPDrawBorder3D (dc, Rectangle.Inflate(rect, -1, -1), Border3DStyle.SunkenOuter, all_sides);
4713                                 else
4714                                         CPDrawBorder3D (dc, rect, Border3DStyle.Raised, all_sides);
4715                         }
4716
4717                         PointF [] vertices = new PointF [3];
4718                         PointF ddCenter = new PointF (rect.X + (rect.Width/2.0f), rect.Y + (rect.Height / 2));
4719
4720                         // Increase vertical and horizontal position by 1 when button is pressed
4721                         if (button.Pressed || button.Pushed || button.dd_pressed) {
4722                             ddCenter.X += 1;
4723                             ddCenter.Y += 1;
4724                         }
4725
4726                         vertices [0].X = ddCenter.X - ToolBarDropDownArrowWidth / 2.0f + 0.5f;
4727                         vertices [0].Y = ddCenter.Y;
4728                         vertices [1].X = ddCenter.X + ToolBarDropDownArrowWidth / 2.0f + 0.5f;
4729                         vertices [1].Y = ddCenter.Y;
4730                         vertices [2].X = ddCenter.X + 0.5f; // 0.5 is added for adjustment
4731                         vertices [2].Y = ddCenter.Y + ToolBarDropDownArrowHeight;
4732                         dc.FillPolygon (SystemBrushes.ControlText, vertices);
4733                 }
4734
4735                 protected virtual void DrawToolBarButtonContents (Graphics dc, ToolBar control, ToolBarButton button, StringFormat format)
4736                 {
4737                         if (button.Image != null) {
4738                                 int x = button.ImageRectangle.X + ToolBarImageGripWidth;
4739                                 int y = button.ImageRectangle.Y + ToolBarImageGripWidth;
4740
4741                                 // Increase vertical and horizontal position by 1 when button is pressed
4742                                 if (button.Pressed || button.Pushed) {
4743                                     x += 1;
4744                                     y += 1;
4745                                 }
4746
4747                                 if (button.Enabled)
4748                                         dc.DrawImage (button.Image, x, y);
4749                                 else
4750                                         CPDrawImageDisabled (dc, button.Image, x, y, ColorControl);
4751                         }
4752
4753                         Rectangle text_rect = button.TextRectangle;
4754                         if (text_rect.Width <= 0 || text_rect.Height <= 0)
4755                                 return;
4756
4757                         if (button.Pressed || button.Pushed) {
4758                                 text_rect.X += 1;
4759                                 text_rect.Y += 1;
4760                         }
4761
4762                         if (button.Enabled)
4763                                 dc.DrawString (button.Text, control.Font, SystemBrushes.ControlText, text_rect, format);
4764                         else
4765                                 CPDrawStringDisabled (dc, button.Text, control.Font, control.BackColor, text_rect, format);
4766                 }
4767
4768                 // Grip width for the ToolBar
4769                 public override int ToolBarGripWidth {
4770                         get { return 2;}
4771                 }
4772
4773                 // Grip width for the Image on the ToolBarButton
4774                 public override int ToolBarImageGripWidth {
4775                         get { return 2;}
4776                 }
4777
4778                 // width of the separator
4779                 public override int ToolBarSeparatorWidth {
4780                         get { return 4; }
4781                 }
4782
4783                 // width of the dropdown arrow rect
4784                 public override int ToolBarDropDownWidth {
4785                         get { return 13; }
4786                 }
4787
4788                 // width for the dropdown arrow on the ToolBarButton
4789                 public override int ToolBarDropDownArrowWidth {
4790                         get { return 5;}
4791                 }
4792
4793                 // height for the dropdown arrow on the ToolBarButton
4794                 public override int ToolBarDropDownArrowHeight {
4795                         get { return 3;}
4796                 }
4797
4798                 public override Size ToolBarDefaultSize {
4799                         get {
4800                                 return new Size (100, 42);
4801                         }
4802                 }
4803
4804                 #endregion      // ToolBar
4805
4806                 #region ToolTip
4807                 public override void DrawToolTip(Graphics dc, Rectangle clip_rectangle, ToolTip.ToolTipWindow control) {
4808                         dc.FillRectangle(SystemBrushes.Info, control.ClientRectangle);
4809                         dc.DrawRectangle(SystemPens.WindowFrame, 0, 0, control.Width-1, control.Height-1);
4810                         dc.DrawString(control.Text, control.Font, ResPool.GetSolidBrush(this.ColorInfoText), control.ClientRectangle, control.string_format);
4811                 }
4812
4813                 public override Size ToolTipSize(ToolTip.ToolTipWindow tt, string text) {
4814                         SizeF   sizef;
4815
4816                         sizef = tt.DeviceContext.MeasureString(text, tt.Font, SizeF.Empty, tt.string_format);
4817                         return new Size((int)sizef.Width+8, (int)sizef.Height+3);       // Need space for the border
4818                 }
4819                 #endregion      // ToolTip
4820
4821                 #region TrackBar
4822                 private void DrawTrackBar_Vertical (Graphics dc, Rectangle clip_rectangle, TrackBar tb,
4823                         ref Rectangle thumb_pos, ref Rectangle thumb_area,  Brush br_thumb,
4824                         float ticks, int value_pos, bool mouse_value) {
4825
4826                         Point toptick_startpoint = new Point ();
4827                         Point bottomtick_startpoint = new Point ();
4828                         Point channel_startpoint = new Point ();
4829                         float pixel_len;
4830                         float pixels_betweenticks;
4831                         const int space_from_right = 8;
4832                         const int space_from_left = 8;
4833                         const int space_from_bottom = 11;
4834                         Rectangle area = tb.ClientRectangle;
4835
4836                         switch (tb.TickStyle)   {
4837                         case TickStyle.BottomRight:
4838                         case TickStyle.None:
4839                                 channel_startpoint.Y = 8;
4840                                 channel_startpoint.X = 9;
4841                                 bottomtick_startpoint.Y = 13;
4842                                 bottomtick_startpoint.X = 24;
4843                                 break;
4844                         case TickStyle.TopLeft:
4845                                 channel_startpoint.Y = 8;
4846                                 channel_startpoint.X = 19;
4847                                 toptick_startpoint.Y = 13;
4848                                 toptick_startpoint.X = 8;
4849                                 break;
4850                         case TickStyle.Both:
4851                                 channel_startpoint.Y = 8;
4852                                 channel_startpoint.X = 18;
4853                                 bottomtick_startpoint.Y = 13;
4854                                 bottomtick_startpoint.X = 32;
4855                                 toptick_startpoint.Y = 13;
4856                                 toptick_startpoint.X = 8;
4857                                 break;
4858                         default:
4859                                 break;
4860                         }
4861
4862                         thumb_area.X = area.X + channel_startpoint.X;
4863                         thumb_area.Y = area.Y + channel_startpoint.Y;
4864                         thumb_area.Height = area.Height - space_from_right - space_from_left;
4865                         thumb_area.Width = 4;
4866
4867                         /* Draw channel */
4868                         dc.FillRectangle (SystemBrushes.ControlDark, channel_startpoint.X, channel_startpoint.Y,
4869                                 1, thumb_area.Height);
4870
4871                         dc.FillRectangle (SystemBrushes.ControlDarkDark, channel_startpoint.X + 1, channel_startpoint.Y,
4872                                 1, thumb_area.Height);
4873
4874                         dc.FillRectangle (SystemBrushes.ControlLight, channel_startpoint.X + 3, channel_startpoint.Y,
4875                                 1, thumb_area.Height);
4876
4877                         pixel_len = thumb_area.Height - 11;
4878                         pixels_betweenticks = pixel_len / (tb.Maximum - tb.Minimum);
4879
4880                         /* Convert thumb position from mouse position to value*/
4881                         if (mouse_value) {
4882                                 if (tb.mouse_moved) {
4883                                         value_pos += (int) pixels_betweenticks / 2;
4884                                         if (value_pos < thumb_area.Bottom) {
4885                                                 value_pos = (int) ((thumb_area.Bottom - value_pos - (int)(thumb_pos.Width / 2)) / pixels_betweenticks);
4886                                         } else {
4887                                                 value_pos = 0;
4888                                         }
4889
4890                                         if (value_pos + tb.Minimum > tb.Maximum)
4891                                                 value_pos = tb.Maximum - tb.Minimum;
4892                                         else if (value_pos + tb.Minimum < tb.Minimum)
4893                                                 value_pos = 0;
4894
4895                                         tb.Value = value_pos + tb.Minimum;
4896                                 } else {
4897                                         value_pos = tb.Value - tb.Minimum;
4898                                 }
4899                         }
4900
4901                         // thumb_pos.Y = channel_startpoint.Y ; // + (int) (pixels_betweenticks * (float) value_pos);
4902                         thumb_pos.Y = thumb_area.Bottom - space_from_bottom - (int) (pixels_betweenticks * (float) value_pos);
4903
4904                         /* Draw thumb fixed 10x22 size */
4905                         thumb_pos.Width = 10;
4906                         thumb_pos.Height = 22;
4907
4908                         switch (tb.TickStyle)   {
4909                         case TickStyle.BottomRight:
4910                         case TickStyle.None: {
4911                                 thumb_pos.X = channel_startpoint.X - 8;
4912
4913                                 Pen pen = SystemPens.ControlLight;
4914                                 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X , thumb_pos.Y + 10);
4915                                 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X + 16, thumb_pos.Y);
4916                                 dc.DrawLine (pen, thumb_pos.X + 16, thumb_pos.Y, thumb_pos.X + 16 + 4, thumb_pos.Y + 4);
4917
4918                                 pen = SystemPens.ControlDark;
4919                                 dc.DrawLine (pen, thumb_pos.X +1, thumb_pos.Y + 9, thumb_pos.X +15, thumb_pos.Y  +9);
4920                                 dc.DrawLine (pen, thumb_pos.X + 16, thumb_pos.Y + 9, thumb_pos.X +16 + 4, thumb_pos.Y  +9 - 4);
4921
4922                                 pen = SystemPens.ControlDarkDark;
4923                                 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y  + 10, thumb_pos.X +16, thumb_pos.Y +10);
4924                                 dc.DrawLine (pen, thumb_pos.X + 16, thumb_pos.Y  + 10, thumb_pos.X  +16 + 5, thumb_pos.Y +10 - 5);
4925
4926                                 dc.FillRectangle (br_thumb, thumb_pos.X + 1, thumb_pos.Y + 1, 16, 8);
4927                                 dc.FillRectangle (br_thumb, thumb_pos.X + 17, thumb_pos.Y + 2, 1, 6);
4928                                 dc.FillRectangle (br_thumb, thumb_pos.X + 18, thumb_pos.Y + 3, 1, 4);
4929                                 dc.FillRectangle (br_thumb, thumb_pos.X + 19, thumb_pos.Y + 4, 1, 2);
4930
4931                                 break;
4932                         }
4933                         case TickStyle.TopLeft: {
4934                                 thumb_pos.X = channel_startpoint.X - 10;
4935
4936                                 Pen pen = SystemPens.ControlLight;
4937                                 dc.DrawLine (pen, thumb_pos.X + 4, thumb_pos.Y, thumb_pos.X + 4 + 16, thumb_pos.Y);
4938                                 dc.DrawLine (pen, thumb_pos.X + 4, thumb_pos.Y, thumb_pos.X, thumb_pos.Y + 4);
4939
4940                                 pen = SystemPens.ControlDark;
4941                                 dc.DrawLine (pen, thumb_pos.X  + 4, thumb_pos.Y + 9, thumb_pos.X + 4 + 16 , thumb_pos.Y+ 9);
4942                                 dc.DrawLine (pen, thumb_pos.X + 4, thumb_pos.Y  + 9, thumb_pos.X, thumb_pos.Y + 5);
4943                                 dc.DrawLine (pen, thumb_pos.X  + 19, thumb_pos.Y + 9, thumb_pos.X  +19 , thumb_pos.Y+ 1);
4944
4945                                 pen = SystemPens.ControlDarkDark;
4946                                 dc.DrawLine (pen, thumb_pos.X  + 4, thumb_pos.Y+ 10, thumb_pos.X  + 4 + 16, thumb_pos.Y+ 10);
4947                                 dc.DrawLine (pen, thumb_pos.X  + 4, thumb_pos.Y + 10, thumb_pos.X  -1, thumb_pos.Y+ 5);
4948                                 dc.DrawLine (pen, thumb_pos.X + 20, thumb_pos.Y, thumb_pos.X+ 20, thumb_pos.Y + 10);
4949
4950                                 dc.FillRectangle (br_thumb, thumb_pos.X + 4, thumb_pos.Y + 1, 15, 8);
4951                                 dc.FillRectangle (br_thumb, thumb_pos.X + 3, thumb_pos.Y + 2, 1, 6);
4952                                 dc.FillRectangle (br_thumb, thumb_pos.X + 2, thumb_pos.Y + 3, 1, 4);
4953                                 dc.FillRectangle (br_thumb, thumb_pos.X + 1, thumb_pos.Y + 4, 1, 2);
4954
4955                                 break;
4956                         }
4957
4958                         case TickStyle.Both: {
4959                                 thumb_pos.X = area.X + 10;
4960
4961                                 Pen pen = SystemPens.ControlLight;
4962                                 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X, thumb_pos.Y + 9);
4963                                 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X + 19, thumb_pos.Y);
4964
4965                                 pen = SystemPens.ControlDark;
4966                                 dc.DrawLine (pen, thumb_pos.X + 1, thumb_pos.Y + 9, thumb_pos.X+ 19, thumb_pos.Y  + 9);
4967                                 dc.DrawLine (pen, thumb_pos.X  + 10, thumb_pos.Y+ 1, thumb_pos.X + 19, thumb_pos.Y  + 8);
4968
4969                                 pen = SystemPens.ControlDarkDark;
4970                                 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 10, thumb_pos.X+ 20, thumb_pos.Y  +10);
4971                                 dc.DrawLine (pen, thumb_pos.X  + 20, thumb_pos.Y, thumb_pos.X  + 20, thumb_pos.Y+ 9);
4972
4973                                 dc.FillRectangle (br_thumb, thumb_pos.X + 1, thumb_pos.Y + 1, 18, 8);
4974
4975                                 break;
4976                         }
4977
4978                         default:
4979                                 break;
4980                         }
4981
4982                         pixel_len = thumb_area.Height - 11;
4983                         pixels_betweenticks = pixel_len / ticks;
4984
4985                         thumb_area.X = thumb_pos.X;
4986                         thumb_area.Y = channel_startpoint.Y;
4987                         thumb_area.Width = thumb_pos.Height;
4988
4989                         /* Draw ticks*/
4990                         Region outside = new Region (area);
4991                         outside.Exclude (thumb_area);
4992
4993                         if (outside.IsVisible (clip_rectangle)) {
4994                                 if (pixels_betweenticks > 0 && ((tb.TickStyle & TickStyle.BottomRight) == TickStyle.BottomRight ||
4995                                         ((tb.TickStyle & TickStyle.Both) == TickStyle.Both))) {
4996
4997                                         for (float inc = 0; inc < (pixel_len + 1); inc += pixels_betweenticks)  {
4998                                                 if (inc == 0 || (inc +  pixels_betweenticks) >= pixel_len +1)
4999                                                         dc.DrawLine (ResPool.GetPen (pen_ticks_color), area.X + bottomtick_startpoint.X , area.Y + bottomtick_startpoint.Y  + inc,
5000                                                                 area.X + bottomtick_startpoint.X  + 3, area.Y + bottomtick_startpoint.Y + inc);
5001                                                 else
5002                                                         dc.DrawLine (ResPool.GetPen (pen_ticks_color), area.X + bottomtick_startpoint.X, area.Y + bottomtick_startpoint.Y  + inc,
5003                                                                 area.X + bottomtick_startpoint.X  + 2, area.Y + bottomtick_startpoint.Y + inc);
5004                                         }
5005                                 }
5006
5007                                 if (pixels_betweenticks > 0 &&  ((tb.TickStyle & TickStyle.TopLeft) == TickStyle.TopLeft ||
5008                                         ((tb.TickStyle & TickStyle.Both) == TickStyle.Both))) {
5009
5010                                         pixel_len = thumb_area.Height - 11;
5011                                         pixels_betweenticks = pixel_len / ticks;
5012
5013                                         for (float inc = 0; inc < (pixel_len + 1); inc += pixels_betweenticks) {
5014                                                 if (inc == 0 || (inc +  pixels_betweenticks) >= pixel_len +1)
5015                                                         dc.DrawLine (ResPool.GetPen (pen_ticks_color), area.X + toptick_startpoint.X  - 3 , area.Y + toptick_startpoint.Y + inc,
5016                                                                 area.X + toptick_startpoint.X, area.Y + toptick_startpoint.Y + inc);
5017                                                 else
5018                                                         dc.DrawLine (ResPool.GetPen (pen_ticks_color), area.X + toptick_startpoint.X  - 2, area.Y + toptick_startpoint.Y + inc,
5019                                                                 area.X + toptick_startpoint.X, area.Y + toptick_startpoint.Y  + inc);
5020                                         }
5021                                 }
5022                         }
5023
5024                         outside.Dispose ();
5025
5026                 }
5027
5028                 /*
5029                         Horizontal trackbar
5030
5031                         Does not matter the size of the control, Win32 always draws:
5032                                 - Ticks starting from pixel 13, 8
5033                                 - Channel starting at pos 8, 19 and ends at Width - 8
5034                                 - Autosize makes always the control 45 pixels high
5035                                 - Ticks are draw at (channel.Witdh - 10) / (Maximum - Minimum)
5036
5037                 */
5038                 private void DrawTrackBar_Horizontal (Graphics dc, Rectangle clip_rectangle, TrackBar tb,
5039                         ref Rectangle thumb_pos, ref Rectangle thumb_area, Brush br_thumb,
5040                         float ticks, int value_pos, bool mouse_value) {
5041                         Point toptick_startpoint = new Point ();
5042                         Point bottomtick_startpoint = new Point ();
5043                         Point channel_startpoint = new Point ();
5044                         float pixel_len;
5045                         float pixels_betweenticks;
5046                         const int space_from_right = 8;
5047                         const int space_from_left = 8;
5048                         Rectangle area = tb.ClientRectangle;
5049
5050                         switch (tb.TickStyle) {
5051                         case TickStyle.BottomRight:
5052                         case TickStyle.None:
5053                                 channel_startpoint.X = 8;
5054                                 channel_startpoint.Y = 9;
5055                                 bottomtick_startpoint.X = 13;
5056                                 bottomtick_startpoint.Y = 24;
5057                                 break;
5058                         case TickStyle.TopLeft:
5059                                 channel_startpoint.X = 8;
5060                                 channel_startpoint.Y = 19;
5061                                 toptick_startpoint.X = 13;
5062                                 toptick_startpoint.Y = 8;
5063                                 break;
5064                         case TickStyle.Both:
5065                                 channel_startpoint.X = 8;
5066                                 channel_startpoint.Y = 18;
5067                                 bottomtick_startpoint.X = 13;
5068                                 bottomtick_startpoint.Y = 32;
5069                                 toptick_startpoint.X = 13;
5070                                 toptick_startpoint.Y = 8;
5071                                 break;
5072                         default:
5073                                 break;
5074                         }
5075
5076                         thumb_area.X = area.X + channel_startpoint.X;
5077                         thumb_area.Y = area.Y + channel_startpoint.Y;
5078                         thumb_area.Width = area.Width - space_from_right - space_from_left;
5079                         thumb_area.Height = 4;
5080
5081                         /* Draw channel */
5082                         dc.FillRectangle (SystemBrushes.ControlDark, channel_startpoint.X, channel_startpoint.Y,
5083                                 thumb_area.Width, 1);
5084
5085                         dc.FillRectangle (SystemBrushes.ControlDarkDark, channel_startpoint.X, channel_startpoint.Y + 1,
5086                                 thumb_area.Width, 1);
5087
5088                         dc.FillRectangle (SystemBrushes.ControlLight, channel_startpoint.X, channel_startpoint.Y +3,
5089                                 thumb_area.Width, 1);
5090
5091                         pixel_len = thumb_area.Width - 11;
5092                         pixels_betweenticks = pixel_len / (tb.Maximum - tb.Minimum);
5093
5094                         /* Convert thumb position from mouse position to value*/
5095                         if (mouse_value) {
5096                                 if (tb.mouse_moved) {
5097                                         value_pos += (int) pixels_betweenticks / 2;
5098                                         if (value_pos >= channel_startpoint.X) {
5099                                                 value_pos = (int)(((float) (value_pos - channel_startpoint.X - (int)(thumb_pos.Width / 2))) / pixels_betweenticks);
5100                                         } else
5101                                                 value_pos = 0;
5102
5103                                         if (value_pos + tb.Minimum > tb.Maximum)
5104                                                 value_pos = tb.Maximum - tb.Minimum;
5105                                         else if(value_pos + tb.Minimum < tb.Minimum)
5106                                                 value_pos = 0;
5107
5108                                         tb.Value = value_pos + tb.Minimum;
5109                                 } else {
5110                                         value_pos = tb.Value - tb.Minimum;
5111                                 }
5112                         }
5113
5114                         thumb_pos.X = channel_startpoint.X + (int) (pixels_betweenticks * (float) value_pos);
5115
5116                         /* Draw thumb fixed 10x22 size */
5117                         thumb_pos.Width = 10;
5118                         thumb_pos.Height = 22;
5119
5120                         switch (tb.TickStyle) {
5121                         case TickStyle.BottomRight:
5122                         case TickStyle.None: {
5123                                 thumb_pos.Y = channel_startpoint.Y - 8;
5124
5125                                 Pen pen = SystemPens.ControlLight;
5126                                 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X + 10, thumb_pos.Y);
5127                                 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X, thumb_pos.Y + 16);
5128                                 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 16, thumb_pos.X + 4, thumb_pos.Y + 16 + 4);
5129
5130                                 pen = SystemPens.ControlDark;
5131                                 dc.DrawLine (pen, thumb_pos.X + 9, thumb_pos.Y + 1, thumb_pos.X +9, thumb_pos.Y +15);
5132                                 dc.DrawLine (pen, thumb_pos.X + 9, thumb_pos.Y + 16, thumb_pos.X +9 - 4, thumb_pos.Y +16 + 4);
5133
5134                                 pen = SystemPens.ControlDarkDark;
5135                                 dc.DrawLine (pen, thumb_pos.X + 10, thumb_pos.Y, thumb_pos.X +10, thumb_pos.Y +16);
5136                                 dc.DrawLine (pen, thumb_pos.X + 10, thumb_pos.Y + 16, thumb_pos.X +10 - 5, thumb_pos.Y +16 + 5);
5137
5138                                 dc.FillRectangle (br_thumb, thumb_pos.X + 1, thumb_pos.Y + 1, 8, 16);
5139                                 dc.FillRectangle (br_thumb, thumb_pos.X + 2, thumb_pos.Y + 17, 6, 1);
5140                                 dc.FillRectangle (br_thumb, thumb_pos.X + 3, thumb_pos.Y + 18, 4, 1);
5141                                 dc.FillRectangle (br_thumb, thumb_pos.X + 4, thumb_pos.Y + 19, 2, 1);
5142                                 break;
5143                         }
5144                         case TickStyle.TopLeft: {
5145                                 thumb_pos.Y = channel_startpoint.Y - 10;
5146
5147                                 Pen pen = SystemPens.ControlLight;
5148                                 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 4, thumb_pos.X, thumb_pos.Y + 4 + 16);
5149                                 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 4, thumb_pos.X + 4, thumb_pos.Y);
5150
5151                                 pen = SystemPens.ControlDark;
5152                                 dc.DrawLine (pen, thumb_pos.X + 9, thumb_pos.Y + 4, thumb_pos.X + 9, thumb_pos.Y + 4 + 16);
5153                                 dc.DrawLine (pen, thumb_pos.X + 9, thumb_pos.Y + 4, thumb_pos.X + 5, thumb_pos.Y);
5154                                 dc.DrawLine (pen, thumb_pos.X + 9, thumb_pos.Y + 19, thumb_pos.X + 1 , thumb_pos.Y +19);
5155
5156                                 pen = SystemPens.ControlDarkDark;
5157                                 dc.DrawLine (pen, thumb_pos.X + 10, thumb_pos.Y + 4, thumb_pos.X + 10, thumb_pos.Y + 4 + 16);
5158                                 dc.DrawLine (pen, thumb_pos.X + 10, thumb_pos.Y + 4, thumb_pos.X + 5, thumb_pos.Y -1);
5159                                 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 20, thumb_pos.X + 10, thumb_pos.Y + 20);
5160
5161                                 dc.FillRectangle (br_thumb, thumb_pos.X + 1, thumb_pos.Y + 4, 8, 15);
5162                                 dc.FillRectangle (br_thumb, thumb_pos.X + 2, thumb_pos.Y + 3, 6, 1);
5163                                 dc.FillRectangle (br_thumb, thumb_pos.X + 3, thumb_pos.Y + 2, 4, 1);
5164                                 dc.FillRectangle (br_thumb, thumb_pos.X + 4, thumb_pos.Y + 1, 2, 1);
5165                                 break;
5166                         }
5167
5168                         case TickStyle.Both: {
5169                                 thumb_pos.Y = area.Y + 10;
5170
5171                                 Pen pen = SystemPens.ControlLight;
5172                                 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X + 9, thumb_pos.Y);
5173                                 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X, thumb_pos.Y + 19);
5174
5175                                 pen = SystemPens.ControlDark;
5176                                 dc.DrawLine (pen, thumb_pos.X + 9, thumb_pos.Y + 1, thumb_pos.X + 9, thumb_pos.Y + 19);
5177                                 dc.DrawLine (pen, thumb_pos.X + 1, thumb_pos.Y + 10, thumb_pos.X + 8, thumb_pos.Y + 19);
5178
5179                                 pen = SystemPens.ControlDarkDark;
5180                                 dc.DrawLine (pen, thumb_pos.X + 10, thumb_pos.Y, thumb_pos.X +10, thumb_pos.Y + 20);
5181                                 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 20, thumb_pos.X + 9, thumb_pos.Y + 20);
5182
5183                                 dc.FillRectangle (br_thumb, thumb_pos.X + 1, thumb_pos.Y + 1, 8, 18);
5184
5185                                 break;
5186                         }
5187
5188                         default:
5189                                 break;
5190                         }
5191
5192                         pixel_len = thumb_area.Width - 11;
5193                         pixels_betweenticks = pixel_len / ticks;
5194
5195                         /* Draw ticks*/
5196                         thumb_area.Y = thumb_pos.Y;
5197                         thumb_area.X = channel_startpoint.X;
5198                         thumb_area.Height = thumb_pos.Height;
5199                         Region outside = new Region (area);
5200                         outside.Exclude (thumb_area);
5201
5202                         if (outside.IsVisible (clip_rectangle)) {
5203                                 if (pixels_betweenticks > 0 && ((tb.TickStyle & TickStyle.BottomRight) == TickStyle.BottomRight ||
5204                                         ((tb.TickStyle & TickStyle.Both) == TickStyle.Both))) {
5205
5206                                         for (float inc = 0; inc < (pixel_len + 1); inc += pixels_betweenticks) {
5207                                                 if (inc == 0 || (inc +  pixels_betweenticks) >= pixel_len +1)
5208                                                         dc.DrawLine (ResPool.GetPen (pen_ticks_color), area.X + bottomtick_startpoint.X + inc , area.Y + bottomtick_startpoint.Y,
5209                                                                 area.X + bottomtick_startpoint.X + inc , area.Y + bottomtick_startpoint.Y + 3);
5210                                                 else
5211                                                         dc.DrawLine (ResPool.GetPen (pen_ticks_color), area.X + bottomtick_startpoint.X + inc, area.Y + bottomtick_startpoint.Y,
5212                                                                 area.X + bottomtick_startpoint.X + inc, area.Y + bottomtick_startpoint.Y + 2);
5213                                         }
5214                                 }
5215
5216                                 if (pixels_betweenticks > 0 && ((tb.TickStyle & TickStyle.TopLeft) == TickStyle.TopLeft ||
5217                                         ((tb.TickStyle & TickStyle.Both) == TickStyle.Both))) {
5218
5219                                         for (float inc = 0; inc < (pixel_len + 1); inc += pixels_betweenticks) {
5220                                                 if (inc == 0 || (inc +  pixels_betweenticks) >= pixel_len +1)
5221                                                         dc.DrawLine (ResPool.GetPen (pen_ticks_color), area.X + toptick_startpoint.X + inc , area.Y + toptick_startpoint.Y - 3,
5222                                                                 area.X + toptick_startpoint.X + inc , area.Y + toptick_startpoint.Y);
5223                                                 else
5224                                                         dc.DrawLine (ResPool.GetPen (pen_ticks_color), area.X + toptick_startpoint.X + inc, area.Y + toptick_startpoint.Y - 2,
5225                                                                 area.X + toptick_startpoint.X + inc, area.Y + toptick_startpoint.Y );
5226                                         }
5227                                 }
5228                         }
5229
5230                         outside.Dispose ();
5231                 }
5232
5233                 public override void DrawTrackBar (Graphics dc, Rectangle clip_rectangle, TrackBar tb)
5234                 {
5235                         Brush           br_thumb;
5236                         int             value_pos;
5237                         bool            mouse_value;
5238                         float           ticks = (tb.Maximum - tb.Minimum) / tb.tickFrequency; /* N of ticks draw*/
5239                         Rectangle       area;
5240                         Rectangle       thumb_pos = tb.ThumbPos;
5241                         Rectangle       thumb_area = tb.ThumbArea;
5242
5243                         if (tb.thumb_pressed) {
5244                                 value_pos = tb.thumb_mouseclick;
5245                                 mouse_value = true;
5246                         } else {
5247                                 value_pos = tb.Value - tb.Minimum;
5248                                 mouse_value = false;
5249                         }
5250
5251                         area = tb.ClientRectangle;
5252
5253                         if (!tb.Enabled) {
5254                                 br_thumb = (Brush) ResPool.GetHatchBrush (HatchStyle.Percent50, ColorControlLightLight, ColorControlLight);
5255                         } else if (tb.thumb_pressed == true) {
5256                                 br_thumb = (Brush) ResPool.GetHatchBrush (HatchStyle.Percent50, ColorControlLight, ColorControl);
5257                         } else {
5258                                 br_thumb = SystemBrushes.Control;
5259                         }
5260
5261
5262                         /* Control Background */
5263                         if (tb.BackColor.ToArgb () == DefaultControlBackColor.ToArgb ()) {
5264                                 dc.FillRectangle (SystemBrushes.Control, clip_rectangle);
5265                         } else {
5266                                 dc.FillRectangle (ResPool.GetSolidBrush (tb.BackColor), clip_rectangle);
5267                         }
5268
5269                         if (tb.Focused) {
5270                                 CPDrawFocusRectangle(dc, area, tb.ForeColor, tb.BackColor);
5271                         }
5272
5273                         if (tb.Orientation == Orientation.Vertical) {
5274                                 DrawTrackBar_Vertical (dc, clip_rectangle, tb, ref thumb_pos, ref thumb_area,
5275                                         br_thumb, ticks, value_pos, mouse_value);
5276
5277                         } else {
5278                                 DrawTrackBar_Horizontal (dc, clip_rectangle, tb, ref thumb_pos, ref thumb_area,
5279                                         br_thumb, ticks, value_pos, mouse_value);
5280                         }
5281
5282                         tb.ThumbPos = thumb_pos;
5283                         tb.ThumbArea = thumb_area;
5284                 }
5285
5286                 public override Size TrackBarDefaultSize {
5287                         get {
5288                                 return new Size (104, 42);
5289                         }
5290                 }
5291
5292                 #endregion      // TrackBar
5293
5294                 #region VScrollBar
5295                 public override Size VScrollBarDefaultSize {
5296                         get {
5297                                 return new Size (this.ScrollBarButtonSize, 80);
5298                         }
5299                 }
5300                 #endregion      // VScrollBar
5301
5302                 #region TreeView
5303                 public override Size TreeViewDefaultSize {
5304                         get {
5305                                 return new Size (121, 97);
5306                         }
5307                 }
5308
5309                 #endregion
5310
5311                 public override int ManagedWindowTitleBarHeight (InternalWindowManager wm)
5312                 {
5313                         if (wm.IsToolWindow && !wm.IsMinimized)
5314                                 return SystemInformation.ToolWindowCaptionHeight;
5315                         if (wm.Form.FormBorderStyle == FormBorderStyle.None)
5316                                 return 0;
5317                         return SystemInformation.CaptionHeight;
5318                 }
5319
5320                 public override int ManagedWindowBorderWidth (InternalWindowManager wm)
5321                 {
5322                         return 4;
5323                 }
5324
5325                 public override int ManagedWindowIconWidth (InternalWindowManager wm)
5326                 {
5327                         return ManagedWindowTitleBarHeight (wm) - 5;
5328                 }
5329
5330                 public override void ManagedWindowSetButtonLocations (InternalWindowManager wm)
5331                 {
5332                         TitleButtons buttons = wm.TitleButtons;
5333                         Form form = wm.form;
5334
5335                         buttons.HelpButton.Visible = form.HelpButton;
5336
5337                         foreach (TitleButton button in buttons) {
5338                                 button.Visible = false;
5339                         }
5340
5341                         switch (form.FormBorderStyle) {
5342                         case FormBorderStyle.None:
5343                                 if (form.WindowState != FormWindowState.Normal)
5344                                         goto case FormBorderStyle.Sizable;
5345                                 break;
5346                         case FormBorderStyle.FixedToolWindow:
5347                         case FormBorderStyle.SizableToolWindow:
5348                                 buttons.CloseButton.Visible = true;
5349                                 if (form.WindowState != FormWindowState.Normal)
5350                                         goto case FormBorderStyle.Sizable;
5351                                 break;
5352                         case FormBorderStyle.FixedSingle:
5353                         case FormBorderStyle.Fixed3D:
5354                         case FormBorderStyle.FixedDialog:
5355                         case FormBorderStyle.Sizable:
5356                                 switch (form.WindowState) {
5357                                         case FormWindowState.Normal:
5358                                                 buttons.MinimizeButton.Visible = true;
5359                                                 buttons.MaximizeButton.Visible = true;
5360                                                 buttons.RestoreButton.Visible = false;
5361                                                 break;
5362                                         case FormWindowState.Maximized:
5363                                                 buttons.MinimizeButton.Visible = true;
5364                                                 buttons.MaximizeButton.Visible = false;
5365                                                 buttons.RestoreButton.Visible = true;
5366                                                 break;
5367                                         case FormWindowState.Minimized:
5368                                                 buttons.MinimizeButton.Visible = false;
5369                                                 buttons.MaximizeButton.Visible = true;
5370                                                 buttons.RestoreButton.Visible = true;
5371                                                 break;
5372                                 }
5373                                 buttons.CloseButton.Visible = true;
5374                                 break;
5375                         }
5376
5377                         int bw = ManagedWindowBorderWidth (wm);
5378                         Size btsize = ManagedWindowButtonSize (wm);
5379                         int btw = btsize.Width;
5380                         int bth = btsize.Height;
5381                         int top = bw + 2;
5382                         int left = form.Width - bw - btw - 2;
5383
5384                         if ((!wm.IsToolWindow || wm.IsMinimized) && wm.HasBorders) {
5385                                 buttons.CloseButton.Rectangle = new Rectangle (left, top, btw, bth);
5386                                 left -= 2 + btw;
5387
5388                                 if (buttons.MaximizeButton.Visible) {
5389                                         buttons.MaximizeButton.Rectangle = new Rectangle (left, top, btw, bth);
5390                                         left -= 2 + btw;
5391                                 }
5392                                 if (buttons.RestoreButton.Visible) {
5393                                         buttons.RestoreButton.Rectangle = new Rectangle (left, top, btw, bth);
5394                                         left -= 2 + btw;
5395                                 }
5396
5397                                 buttons.MinimizeButton.Rectangle = new Rectangle (left, top, btw, bth);
5398                                 left -= 2 + btw;
5399                         } else if (wm.IsToolWindow) {
5400                                 buttons.CloseButton.Rectangle = new Rectangle (left, top, btw, bth);
5401                                 left -= 2 + btw;
5402                         }
5403                 }
5404
5405                 public override void DrawManagedWindowDecorations (Graphics dc, Rectangle clip, InternalWindowManager wm)
5406                 {
5407                         Form form = wm.Form;
5408                         int tbheight = ManagedWindowTitleBarHeight (wm);
5409                         int bdwidth = ManagedWindowBorderWidth (wm);
5410                         Color titlebar_color = Color.FromArgb (255, 10, 36, 106);
5411                         Color titlebar_color2 = Color.FromArgb (255, 166, 202, 240);
5412                         Color color = ThemeEngine.Current.ColorControlDark;
5413                         Color color2 = Color.FromArgb (255, 192, 192, 192);
5414
5415 #if debug
5416                         Console.WriteLine (DateTime.Now.ToLongTimeString () + " DrawManagedWindowDecorations");
5417                         dc.FillRectangle (Brushes.Black, clip);
5418 #endif
5419
5420                         if (wm.HasBorders) {
5421                                 Pen pen = ResPool.GetPen (ColorControl);
5422                                 Rectangle borders = new Rectangle (0, 0, form.Width, form.Height);
5423                                 ControlPaint.DrawBorder3D (dc, borders, Border3DStyle.Raised);
5424                                 // The 3d border is only 2 pixels wide, so we draw the innermost pixels ourselves
5425                                 borders = new Rectangle (2, 2, form.Width - 5, form.Height - 5);
5426                                 for (int i = 2; i < bdwidth; i++) {
5427                                         dc.DrawRectangle (pen, borders);
5428                                         borders.Inflate (-1, -1);
5429                                 }
5430                         }
5431
5432
5433                         bool draw_titlebar_enabled = false;
5434                         if (wm.Form.Parent != null && wm.Form.Parent is Form) {
5435                                 draw_titlebar_enabled = false;
5436                         } else if (wm.IsActive && !wm.IsMaximized) {
5437                                 draw_titlebar_enabled = true;
5438                         }
5439                         if (draw_titlebar_enabled) {
5440                                 color = titlebar_color;
5441                                 color2 = titlebar_color2;
5442                         }
5443
5444                         Rectangle tb = new Rectangle (bdwidth, bdwidth, form.Width - (bdwidth * 2), tbheight - 1);
5445
5446                         // HACK: For now always draw the titlebar until we get updates better
5447                         if (tb.Width > 0 && tb.Height > 0) {
5448                                 using (System.Drawing.Drawing2D.LinearGradientBrush gradient = new LinearGradientBrush (tb, color, color2, LinearGradientMode.Horizontal))
5449                                 {
5450                                         dc.FillRectangle (gradient, tb);
5451                                 }
5452                         }
5453
5454                         // Draw the line just beneath the title bar
5455                         dc.DrawLine (ResPool.GetPen (SystemColors.Control), bdwidth,
5456                                         tbheight + bdwidth - 1, form.Width - bdwidth - 1,
5457                                         tbheight + bdwidth - 1);
5458
5459                         if (!wm.IsToolWindow) {
5460                                 tb.X += 18; // Room for the icon and the buttons
5461                                 tb.Width = (form.Width - 62) - tb.X;
5462                         }
5463
5464                         if (form.Text != null && form.Text != string.Empty) {
5465                                 StringFormat format = new StringFormat ();
5466                                 format.FormatFlags = StringFormatFlags.NoWrap;
5467                                 format.Trimming = StringTrimming.EllipsisCharacter;
5468                                 format.LineAlignment = StringAlignment.Center;
5469
5470                                 if (tb.IntersectsWith (clip))
5471                                         dc.DrawString (form.Text, WindowBorderFont,
5472                                                 ThemeEngine.Current.ResPool.GetSolidBrush (Color.White),
5473                                                 tb, format);
5474                         }
5475
5476                         if (wm.HasBorders) {
5477                                 bool draw_icon = false;
5478 #if NET_2_0
5479                                 draw_icon = !wm.IsToolWindow && form.Icon != null && form.ShowIcon;
5480 #else
5481                                 draw_icon = !wm.IsToolWindow && form.Icon != null;
5482 #endif
5483                                 if (draw_icon) {
5484                                         Rectangle icon = new Rectangle (bdwidth + 3,
5485                                                         bdwidth + 2, wm.IconWidth, wm.IconWidth);
5486                                         if (icon.IntersectsWith (clip))
5487                                                 dc.DrawIcon (form.Icon, icon);
5488                                 }
5489
5490                                 foreach (TitleButton button in wm.TitleButtons.AllButtons) {
5491                                         DrawTitleButton (dc, button, clip);
5492                                 }
5493                         }
5494                 }
5495
5496                 public override Size ManagedWindowButtonSize (InternalWindowManager wm)
5497                 {
5498                         int height = ManagedWindowTitleBarHeight (wm);
5499                         if (!wm.IsMaximized && !wm.IsMinimized) {
5500                                 if (wm.IsToolWindow)
5501                                         return new Size (SystemInformation.ToolWindowCaptionButtonSize.Width - 2,
5502                                                         height - 5);
5503                                 if (wm.Form.FormBorderStyle == FormBorderStyle.None)
5504                                         return Size.Empty;
5505                         } else
5506                                 height = SystemInformation.CaptionHeight;
5507
5508                         return new Size (SystemInformation.CaptionButtonSize.Width - 2,
5509                                         height - 5);
5510                 }
5511
5512                 private void DrawTitleButton (Graphics dc, TitleButton button, Rectangle clip)
5513                 {
5514                         if (!button.Visible) {
5515                                 return;
5516                         }
5517
5518                         if (!button.Rectangle.IntersectsWith (clip))
5519                                 return;
5520
5521                         dc.FillRectangle (SystemBrushes.Control, button.Rectangle);
5522
5523                         ControlPaint.DrawCaptionButton (dc, button.Rectangle,
5524                                         button.Caption, button.State);
5525                 }
5526
5527                 #region ControlPaint
5528                 public override void CPDrawBorder (Graphics graphics, Rectangle bounds, Color leftColor, int leftWidth,
5529                         ButtonBorderStyle leftStyle, Color topColor, int topWidth, ButtonBorderStyle topStyle,
5530                         Color rightColor, int rightWidth, ButtonBorderStyle rightStyle, Color bottomColor,
5531                         int bottomWidth, ButtonBorderStyle bottomStyle) {
5532                         DrawBorderInternal(graphics, bounds.Left, bounds.Top, bounds.Left, bounds.Bottom-1, leftWidth, leftColor, leftStyle, Border3DSide.Left);
5533                         DrawBorderInternal(graphics, bounds.Left, bounds.Top, bounds.Right-1, bounds.Top, topWidth, topColor, topStyle, Border3DSide.Top);
5534                         DrawBorderInternal(graphics, bounds.Right-1, bounds.Top, bounds.Right-1, bounds.Bottom-1, rightWidth, rightColor, rightStyle, Border3DSide.Right);
5535                         DrawBorderInternal(graphics, bounds.Left, bounds.Bottom-1, bounds.Right-1, bounds.Bottom-1, bottomWidth, bottomColor, bottomStyle, Border3DSide.Bottom);
5536                 }
5537
5538                 public override void CPDrawBorder3D (Graphics graphics, Rectangle rectangle, Border3DStyle style, Border3DSide sides) {
5539                         CPDrawBorder3D(graphics, rectangle, style, sides, ColorControl);
5540                 }
5541
5542                 protected virtual void CPDrawBorder3D (Graphics graphics, Rectangle rectangle, Border3DStyle style, Border3DSide sides, Color control_color)
5543                 {
5544                         Pen             penTopLeft;
5545                         Pen             penTopLeftInner;
5546                         Pen             penBottomRight;
5547                         Pen             penBottomRightInner;
5548                         Rectangle       rect= new Rectangle (rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
5549                         bool is_ColorControl = control_color.ToArgb () == ColorControl.ToArgb () ? true : false;
5550
5551                         if ((style & Border3DStyle.Adjust) != 0) {
5552                                 rect.Y -= 2;
5553                                 rect.X -= 2;
5554                                 rect.Width += 4;
5555                                 rect.Height += 4;
5556                         }
5557
5558                         penTopLeft = penTopLeftInner = penBottomRight = penBottomRightInner = is_ColorControl ? SystemPens.Control : ResPool.GetPen (control_color);
5559
5560                         CPColor cpcolor = CPColor.Empty;
5561
5562                         if (!is_ColorControl)
5563                                 cpcolor = ResPool.GetCPColor (control_color);
5564
5565                         switch (style) {
5566                         case Border3DStyle.Raised:
5567                                 penTopLeftInner = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
5568                                 penBottomRight = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
5569                                 penBottomRightInner = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
5570                                 break;
5571                         case Border3DStyle.Sunken:
5572                                 penTopLeft = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
5573                                 penTopLeftInner = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
5574                                 penBottomRight = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
5575                                 break;
5576                         case Border3DStyle.Etched:
5577                                 penTopLeft = penBottomRightInner = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
5578                                 penTopLeftInner = penBottomRight = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
5579                                 break;
5580                         case Border3DStyle.RaisedOuter:
5581                                 penBottomRight = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
5582                                 break;
5583                         case Border3DStyle.SunkenOuter:
5584                                 penTopLeft = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
5585                                 penBottomRight = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
5586                                 break;
5587                         case Border3DStyle.RaisedInner:
5588                                 penTopLeft = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
5589                                 penBottomRight = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
5590                                 break;
5591                         case Border3DStyle.SunkenInner:
5592                                 penTopLeft = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
5593                                 break;
5594                         case Border3DStyle.Flat:
5595                                 penTopLeft = penBottomRight = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
5596                                 break;
5597                         case Border3DStyle.Bump:
5598                                 penTopLeftInner = penBottomRight = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
5599                                 break;
5600                         default:
5601                                 break;
5602                         }
5603
5604                         bool inner = ((style != Border3DStyle.RaisedOuter) && (style != Border3DStyle.SunkenOuter));
5605
5606                         if ((sides & Border3DSide.Middle) != 0) {
5607                                 Brush brush = is_ColorControl ? SystemBrushes.Control : ResPool.GetSolidBrush (control_color);
5608                                 graphics.FillRectangle (brush, rect);
5609                         }
5610
5611                         if ((sides & Border3DSide.Left) != 0) {
5612                                 graphics.DrawLine (penTopLeft, rect.Left, rect.Bottom - 2, rect.Left, rect.Top);
5613                                 if ((rect.Width > 2) && inner)
5614                                         graphics.DrawLine (penTopLeftInner, rect.Left + 1, rect.Bottom - 2, rect.Left + 1, rect.Top);
5615                         }
5616
5617                         if ((sides & Border3DSide.Top) != 0) {
5618                                 graphics.DrawLine (penTopLeft, rect.Left, rect.Top, rect.Right - 2, rect.Top);
5619                                 if ((rect.Height > 2) && inner)
5620                                         graphics.DrawLine (penTopLeftInner, rect.Left + 1, rect.Top + 1, rect.Right - 3, rect.Top + 1);
5621                         }
5622
5623                         if ((sides & Border3DSide.Right) != 0) {
5624                                 graphics.DrawLine (penBottomRight, rect.Right - 1, rect.Top, rect.Right - 1, rect.Bottom - 1);
5625                                 if ((rect.Width > 3) && inner)
5626                                         graphics.DrawLine (penBottomRightInner, rect.Right - 2, rect.Top + 1, rect.Right - 2, rect.Bottom - 2);
5627                         }
5628
5629                         if ((sides & Border3DSide.Bottom) != 0) {
5630                                 graphics.DrawLine (penBottomRight, rect.Left, rect.Bottom - 1, rect.Right - 1, rect.Bottom - 1);
5631                                 if ((rect.Height > 3) && inner)
5632                                         graphics.DrawLine (penBottomRightInner, rect.Left + 1, rect.Bottom - 2, rect.Right - 2, rect.Bottom - 2);
5633                         }
5634                 }
5635
5636                 public override void CPDrawButton (Graphics dc, Rectangle rectangle, ButtonState state)
5637                 {
5638                         CPDrawButtonInternal (dc, rectangle, state, SystemPens.ControlDarkDark, SystemPens.ControlDark, SystemPens.ControlLight);
5639                 }
5640
5641                 private void CPDrawButtonInternal (Graphics dc, Rectangle rectangle, ButtonState state, Pen DarkPen, Pen NormalPen, Pen LightPen)
5642                 {
5643                         // sadly enough, the rectangle gets always filled with a hatchbrush
5644                         dc.FillRectangle (ResPool.GetHatchBrush (HatchStyle.Percent50,
5645                                                                  Color.FromArgb (Clamp (ColorControl.R + 3, 0, 255),
5646                                                                                  ColorControl.G, ColorControl.B),
5647                                                                  ColorControl),
5648                                           rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2);
5649
5650                         if ((state & ButtonState.All) == ButtonState.All || ((state & ButtonState.Checked) == ButtonState.Checked && (state & ButtonState.Flat) == ButtonState.Flat)) {
5651                                 dc.FillRectangle (ResPool.GetHatchBrush (HatchStyle.Percent50, ColorControlLight, ColorControl), rectangle.X + 2, rectangle.Y + 2, rectangle.Width - 4, rectangle.Height - 4);
5652
5653                                 dc.DrawRectangle (SystemPens.ControlDark, rectangle.X, rectangle.Y, rectangle.Width - 1, rectangle.Height - 1);
5654                         } else
5655                         if ((state & ButtonState.Flat) == ButtonState.Flat) {
5656                                 dc.DrawRectangle (SystemPens.ControlDark, rectangle.X, rectangle.Y, rectangle.Width - 1, rectangle.Height - 1);
5657                         } else
5658                         if ((state & ButtonState.Checked) == ButtonState.Checked) {
5659                                 dc.FillRectangle (ResPool.GetHatchBrush (HatchStyle.Percent50, ColorControlLight, ColorControl), rectangle.X + 2, rectangle.Y + 2, rectangle.Width - 4, rectangle.Height - 4);
5660
5661                                 Pen pen = DarkPen;
5662                                 dc.DrawLine (pen, rectangle.X, rectangle.Y, rectangle.X, rectangle.Bottom - 2);
5663                                 dc.DrawLine (pen, rectangle.X + 1, rectangle.Y, rectangle.Right - 2, rectangle.Y);
5664
5665                                 pen = NormalPen;
5666                                 dc.DrawLine (pen, rectangle.X + 1, rectangle.Y + 1, rectangle.X + 1, rectangle.Bottom - 3);
5667                                 dc.DrawLine (pen, rectangle.X + 2, rectangle.Y + 1, rectangle.Right - 3, rectangle.Y + 1);
5668
5669                                 pen = LightPen;
5670                                 dc.DrawLine (pen, rectangle.X, rectangle.Bottom - 1, rectangle.Right - 2, rectangle.Bottom - 1);
5671                                 dc.DrawLine (pen, rectangle.Right - 1, rectangle.Y, rectangle.Right - 1, rectangle.Bottom - 1);
5672                         } else
5673                         if (((state & ButtonState.Pushed) == ButtonState.Pushed) && ((state & ButtonState.Normal) == ButtonState.Normal)) {
5674                                 Pen pen = DarkPen;
5675                                 dc.DrawLine (pen, rectangle.X, rectangle.Y, rectangle.X, rectangle.Bottom - 2);
5676                                 dc.DrawLine (pen, rectangle.X + 1, rectangle.Y, rectangle.Right - 2, rectangle.Y);
5677
5678                                 pen = NormalPen;
5679                                 dc.DrawLine (pen, rectangle.X + 1, rectangle.Y + 1, rectangle.X + 1, rectangle.Bottom - 3);
5680                                 dc.DrawLine (pen, rectangle.X + 2, rectangle.Y + 1, rectangle.Right - 3, rectangle.Y + 1);
5681
5682                                 pen = LightPen;
5683                                 dc.DrawLine (pen, rectangle.X, rectangle.Bottom - 1, rectangle.Right - 2, rectangle.Bottom - 1);
5684                                 dc.DrawLine (pen, rectangle.Right - 1, rectangle.Y, rectangle.Right - 1, rectangle.Bottom - 1);
5685                         } else
5686                         if (((state & ButtonState.Inactive) == ButtonState.Inactive) || ((state & ButtonState.Normal) == ButtonState.Normal)) {
5687                                 Pen pen = LightPen;
5688                                 dc.DrawLine (pen, rectangle.X, rectangle.Y, rectangle.Right - 2, rectangle.Y);
5689                                 dc.DrawLine (pen, rectangle.X, rectangle.Y, rectangle.X, rectangle.Bottom - 2);
5690
5691                                 pen = NormalPen;
5692                                 dc.DrawLine (pen, rectangle.X + 1, rectangle.Bottom - 2, rectangle.Right - 2, rectangle.Bottom - 2);
5693                                 dc.DrawLine (pen, rectangle.Right - 2, rectangle.Y + 1, rectangle.Right - 2, rectangle.Bottom - 3);
5694
5695                                 pen = DarkPen;
5696                                 dc.DrawLine (pen, rectangle.X, rectangle.Bottom - 1, rectangle.Right - 1, rectangle.Bottom - 1);
5697                                 dc.DrawLine (pen, rectangle.Right - 1, rectangle.Y, rectangle.Right - 1, rectangle.Bottom - 2);
5698                         }
5699                 }
5700
5701
5702                 public override void CPDrawCaptionButton (Graphics graphics, Rectangle rectangle, CaptionButton button, ButtonState state) {
5703                         Rectangle       captionRect;
5704                         int                     lineWidth;
5705
5706                         CPDrawButtonInternal (graphics, rectangle, state, SystemPens.ControlDarkDark, SystemPens.ControlDark, SystemPens.ControlLightLight);
5707
5708                         if (rectangle.Width<rectangle.Height) {
5709                                 captionRect=new Rectangle(rectangle.X+1, rectangle.Y+rectangle.Height/2-rectangle.Width/2+1, rectangle.Width-4, rectangle.Width-4);
5710                         } else {
5711                                 captionRect=new Rectangle(rectangle.X+rectangle.Width/2-rectangle.Height/2+1, rectangle.Y+1, rectangle.Height-4, rectangle.Height-4);
5712                         }
5713
5714                         if ((state & ButtonState.Pushed)!=0) {
5715                                 captionRect=new Rectangle(rectangle.X+2, rectangle.Y+2, rectangle.Width-3, rectangle.Height-3);
5716                         }
5717
5718                         /* Make sure we've got at least a line width of 1 */
5719                         lineWidth=Math.Max(1, captionRect.Width/7);
5720
5721                         switch(button) {
5722                         case CaptionButton.Close: {
5723                                 Pen     pen;
5724
5725                                 if ((state & ButtonState.Inactive)!=0) {
5726                                         pen = ResPool.GetSizedPen (ColorControlLight, lineWidth);
5727                                         DrawCaptionHelper(graphics, ColorControlLight, pen, lineWidth, 1, captionRect, button);
5728
5729                                         pen = ResPool.GetSizedPen (ColorControlDark, lineWidth);
5730                                         DrawCaptionHelper(graphics, ColorControlDark, pen, lineWidth, 0, captionRect, button);
5731                                         return;
5732                                 } else {
5733                                         pen = ResPool.GetSizedPen (ColorControlText, lineWidth);
5734                                         DrawCaptionHelper(graphics, ColorControlText, pen, lineWidth, 0, captionRect, button);
5735                                         return;
5736                                 }
5737                         }
5738
5739                         case CaptionButton.Help:
5740                         case CaptionButton.Maximize:
5741                         case CaptionButton.Minimize:
5742                         case CaptionButton.Restore: {
5743                                 if ((state & ButtonState.Inactive)!=0) {
5744                                         DrawCaptionHelper(graphics, ColorControlLight, SystemPens.ControlLightLight, lineWidth, 1, captionRect, button);
5745
5746                                         DrawCaptionHelper(graphics, ColorControlDark, SystemPens.ControlDark, lineWidth, 0, captionRect, button);
5747                                         return;
5748                                 } else {
5749                                         DrawCaptionHelper(graphics, ColorControlText, SystemPens.ControlText, lineWidth, 0, captionRect, button);
5750                                         return;
5751                                 }
5752                         }
5753                         }
5754                 }
5755
5756                 public override void CPDrawCheckBox (Graphics dc, Rectangle rectangle, ButtonState state)
5757                 {
5758                         Pen check_pen = SystemPens.ControlDarkDark;
5759
5760                         Rectangle cb_rect = new Rectangle (rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
5761
5762                         if ((state & ButtonState.All) == ButtonState.All) {
5763                                 cb_rect.Width -= 2;
5764                                 cb_rect.Height -= 2;
5765
5766                                 dc.FillRectangle (SystemBrushes.Control, cb_rect.X, cb_rect.Y, cb_rect.Width - 1, cb_rect.Height - 1);
5767                                 dc.DrawRectangle (SystemPens.ControlDark, cb_rect.X, cb_rect.Y, cb_rect.Width - 1, cb_rect.Height - 1);
5768
5769                                 check_pen = SystemPens.ControlDark;
5770                         } else
5771                         if ((state & ButtonState.Flat) == ButtonState.Flat) {
5772                                 cb_rect.Width -= 2;
5773                                 cb_rect.Height -= 2;
5774
5775                                 dc.FillRectangle (SystemBrushes.ControlLight, cb_rect.X, cb_rect.Y, cb_rect.Width - 1, cb_rect.Height - 1);
5776                                 dc.DrawRectangle (SystemPens.ControlDark, cb_rect.X, cb_rect.Y, cb_rect.Width - 1, cb_rect.Height - 1);
5777                         } else {
5778                                 cb_rect.Width -= 1;
5779                                 cb_rect.Height -= 1;
5780
5781                                 int check_box_visible_size = (cb_rect.Height > cb_rect.Width) ? cb_rect.Width : cb_rect.Height;
5782
5783                                 int x_pos = Math.Max (0, cb_rect.X + (cb_rect.Width / 2) - check_box_visible_size / 2);
5784                                 int y_pos = Math.Max (0, cb_rect.Y + (cb_rect.Height / 2) - check_box_visible_size / 2);
5785
5786                                 Rectangle rect = new Rectangle (x_pos, y_pos, check_box_visible_size, check_box_visible_size);
5787
5788                                 if (((state & ButtonState.Pushed) == ButtonState.Pushed) || ((state & ButtonState.Inactive) == ButtonState.Inactive)) {
5789                                         dc.FillRectangle (ResPool.GetHatchBrush (HatchStyle.Percent50,
5790                                                                                  Color.FromArgb (Clamp (ColorControl.R + 3, 0, 255),
5791                                                                                                  ColorControl.G, ColorControl.B),
5792                                                                                  ColorControl), rect.X + 2, rect.Y + 2, rect.Width - 3, rect.Height - 3);
5793                                 } else
5794                                         dc.FillRectangle (SystemBrushes.ControlLightLight, rect.X + 2, rect.Y + 2, rect.Width - 3, rect.Height - 3);
5795
5796                                 Pen pen = SystemPens.ControlDark;
5797                                 dc.DrawLine (pen, rect.X, rect.Y, rect.X, rect.Bottom - 1);
5798                                 dc.DrawLine (pen, rect.X + 1, rect.Y, rect.Right - 1, rect.Y);
5799
5800                                 pen = SystemPens.ControlDarkDark;
5801                                 dc.DrawLine (pen, rect.X + 1, rect.Y + 1, rect.X + 1, rect.Bottom - 2);
5802                                 dc.DrawLine (pen, rect.X + 2, rect.Y + 1, rect.Right - 2, rect.Y + 1);
5803
5804                                 pen = SystemPens.ControlLight;
5805                                 dc.DrawLine (pen, rect.Right, rect.Y, rect.Right, rect.Bottom);
5806                                 dc.DrawLine (pen, rect.X, rect.Bottom, rect.Right, rect.Bottom);
5807
5808                                 // oh boy, matching ms is like fighting against windmills
5809                                 using (Pen h_pen = new Pen (ResPool.GetHatchBrush (HatchStyle.Percent50,
5810                                                                                    Color.FromArgb (Clamp (ColorControl.R + 3, 0, 255),
5811                                                                                                    ColorControl.G, ColorControl.B), ColorControl))) {
5812                                         dc.DrawLine (h_pen, rect.X + 1, rect.Bottom - 1, rect.Right - 1, rect.Bottom - 1);
5813                                         dc.DrawLine (h_pen, rect.Right - 1, rect.Y + 1, rect.Right - 1, rect.Bottom - 1);
5814                                 }
5815
5816                                 if ((state & ButtonState.Inactive) == ButtonState.Inactive)
5817                                         check_pen = SystemPens.ControlDark;
5818                         }
5819
5820                         if ((state & ButtonState.Checked) == ButtonState.Checked) {
5821                                 int check_size = (cb_rect.Height > cb_rect.Width) ? cb_rect.Width / 2: cb_rect.Height / 2;
5822
5823                                 if (check_size < 7) {
5824                                         int lineWidth = Math.Max (3, check_size / 3);
5825                                         int Scale = Math.Max (1, check_size / 9);
5826
5827                                         Rectangle rect = new Rectangle (cb_rect.X + (cb_rect.Width / 2) - (check_size / 2) - 1, cb_rect.Y + (cb_rect.Height / 2) - (check_size / 2) - 1,
5828                                                                         check_size, check_size);
5829
5830                                         for (int i = 0; i < lineWidth; i++) {
5831                                                 dc.DrawLine (check_pen, rect.Left + lineWidth / 2, rect.Top + lineWidth + i, rect.Left + lineWidth / 2 + 2 * Scale, rect.Top + lineWidth + 2 * Scale + i);
5832                                                 dc.DrawLine (check_pen, rect.Left + lineWidth / 2 + 2 * Scale, rect.Top + lineWidth + 2 * Scale + i, rect.Left + lineWidth / 2 + 6 * Scale, rect.Top + lineWidth - 2 * Scale + i);
5833                                         }
5834                                 } else {
5835                                         int lineWidth = Math.Max (3, check_size / 3) + 1;
5836
5837                                         int x_half = cb_rect.Width / 2;
5838                                         int y_half = cb_rect.Height / 2;
5839
5840                                         Rectangle rect = new Rectangle (cb_rect.X + x_half - (check_size / 2) - 1, cb_rect.Y + y_half - (check_size / 2),
5841                                                                         check_size, check_size);
5842
5843                                         int gradient_left = check_size / 3;
5844                                         int gradient_right = check_size - gradient_left - 1;
5845
5846
5847                                         for (int i = 0; i < lineWidth; i++) {
5848                                                 dc.DrawLine (check_pen, rect.X, rect.Bottom - 1 - gradient_left - i, rect.X + gradient_left, rect.Bottom - 1 - i);
5849                                                 dc.DrawLine (check_pen, rect.X + gradient_left, rect.Bottom - 1 - i, rect.Right - 1, rect.Bottom - i  - 1 - gradient_right);
5850                                         }
5851                                 }
5852                         }
5853                 }
5854
5855                 public override void CPDrawComboButton (Graphics graphics, Rectangle rectangle, ButtonState state) {
5856                         Point[]                 arrow = new Point[3];
5857                         Point                           P1;
5858                         Point                           P2;
5859                         Point                           P3;
5860                         int                             centerX;
5861                         int                             centerY;
5862                         int                             shiftX;
5863                         int                             shiftY;
5864                         Rectangle               rect;
5865
5866                         if ((state & ButtonState.Checked)!=0) {
5867                                 graphics.FillRectangle(ResPool.GetHatchBrush (HatchStyle.Percent50, ColorControlLightLight, ColorControlLight),rectangle);
5868                         }
5869
5870                         if ((state & ButtonState.Flat)!=0) {
5871                                 ControlPaint.DrawBorder(graphics, rectangle, ColorControlDark, ButtonBorderStyle.Solid);
5872                         } else {
5873                                 if ((state & (ButtonState.Pushed | ButtonState.Checked))!=0) {
5874                                         // this needs to render like a pushed button - jba
5875                                         // CPDrawBorder3D(graphics, rectangle, Border3DStyle.Sunken, Border3DSide.Left | Border3DSide.Top | Border3DSide.Right | Border3DSide.Bottom, ColorControl);
5876                                         Rectangle trace_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max (rectangle.Width-1, 0), Math.Max (rectangle.Height-1, 0));
5877                                         graphics.DrawRectangle (SystemPens.ControlDark, trace_rectangle);
5878                                 } else {
5879                                         CPDrawBorder3D(graphics, rectangle, Border3DStyle.Raised, Border3DSide.Left | Border3DSide.Top | Border3DSide.Right | Border3DSide.Bottom, ColorControl);
5880                                 }
5881                         }
5882
5883                         rect=new Rectangle(rectangle.X+rectangle.Width/4, rectangle.Y+rectangle.Height/4, rectangle.Width/2, rectangle.Height/2);
5884                         centerX=rect.Left+rect.Width/2;
5885                         centerY=rect.Top+rect.Height/2;
5886                         shiftX=Math.Max(1, rect.Width/8);
5887                         shiftY=Math.Max(1, rect.Height/8);
5888
5889                         if ((state & ButtonState.Pushed)!=0) {
5890                                 shiftX++;
5891                                 shiftY++;
5892                         }
5893
5894                         rect.Y-=shiftY;
5895                         centerY-=shiftY;
5896                         P1=new Point(rect.Left, centerY);
5897                         P2=new Point(rect.Right, centerY);
5898                         P3=new Point(centerX, rect.Bottom);
5899
5900                         arrow[0]=P1;
5901                         arrow[1]=P2;
5902                         arrow[2]=P3;
5903
5904                         /* Draw the arrow */
5905                         if ((state & ButtonState.Inactive)!=0) {
5906                                 /* Move away from the shadow */
5907                                 arrow[0].X += 1;        arrow[0].Y += 1;
5908                                 arrow[1].X += 1;        arrow[1].Y += 1;
5909                                 arrow[2].X += 1;        arrow[2].Y += 1;
5910
5911                                 graphics.FillPolygon(SystemBrushes.ControlLightLight, arrow, FillMode.Winding);
5912
5913                                 arrow[0]=P1;
5914                                 arrow[1]=P2;
5915                                 arrow[2]=P3;
5916
5917                                 graphics.FillPolygon(SystemBrushes.ControlDark, arrow, FillMode.Winding);
5918                         } else {
5919                                 graphics.FillPolygon(SystemBrushes.ControlText, arrow, FillMode.Winding);
5920                         }
5921                 }
5922
5923
5924                 public override void CPDrawContainerGrabHandle (Graphics graphics, Rectangle bounds)
5925                 {
5926                         Pen                     pen     = Pens.Black;
5927                         Rectangle       rect    = new Rectangle (bounds.X, bounds.Y, bounds.Width - 1, bounds.Height - 1);      // Dunno why, but MS does it that way, too
5928                         int                     X;
5929                         int                     Y;
5930
5931                         graphics.FillRectangle (SystemBrushes.ControlLightLight, rect);
5932                         graphics.DrawRectangle (pen, rect);
5933
5934                         X = rect.X + rect.Width / 2;
5935                         Y = rect.Y + rect.Height / 2;
5936
5937                         /* Draw the cross */
5938                         graphics.DrawLine (pen, X, rect.Y + 2, X, rect.Bottom - 2);
5939                         graphics.DrawLine (pen, rect.X + 2, Y, rect.Right - 2, Y);
5940
5941                         /* Draw 'arrows' for vertical lines */
5942                         graphics.DrawLine (pen, X - 1, rect.Y + 3, X + 1, rect.Y + 3);
5943                         graphics.DrawLine (pen, X - 1, rect.Bottom - 3, X + 1, rect.Bottom - 3);
5944
5945                         /* Draw 'arrows' for horizontal lines */
5946                         graphics.DrawLine (pen, rect.X + 3, Y - 1, rect.X + 3, Y + 1);
5947                         graphics.DrawLine (pen, rect.Right - 3, Y - 1, rect.Right - 3, Y + 1);
5948                 }
5949
5950                 public virtual void DrawFlatStyleFocusRectangle (Graphics graphics, Rectangle rectangle, ButtonBase button, Color foreColor, Color backColor) {
5951                         // make a rectange to trace around border of the button
5952                         Rectangle trace_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max (rectangle.Width-1, 0), Math.Max (rectangle.Height-1, 0));
5953
5954                         Color outerColor = foreColor;
5955                         // adjust focus color according to the flatstyle
5956                         if (button.FlatStyle == FlatStyle.Popup && !button.is_pressed) {
5957                                 outerColor = (backColor.ToArgb () == ColorControl.ToArgb ()) ? ControlPaint.Dark(ColorControl) : ColorControlText;
5958                         }
5959
5960                         // draw the outer rectangle
5961                         graphics.DrawRectangle (ResPool.GetPen (outerColor), trace_rectangle);
5962
5963                         // draw the inner rectangle
5964                         if (button.FlatStyle == FlatStyle.Popup) {
5965                                 DrawInnerFocusRectangle (graphics, Rectangle.Inflate (rectangle, -4, -4), backColor);
5966                         } else {
5967                                 // draw a flat inner rectangle
5968                                 Pen pen = ResPool.GetPen (ControlPaint.LightLight (backColor));
5969                                 graphics.DrawRectangle(pen, Rectangle.Inflate (trace_rectangle, -4, -4));
5970                         }
5971                 }
5972
5973                 public virtual void DrawInnerFocusRectangle(Graphics graphics, Rectangle rectangle, Color backColor)
5974                 {
5975                         // make a rectange to trace around border of the button
5976                         Rectangle trace_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max (rectangle.Width-1, 0), Math.Max (rectangle.Height-1, 0));
5977
5978 #if NotUntilCairoIsFixed
5979                         Color colorBackInverted = Color.FromArgb (Math.Abs (backColor.R-255), Math.Abs (backColor.G-255), Math.Abs (backColor.B-255));
5980                         DashStyle oldStyle; // used for caching old penstyle
5981                         Pen pen = ResPool.GetPen (colorBackInverted);
5982
5983                         oldStyle = pen.DashStyle;
5984                         pen.DashStyle = DashStyle.Dot;
5985
5986                         graphics.DrawRectangle (pen, trace_rectangle);
5987                         pen.DashStyle = oldStyle;
5988 #else
5989                         CPDrawFocusRectangle(graphics, trace_rectangle, Color.Wheat, backColor);
5990 #endif
5991                 }
5992
5993
5994                 public override void CPDrawFocusRectangle (Graphics graphics, Rectangle rectangle, Color foreColor, Color backColor)
5995                 {
5996                         Rectangle rect = rectangle;
5997                         Pen pen;
5998                         HatchBrush brush;
5999
6000                         if (backColor.GetBrightness () >= 0.5) {
6001                                 foreColor = Color.Transparent;
6002                                 backColor = Color.Black;
6003
6004                         } else {
6005                                 backColor = Color.FromArgb (Math.Abs (backColor.R-255), Math.Abs (backColor.G-255), Math.Abs (backColor.B-255));
6006                                 foreColor = Color.Black;
6007                         }
6008
6009                         brush = ResPool.GetHatchBrush (HatchStyle.Percent50, backColor, foreColor);
6010                         pen = new Pen (brush, 1);
6011
6012                         rect.Width--;
6013                         rect.Height--;
6014
6015                         graphics.DrawRectangle (pen, rect);
6016                         pen.Dispose ();
6017                 }
6018
6019                 public override void CPDrawGrabHandle (Graphics graphics, Rectangle rectangle, bool primary, bool enabled)
6020                 {
6021                         Brush   sb;
6022                         Pen pen;
6023
6024                         if (primary == true) {
6025                                 pen = Pens.Black;
6026                                 if (enabled == true) {
6027                                         sb = Brushes.White;
6028                                 } else {
6029                                         sb = SystemBrushes.Control;
6030                                 }
6031                         } else {
6032                                 pen = Pens.White;
6033                                 if (enabled == true) {
6034                                         sb = Brushes.Black;
6035                                 } else {
6036                                         sb = SystemBrushes.Control;
6037                                 }
6038                         }
6039                         graphics.FillRectangle (sb, rectangle);
6040                         graphics.DrawRectangle (pen, rectangle);
6041                 }
6042
6043
6044                 public override void CPDrawGrid (Graphics graphics, Rectangle area, Size pixelsBetweenDots, Color backColor) {
6045                         Color   foreColor;
6046                         int     h;
6047                         int     b;
6048                         int     s;
6049
6050                         ControlPaint.Color2HBS(backColor, out h, out b, out s);
6051
6052                         if (b>127) {
6053                                 foreColor=Color.Black;
6054                         } else {
6055                                 foreColor=Color.White;
6056                         }
6057
6058                         // still not perfect. it seems that ms calculates the position of the first dot or line
6059
6060                         using (Pen pen = new Pen (foreColor)) {
6061                                 pen.DashPattern = new float [] {1.0f, pixelsBetweenDots.Width - 1};
6062
6063                                 for (int y = area.Top; y < area.Bottom; y += pixelsBetweenDots.Height)
6064                                         graphics.DrawLine (pen, area.X, y, area.Right - 1, y);
6065                         }
6066                 }
6067
6068                 public override void CPDrawImageDisabled (Graphics graphics, Image image, int x, int y, Color background) {
6069                         /*
6070                                 Microsoft seems to ignore the background and simply make
6071                                 the image grayscale. At least when having > 256 colors on
6072                                 the display.
6073                         */
6074
6075                         if (imagedisabled_attributes == null) {
6076                                 imagedisabled_attributes = new ImageAttributes ();
6077                                 ColorMatrix colorMatrix=new ColorMatrix(new float[][] {
6078                                           // This table would create a perfect grayscale image, based on luminance
6079                                           //                            new float[]{0.3f,0.3f,0.3f,0,0},
6080                                           //                            new float[]{0.59f,0.59f,0.59f,0,0},
6081                                           //                            new float[]{0.11f,0.11f,0.11f,0,0},
6082                                           //                            new float[]{0,0,0,1,0,0},
6083                                           //                            new float[]{0,0,0,0,1,0},
6084                                           //                            new float[]{0,0,0,0,0,1}
6085
6086                                           // This table generates a image that is grayscaled and then
6087                                           // brightened up. Seems to match MS close enough.
6088                                           new float[]{0.2f,0.2f,0.2f,0,0},
6089                                           new float[]{0.41f,0.41f,0.41f,0,0},
6090                                           new float[]{0.11f,0.11f,0.11f,0,0},
6091                                           new float[]{0.15f,0.15f,0.15f,1,0,0},
6092                                           new float[]{0.15f,0.15f,0.15f,0,1,0},
6093                                           new float[]{0.15f,0.15f,0.15f,0,0,1}
6094                                   });
6095
6096                                  imagedisabled_attributes.SetColorMatrix (colorMatrix);
6097                         }
6098
6099                         graphics.DrawImage(image, new Rectangle(x, y, image.Width, image.Height), 0, 0, image.Width, image.Height, GraphicsUnit.Pixel, imagedisabled_attributes);
6100
6101                 }
6102
6103
6104                 public override void CPDrawLockedFrame (Graphics graphics, Rectangle rectangle, bool primary) {
6105                         Pen     penBorder;
6106                         Pen     penInside;
6107
6108                         if (primary) {
6109                                 penBorder = ResPool.GetSizedPen (Color.White, 2);
6110                                 penInside = ResPool.GetPen (Color.Black);
6111                         } else {
6112                                 penBorder = ResPool.GetSizedPen (Color.Black, 2);
6113                                 penInside = ResPool.GetPen (Color.White);
6114                         }
6115                         penBorder.Alignment=PenAlignment.Inset;
6116                         penInside.Alignment=PenAlignment.Inset;
6117
6118                         graphics.DrawRectangle(penBorder, rectangle);
6119                         graphics.DrawRectangle(penInside, rectangle.X+2, rectangle.Y+2, rectangle.Width-5, rectangle.Height-5);
6120                 }
6121
6122
6123                 public override void CPDrawMenuGlyph (Graphics graphics, Rectangle rectangle, MenuGlyph glyph, Color color) {
6124                         Rectangle       rect;
6125                         int                     lineWidth;
6126
6127                         Brush brush = ResPool.GetSolidBrush (color);
6128
6129                         switch(glyph) {
6130                         case MenuGlyph.Arrow: {
6131                                 float height = rectangle.Height * 0.7f;
6132                                 float width  = height / 2.0f;
6133
6134                                 PointF ddCenter = new PointF (rectangle.X + ((rectangle.Width-width) / 2.0f), rectangle.Y + (rectangle.Height / 2.0f));
6135
6136                                 PointF [] vertices = new PointF [3];
6137                                 vertices [0].X = ddCenter.X;
6138                                 vertices [0].Y = ddCenter.Y - (height / 2.0f);
6139                                 vertices [1].X = ddCenter.X;
6140                                 vertices [1].Y = ddCenter.Y + (height / 2.0f);
6141                                 vertices [2].X = ddCenter.X + width + 0.1f;
6142                                 vertices [2].Y = ddCenter.Y;
6143
6144                                 graphics.FillPolygon (brush, vertices);
6145
6146                                 return;
6147                         }
6148
6149                         case MenuGlyph.Bullet: {
6150
6151                                 lineWidth=Math.Max(2, rectangle.Width/3);
6152                                 rect=new Rectangle(rectangle.X+lineWidth, rectangle.Y+lineWidth, rectangle.Width-lineWidth*2, rectangle.Height-lineWidth*2);
6153
6154                                 graphics.FillEllipse(brush, rect);
6155
6156                                 return;
6157                         }
6158
6159                         case MenuGlyph.Checkmark: {
6160
6161                                 Pen pen = ResPool.GetPen (color);
6162                                 lineWidth = Math.Max (2, rectangle.Width / 6);
6163                                 rect = new Rectangle(rectangle.X + lineWidth, rectangle.Y + lineWidth, rectangle.Width - lineWidth * 2, rectangle.Height- lineWidth * 2);
6164
6165                                 int Scale = Math.Max (1, rectangle.Width / 12);
6166                                 int top = (rect.Y + lineWidth + ((rect.Height - ((2 * Scale) + lineWidth)) / 2));
6167
6168                                 for (int i=0; i<lineWidth; i++) {
6169                                         graphics.DrawLine (pen, rect.Left+lineWidth/2, top+i, rect.Left+lineWidth/2+2*Scale, top+2*Scale+i);
6170                                         graphics.DrawLine (pen, rect.Left+lineWidth/2+2*Scale, top+2*Scale+i, rect.Left+lineWidth/2+6*Scale, top-2*Scale+i);
6171                                 }
6172                                 return;
6173                         }
6174                         }
6175
6176                 }
6177
6178                 public override void CPDrawRadioButton (Graphics dc, Rectangle rectangle, ButtonState state)
6179                 {
6180                         CPColor cpcolor = ResPool.GetCPColor (ColorControl);
6181
6182                         Color dot_color = Color.Black;
6183
6184                         Color top_left_outer = Color.Black;
6185                         Color top_left_inner = Color.Black;
6186                         Color bottom_right_outer = Color.Black;
6187                         Color bottom_right_inner = Color.Black;
6188
6189                         int ellipse_diameter = (rectangle.Width > rectangle.Height) ? (int)(rectangle.Height  * 0.9f) : (int)(rectangle.Width * 0.9f);
6190                         int radius = ellipse_diameter / 2;
6191
6192                         Rectangle rb_rect = new Rectangle (rectangle.X + (rectangle.Width / 2) - radius, rectangle.Y + (rectangle.Height / 2) - radius, ellipse_diameter, ellipse_diameter);
6193
6194                         Brush brush = null;
6195
6196                         if ((state & ButtonState.All) == ButtonState.All) {
6197                                 brush = ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (Clamp (ColorControl.R + 3, 0, 255),
6198                                                                                                      ColorControl.G, ColorControl.B), ColorControl);
6199                                 dot_color = cpcolor.Dark;
6200                         } else
6201                         if ((state & ButtonState.Flat) == ButtonState.Flat) {
6202                                 if (((state & ButtonState.Inactive) == ButtonState.Inactive) || ((state & ButtonState.Pushed) == ButtonState.Pushed))
6203                                         brush = ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (Clamp (ColorControl.R + 3, 0, 255), ColorControl.G, ColorControl.B), ColorControl);
6204                                 else
6205                                         brush = SystemBrushes.ControlLightLight;
6206                         } else {
6207                                 if (((state & ButtonState.Inactive) == ButtonState.Inactive) || ((state & ButtonState.Pushed) == ButtonState.Pushed))
6208                                         brush = ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (Clamp (ColorControl.R + 3, 0, 255), ColorControl.G, ColorControl.B), ColorControl);
6209                                 else
6210                                         brush = SystemBrushes.ControlLightLight;
6211
6212                                 top_left_outer = cpcolor.Dark;
6213                                 top_left_inner = cpcolor.DarkDark;
6214                                 bottom_right_outer = cpcolor.Light;
6215                                 bottom_right_inner = Color.Transparent;
6216
6217                                 if ((state & ButtonState.Inactive) == ButtonState.Inactive)
6218                                         dot_color = cpcolor.Dark;
6219                         }
6220
6221                         dc.FillEllipse (brush, rb_rect.X + 1, rb_rect.Y + 1, ellipse_diameter - 1, ellipse_diameter - 1);
6222
6223                         int line_width = Math.Max (1, (int)(ellipse_diameter * 0.08f));
6224
6225                         dc.DrawArc (ResPool.GetSizedPen (top_left_outer, line_width), rb_rect, 135.0f, 180.0f);
6226                         dc.DrawArc (ResPool.GetSizedPen (top_left_inner, line_width), Rectangle.Inflate (rb_rect, -line_width, -line_width), 135.0f, 180.0f);
6227                         dc.DrawArc (ResPool.GetSizedPen (bottom_right_outer, line_width), rb_rect, 315.0f, 180.0f);
6228
6229                         if (bottom_right_inner != Color.Transparent)
6230                                 dc.DrawArc (ResPool.GetSizedPen (bottom_right_inner, line_width), Rectangle.Inflate (rb_rect, -line_width, -line_width), 315.0f, 180.0f);
6231                         else
6232                                 using (Pen h_pen = new Pen (ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (Clamp (ColorControl.R + 3, 0, 255), ColorControl.G, ColorControl.B), ColorControl), line_width)) {
6233                                         dc.DrawArc (h_pen, Rectangle.Inflate (rb_rect, -line_width, -line_width), 315.0f, 180.0f);
6234                                 }
6235
6236                         if ((state & ButtonState.Checked) == ButtonState.Checked) {
6237                                 int inflate = line_width * 4;
6238                                 Rectangle tmp = Rectangle.Inflate (rb_rect, -inflate, -inflate);
6239                                 if (rectangle.Height >  13) {
6240                                         tmp.X += 1;
6241                                         tmp.Y += 1;
6242                                         tmp.Height -= 1;
6243                                         dc.FillEllipse (ResPool.GetSolidBrush (dot_color), tmp);
6244                                 } else {
6245                                         Pen pen = ResPool.GetPen (dot_color);
6246                                         dc.DrawLine (pen, tmp.X, tmp.Y + (tmp.Height / 2), tmp.Right, tmp.Y + (tmp.Height / 2));
6247                                         dc.DrawLine (pen, tmp.X, tmp.Y + (tmp.Height / 2) + 1, tmp.Right, tmp.Y + (tmp.Height / 2) + 1);
6248
6249                                         dc.DrawLine (pen, tmp.X + (tmp.Width / 2), tmp.Y, tmp.X + (tmp.Width / 2), tmp.Bottom);
6250                                         dc.DrawLine (pen, tmp.X + (tmp.Width / 2) + 1, tmp.Y, tmp.X + (tmp.Width / 2) + 1, tmp.Bottom);
6251                                 }
6252                         }
6253                 }
6254
6255                 public override void CPDrawReversibleFrame (Rectangle rectangle, Color backColor, FrameStyle style) {
6256
6257                 }
6258
6259
6260                 public override void CPDrawReversibleLine (Point start, Point end, Color backColor) {
6261
6262                 }
6263
6264
6265                 /* Scroll button: regular button + direction arrow */
6266                 public override void CPDrawScrollButton (Graphics dc, Rectangle area, ScrollButton type, ButtonState state)
6267                 {
6268                         DrawScrollButtonPrimitive (dc, area, state);
6269
6270                         bool fill_rect = true;
6271                         int offset = 0;
6272
6273                         if ((state & ButtonState.Pushed) != 0)
6274                                 offset = 1;
6275
6276                         // skip the border
6277                         Rectangle rect = new Rectangle (area.X + 2 + offset, area.Y + 2 + offset, area.Width - 4, area.Height - 4);
6278
6279                         Point [] arrow = new Point [3];
6280                         for (int i = 0; i < 3; i++)
6281                                 arrow [i] = new Point ();
6282
6283                         Pen pen = SystemPens.ControlText;
6284
6285                         if ((state & ButtonState.Inactive) != 0) {
6286                                 pen = SystemPens.ControlDark;
6287                         }
6288
6289                         switch (type) {
6290                                 default:
6291                                 case ScrollButton.Down:
6292                                         int x_middle = (int)Math.Round (rect.Width / 2.0f) - 1;
6293                                         int y_middle = (int)Math.Round (rect.Height / 2.0f) - 1;
6294                                         if (x_middle == 1)
6295                                                 x_middle = 2;
6296
6297                                         int triangle_height;
6298
6299                                         if (rect.Height < 8) {
6300                                                 triangle_height = 2;
6301                                                 fill_rect = false;
6302                                         } else if (rect.Height == 11) {
6303                                                 triangle_height = 3;
6304                                         } else {
6305                                                 triangle_height = (int)Math.Round (rect.Height / 3.0f);
6306                                         }
6307
6308                                         arrow [0].X = rect.X + x_middle;
6309                                         arrow [0].Y = rect.Y + y_middle + triangle_height / 2;
6310
6311                                         arrow [1].X = arrow [0].X + triangle_height - 1;
6312                                         arrow [1].Y = arrow [0].Y - triangle_height + 1;
6313                                         arrow [2].X = arrow [0].X - triangle_height + 1;
6314                                         arrow [2].Y = arrow [1].Y;
6315
6316                                         dc.DrawPolygon (pen, arrow);
6317
6318                                         if ((state & ButtonState.Inactive) != 0) {
6319                                                 dc.DrawLine (SystemPens.ControlLightLight, arrow [1].X + 1, arrow [1].Y + 1, arrow [0].X + 1, arrow [0].Y + 1);
6320                                                 dc.DrawLine (SystemPens.ControlLightLight, arrow [1].X, arrow [1].Y + 1, arrow [0].X + 1, arrow [0].Y);
6321                                         }
6322
6323                                         if (fill_rect) {
6324                                                 for (int i = 0; i < arrow [0].Y - arrow [1].Y; i++) {
6325                                                         dc.DrawLine (pen, arrow [1].X, arrow [1].Y + i, arrow [2].X, arrow [1].Y + i);
6326                                                         arrow [1].X -= 1;
6327                                                         arrow [2].X += 1;
6328                                                 }
6329                                         }
6330                                         break;
6331
6332                                 case ScrollButton.Up:
6333                                         x_middle = (int)Math.Round (rect.Width / 2.0f) - 1;
6334                                         y_middle = (int)Math.Round (rect.Height / 2.0f);
6335                                         if (x_middle == 1)
6336                                                 x_middle = 2;
6337
6338                                         if (y_middle == 1)
6339                                                 y_middle = 2;
6340
6341                                         if (rect.Height < 8) {
6342                                                 triangle_height = 2;
6343                                                 fill_rect = false;
6344                                         } else if (rect.Height == 11) {
6345                                                 triangle_height = 3;
6346                                         } else {
6347                                                 triangle_height = (int)Math.Round (rect.Height / 3.0f);
6348                                         }
6349
6350                                         arrow [0].X = rect.X + x_middle;
6351                                         arrow [0].Y = rect.Y + y_middle - triangle_height / 2;
6352
6353                                         arrow [1].X = arrow [0].X + triangle_height - 1;
6354                                         arrow [1].Y = arrow [0].Y + triangle_height - 1;
6355                                         arrow [2].X = arrow [0].X - triangle_height + 1;
6356                                         arrow [2].Y = arrow [1].Y;
6357
6358                                         dc.DrawPolygon (pen, arrow);
6359
6360                                         if ((state & ButtonState.Inactive) != 0) {
6361                                                 dc.DrawLine (SystemPens.ControlLightLight, arrow [1].X + 1, arrow [1].Y + 1, arrow [2].X + 1, arrow [1].Y + 1);
6362                                         }
6363
6364                                         if (fill_rect) {
6365                                                 for (int i = 0; i < arrow [1].Y - arrow [0].Y; i++) {
6366                                                         dc.DrawLine (pen, arrow [2].X, arrow [1].Y - i, arrow [1].X, arrow [1].Y - i);
6367                                                         arrow [1].X -= 1;
6368                                                         arrow [2].X += 1;
6369                                                 }
6370                                         }
6371                                         break;
6372
6373                                 case ScrollButton.Left:
6374                                         y_middle = (int)Math.Round (rect.Height / 2.0f) - 1;
6375                                         if (y_middle == 1)
6376                                                 y_middle = 2;
6377
6378                                         int triangle_width;
6379
6380                                         if (rect.Width < 8) {
6381                                                 triangle_width = 2;
6382                                                 fill_rect = false;
6383                                         } else if (rect.Width == 11) {
6384                                                 triangle_width = 3;
6385                                         } else {
6386                                                 triangle_width = (int)Math.Round (rect.Width / 3.0f);
6387                                         }
6388
6389                                         arrow [0].X = rect.Left + triangle_width - 1;
6390                                         arrow [0].Y = rect.Y + y_middle;
6391
6392                                         if (arrow [0].X - 1 == rect.X)
6393                                                 arrow [0].X += 1;
6394
6395                                         arrow [1].X = arrow [0].X + triangle_width - 1;
6396                                         arrow [1].Y = arrow [0].Y - triangle_width + 1;
6397                                         arrow [2].X = arrow [1].X;
6398                                         arrow [2].Y = arrow [0].Y + triangle_width - 1;
6399
6400                                         dc.DrawPolygon (pen, arrow);
6401
6402                                         if ((state & ButtonState.Inactive) != 0) {
6403                                                 dc.DrawLine (SystemPens.ControlLightLight, arrow [1].X + 1, arrow [1].Y + 1, arrow [2].X + 1, arrow [2].Y + 1);
6404                                         }
6405
6406                                         if (fill_rect) {
6407                                                 for (int i = 0; i < arrow [2].X - arrow [0].X; i++) {
6408                                                         dc.DrawLine (pen, arrow [2].X - i, arrow [1].Y, arrow [2].X - i, arrow [2].Y);
6409                                                         arrow [1].Y += 1;
6410                                                         arrow [2].Y -= 1;
6411                                                 }
6412                                         }
6413                                         break;
6414
6415                                 case ScrollButton.Right:
6416                                         y_middle = (int)Math.Round (rect.Height / 2.0f) - 1;
6417                                         if (y_middle == 1)
6418                                                 y_middle = 2;
6419
6420                                         if (rect.Width < 8) {
6421                                                 triangle_width = 2;
6422                                                 fill_rect = false;
6423                                         } else if (rect.Width == 11) {
6424                                                 triangle_width = 3;
6425                                         } else {
6426                                                 triangle_width = (int)Math.Round (rect.Width / 3.0f);
6427                                         }
6428
6429                                         arrow [0].X = rect.Right - triangle_width - 1;
6430                                         arrow [0].Y = rect.Y + y_middle;
6431
6432                                         if (arrow [0].X - 1 == rect.X)
6433                                                 arrow [0].X += 1;
6434
6435                                         arrow [1].X = arrow [0].X - triangle_width + 1;
6436                                         arrow [1].Y = arrow [0].Y - triangle_width + 1;
6437                                         arrow [2].X = arrow [1].X;
6438                                         arrow [2].Y = arrow [0].Y + triangle_width - 1;
6439
6440                                         dc.DrawPolygon (pen, arrow);
6441
6442                                         if ((state & ButtonState.Inactive) != 0) {
6443                                                 dc.DrawLine (SystemPens.ControlLightLight, arrow [0].X + 1, arrow [0].Y + 1, arrow [2].X + 1, arrow [2].Y + 1);
6444                                                 dc.DrawLine (SystemPens.ControlLightLight, arrow [0].X, arrow [0].Y + 1, arrow [2].X + 1, arrow [2].Y);
6445                                         }
6446
6447                                         if (fill_rect) {
6448                                                 for (int i = 0; i < arrow [0].X - arrow [1].X; i++) {
6449                                                         dc.DrawLine (pen, arrow [2].X + i, arrow [1].Y, arrow [2].X + i, arrow [2].Y);
6450                                                         arrow [1].Y += 1;
6451                                                         arrow [2].Y -= 1;
6452                                                 }
6453                                         }
6454                                         break;
6455                         }
6456                 }
6457
6458                 public  override void CPDrawSelectionFrame (Graphics graphics, bool active, Rectangle outsideRect, Rectangle insideRect,
6459                         Color backColor) {
6460
6461                 }
6462
6463
6464                 public override void CPDrawSizeGrip (Graphics dc, Color backColor, Rectangle bounds)
6465                 {
6466                         Pen pen_dark = ResPool.GetPen(ControlPaint.Dark(backColor));
6467                         Pen pen_light_light = ResPool.GetPen(ControlPaint.LightLight(backColor));
6468
6469                         for (int i = 2; i < bounds.Width - 2; i += 4) {
6470                                 dc.DrawLine (pen_light_light, bounds.X + i, bounds.Bottom - 2, bounds.Right - 1, bounds.Y + i - 1);
6471                                 dc.DrawLine (pen_dark, bounds.X + i + 1, bounds.Bottom - 2, bounds.Right - 1, bounds.Y + i);
6472                                 dc.DrawLine (pen_dark, bounds.X + i + 2, bounds.Bottom - 2, bounds.Right - 1, bounds.Y + i + 1);
6473                         }
6474                 }
6475
6476                 private void DrawStringDisabled20 (Graphics g, string s, Font font, Rectangle layoutRectangle, Color color, TextFormatFlags flags, bool useDrawString)
6477                 {
6478                         CPColor cpcolor = ResPool.GetCPColor (color);
6479
6480                         layoutRectangle.Offset (1, 1);
6481                         TextRenderer.DrawTextInternal (g, s, font, layoutRectangle, cpcolor.LightLight, flags, useDrawString);
6482
6483                         layoutRectangle.Offset (-1, -1);
6484                         TextRenderer.DrawTextInternal (g, s, font, layoutRectangle, cpcolor.Dark, flags, useDrawString);
6485                 }
6486
6487                 public  override void CPDrawStringDisabled (Graphics dc, string s, Font font, Color color, RectangleF layoutRectangle, StringFormat format)
6488                 {
6489                         CPColor cpcolor = ResPool.GetCPColor (color);
6490
6491                         dc.DrawString (s, font, ResPool.GetSolidBrush(cpcolor.LightLight),
6492                                        new RectangleF(layoutRectangle.X + 1, layoutRectangle.Y + 1, layoutRectangle.Width, layoutRectangle.Height),
6493                                        format);
6494                         dc.DrawString (s, font, ResPool.GetSolidBrush (cpcolor.Dark), layoutRectangle, format);
6495                 }
6496
6497                 private static void DrawBorderInternal(Graphics graphics, int startX, int startY, int endX, int endY,
6498                         int width, Color color, ButtonBorderStyle style, Border3DSide side) {
6499
6500                         Pen pen = null;
6501
6502                         switch (style) {
6503                         case ButtonBorderStyle.Solid:
6504                         case ButtonBorderStyle.Inset:
6505                         case ButtonBorderStyle.Outset:
6506                                         pen = ThemeEngine.Current.ResPool.GetDashPen (color, DashStyle.Solid);
6507                                         break;
6508                         case ButtonBorderStyle.Dashed:
6509                                         pen = ThemeEngine.Current.ResPool.GetDashPen (color, DashStyle.Dash);
6510                                         break;
6511                         case ButtonBorderStyle.Dotted:
6512                                         pen = ThemeEngine.Current.ResPool.GetDashPen (color, DashStyle.Dot);
6513                                         break;
6514                         default:
6515                         case ButtonBorderStyle.None:
6516                                         return;
6517                         }
6518
6519                         switch(style) {
6520                         case ButtonBorderStyle.Outset: {
6521                                 Color           colorGrade;
6522                                 int             hue, brightness, saturation;
6523                                 int             brightnessSteps;
6524                                 int             brightnessDownSteps;
6525
6526                                 ControlPaint.Color2HBS(color, out hue, out brightness, out saturation);
6527
6528                                 brightnessDownSteps=brightness/width;
6529                                 if (brightness>127) {
6530                                         brightnessSteps=Math.Max(6, (160-brightness)/width);
6531                                 } else {
6532                                         brightnessSteps=(127-brightness)/width;
6533                                 }
6534
6535                                 for (int i=0; i<width; i++) {
6536                                         switch(side) {
6537                                         case Border3DSide.Left: {
6538                                                 colorGrade=ControlPaint.HBS2Color(hue, Math.Min(255, brightness+brightnessSteps*(width-i)), saturation);
6539                                                 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
6540                                                 graphics.DrawLine(pen, startX+i, startY+i, endX+i, endY-i);
6541                                                 break;
6542                                         }
6543
6544                                         case Border3DSide.Right: {
6545                                                 colorGrade=ControlPaint.HBS2Color(hue, Math.Max(0, brightness-brightnessDownSteps*(width-i)), saturation);
6546                                                 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
6547                                                 graphics.DrawLine(pen, startX-i, startY+i, endX-i, endY-i);
6548                                                 break;
6549                                         }
6550
6551                                         case Border3DSide.Top: {
6552                                                 colorGrade=ControlPaint.HBS2Color(hue, Math.Min(255, brightness+brightnessSteps*(width-i)), saturation);
6553                                                 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
6554                                                 graphics.DrawLine(pen, startX+i, startY+i, endX-i, endY+i);
6555                                                 break;
6556                                         }
6557
6558                                         case Border3DSide.Bottom: {
6559                                                 colorGrade=ControlPaint.HBS2Color(hue, Math.Max(0, brightness-brightnessDownSteps*(width-i)), saturation);
6560                                                 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
6561                                                 graphics.DrawLine(pen, startX+i, startY-i, endX-i, endY-i);
6562                                                 break;
6563                                         }
6564                                         }
6565                                 }
6566                                 break;
6567                         }
6568
6569                         case ButtonBorderStyle.Inset: {
6570                                 Color           colorGrade;
6571                                 int             hue, brightness, saturation;
6572                                 int             brightnessSteps;
6573                                 int             brightnessDownSteps;
6574
6575                                 ControlPaint.Color2HBS(color, out hue, out brightness, out saturation);
6576
6577                                 brightnessDownSteps=brightness/width;
6578                                 if (brightness>127) {
6579                                         brightnessSteps=Math.Max(6, (160-brightness)/width);
6580                                 } else {
6581                                         brightnessSteps=(127-brightness)/width;
6582                                 }
6583
6584                                 for (int i=0; i<width; i++) {
6585                                         switch(side) {
6586                                         case Border3DSide.Left: {
6587                                                 colorGrade=ControlPaint.HBS2Color(hue, Math.Max(0, brightness-brightnessDownSteps*(width-i)), saturation);
6588                                                 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
6589                                                 graphics.DrawLine(pen, startX+i, startY+i, endX+i, endY-i);
6590                                                 break;
6591                                         }
6592
6593                                         case Border3DSide.Right: {
6594                                                 colorGrade=ControlPaint.HBS2Color(hue, Math.Min(255, brightness+brightnessSteps*(width-i)), saturation);
6595                                                 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
6596                                                 graphics.DrawLine(pen, startX-i, startY+i, endX-i, endY-i);
6597                                                 break;
6598                                         }
6599
6600                                         case Border3DSide.Top: {
6601                                                 colorGrade=ControlPaint.HBS2Color(hue, Math.Max(0, brightness-brightnessDownSteps*(width-i)), saturation);
6602                                                 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
6603                                                 graphics.DrawLine(pen, startX+i, startY+i, endX-i, endY+i);
6604                                                 break;
6605                                         }
6606
6607                                         case Border3DSide.Bottom: {
6608                                                 colorGrade=ControlPaint.HBS2Color(hue, Math.Min(255, brightness+brightnessSteps*(width-i)), saturation);
6609                                                 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
6610                                                 graphics.DrawLine(pen, startX+i, startY-i, endX-i, endY-i);
6611                                                 break;
6612                                         }
6613                                         }
6614                                 }
6615                                 break;
6616                         }
6617
6618                                 /*
6619                                         I decided to have the for-loop duplicated for speed reasons;
6620                                         that way we only have to switch once (as opposed to have the
6621                                         for-loop around the switch)
6622                                 */
6623                         default: {
6624                                 switch(side) {
6625                                 case Border3DSide.Left: {
6626                                         for (int i=0; i<width; i++) {
6627                                                 graphics.DrawLine(pen, startX+i, startY+i, endX+i, endY-i);
6628                                         }
6629                                         break;
6630                                 }
6631
6632                                 case Border3DSide.Right: {
6633                                         for (int i=0; i<width; i++) {
6634                                                 graphics.DrawLine(pen, startX-i, startY+i, endX-i, endY-i);
6635                                         }
6636                                         break;
6637                                 }
6638
6639                                 case Border3DSide.Top: {
6640                                         for (int i=0; i<width; i++) {
6641                                                 graphics.DrawLine(pen, startX+i, startY+i, endX-i, endY+i);
6642                                         }
6643                                         break;
6644                                 }
6645
6646                                 case Border3DSide.Bottom: {
6647                                         for (int i=0; i<width; i++) {
6648                                                 graphics.DrawLine(pen, startX+i, startY-i, endX-i, endY-i);
6649                                         }
6650                                         break;
6651                                 }
6652                                 }
6653                                 break;
6654                         }
6655                         }
6656                 }
6657
6658                 /*
6659                         This function actually draws the various caption elements.
6660                         This way we can scale them nicely, no matter what size, and they
6661                         still look like MS's scaled caption buttons. (as opposed to scaling a bitmap)
6662                 */
6663
6664                 private void DrawCaptionHelper(Graphics graphics, Color color, Pen pen, int lineWidth, int shift, Rectangle captionRect, CaptionButton button) {
6665                         switch(button) {
6666                         case CaptionButton.Close: {
6667                                 if (lineWidth<2) {
6668                                         graphics.DrawLine(pen, captionRect.Left+2*lineWidth+1+shift, captionRect.Top+2*lineWidth+shift, captionRect.Right-2*lineWidth+1+shift, captionRect.Bottom-2*lineWidth+shift);
6669                                         graphics.DrawLine(pen, captionRect.Right-2*lineWidth+1+shift, captionRect.Top+2*lineWidth+shift, captionRect.Left+2*lineWidth+1+shift, captionRect.Bottom-2*lineWidth+shift);
6670                                 }
6671
6672                                 graphics.DrawLine(pen, captionRect.Left+2*lineWidth+shift, captionRect.Top+2*lineWidth+shift, captionRect.Right-2*lineWidth+shift, captionRect.Bottom-2*lineWidth+shift);
6673                                 graphics.DrawLine(pen, captionRect.Right-2*lineWidth+shift, captionRect.Top+2*lineWidth+shift, captionRect.Left+2*lineWidth+shift, captionRect.Bottom-2*lineWidth+shift);
6674                                 return;
6675                         }
6676
6677                         case CaptionButton.Help: {
6678                                 StringFormat    sf = new StringFormat();
6679                                 Font                            font = new Font("Microsoft Sans Serif", captionRect.Height, FontStyle.Bold, GraphicsUnit.Pixel);
6680
6681                                 sf.Alignment=StringAlignment.Center;
6682                                 sf.LineAlignment=StringAlignment.Center;
6683
6684
6685                                 graphics.DrawString("?", font, ResPool.GetSolidBrush (color), captionRect.X+captionRect.Width/2+shift, captionRect.Y+captionRect.Height/2+shift+lineWidth/2, sf);
6686
6687                                 sf.Dispose();
6688                                 font.Dispose();
6689
6690                                 return;
6691                         }
6692
6693                         case CaptionButton.Maximize: {
6694                                 /* Top 'caption bar' line */
6695                                 for (int i=0; i<Math.Max(2, lineWidth); i++) {
6696                                         graphics.DrawLine(pen, captionRect.Left+lineWidth+shift, captionRect.Top+2*lineWidth+shift+i, captionRect.Right-lineWidth-lineWidth/2+shift, captionRect.Top+2*lineWidth+shift+i);
6697                                 }
6698
6699                                 /* Left side line */
6700                                 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
6701                                         graphics.DrawLine(pen, captionRect.Left+lineWidth+shift+i, captionRect.Top+2*lineWidth+shift, captionRect.Left+lineWidth+shift+i, captionRect.Bottom-lineWidth+shift);
6702                                 }
6703
6704                                 /* Right side line */
6705                                 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
6706                                         graphics.DrawLine(pen, captionRect.Right-lineWidth-lineWidth/2+shift+i, captionRect.Top+2*lineWidth+shift, captionRect.Right-lineWidth-lineWidth/2+shift+i, captionRect.Bottom-lineWidth+shift);
6707                                 }
6708
6709                                 /* Bottom line */
6710                                 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
6711                                         graphics.DrawLine(pen, captionRect.Left+lineWidth+shift, captionRect.Bottom-lineWidth+shift-i, captionRect.Right-lineWidth-lineWidth/2+shift, captionRect.Bottom-lineWidth+shift-i);
6712                                 }
6713                                 return;
6714                         }
6715
6716                         case CaptionButton.Minimize: {
6717                                 /* Bottom line */
6718                                 for (int i=0; i<Math.Max(2, lineWidth); i++) {
6719                                         graphics.DrawLine(pen, captionRect.Left+lineWidth+shift, captionRect.Bottom-lineWidth+shift-i, captionRect.Right-3*lineWidth+shift, captionRect.Bottom-lineWidth+shift-i);
6720                                 }
6721                                 return;
6722                         }
6723
6724                         case CaptionButton.Restore: {
6725                                 /** First 'window' **/
6726                                 /* Top 'caption bar' line */
6727                                 for (int i=0; i<Math.Max(2, lineWidth); i++) {
6728                                         graphics.DrawLine(pen, captionRect.Left+3*lineWidth+shift, captionRect.Top+2*lineWidth+shift-i, captionRect.Right-lineWidth-lineWidth/2+shift, captionRect.Top+2*lineWidth+shift-i);
6729                                 }
6730
6731                                 /* Left side line */
6732                                 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
6733                                         graphics.DrawLine(pen, captionRect.Left+3*lineWidth+shift+i, captionRect.Top+2*lineWidth+shift, captionRect.Left+3*lineWidth+shift+i, captionRect.Top+4*lineWidth+shift);
6734                                 }
6735
6736                                 /* Right side line */
6737                                 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
6738                                         graphics.DrawLine(pen, captionRect.Right-lineWidth-lineWidth/2+shift-i, captionRect.Top+2*lineWidth+shift, captionRect.Right-lineWidth-lineWidth/2+shift-i, captionRect.Top+5*lineWidth-lineWidth/2+shift);
6739                                 }
6740
6741                                 /* Bottom line */
6742                                 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
6743                                         graphics.DrawLine(pen, captionRect.Right-3*lineWidth-lineWidth/2+shift, captionRect.Top+5*lineWidth-lineWidth/2+shift+1+i, captionRect.Right-lineWidth-lineWidth/2+shift, captionRect.Top+5*lineWidth-lineWidth/2+shift+1+i);
6744                                 }
6745
6746                                 /** Second 'window' **/
6747                                 /* Top 'caption bar' line */
6748                                 for (int i=0; i<Math.Max(2, lineWidth); i++) {
6749                                         graphics.DrawLine(pen, captionRect.Left+lineWidth+shift, captionRect.Top+4*lineWidth+shift+1-i, captionRect.Right-3*lineWidth-lineWidth/2+shift, captionRect.Top+4*lineWidth+shift+1-i);
6750                                 }
6751
6752                                 /* Left side line */
6753                                 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
6754                                         graphics.DrawLine(pen, captionRect.Left+lineWidth+shift+i, captionRect.Top+4*lineWidth+shift+1, captionRect.Left+lineWidth+shift+i, captionRect.Bottom-lineWidth+shift);
6755                                 }
6756
6757                                 /* Right side line */
6758                                 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
6759                                         graphics.DrawLine(pen, captionRect.Right-3*lineWidth-lineWidth/2+shift-i, captionRect.Top+4*lineWidth+shift+1, captionRect.Right-3*lineWidth-lineWidth/2+shift-i, captionRect.Bottom-lineWidth+shift);
6760                                 }
6761
6762                                 /* Bottom line */
6763                                 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
6764                                         graphics.DrawLine(pen, captionRect.Left+lineWidth+shift, captionRect.Bottom-lineWidth+shift-i, captionRect.Right-3*lineWidth-lineWidth/2+shift, captionRect.Bottom-lineWidth+shift-i);
6765                                 }
6766
6767                                 return;
6768                         }
6769
6770                         }
6771                 }
6772
6773                 /* Generic scroll button */
6774                 public void DrawScrollButtonPrimitive (Graphics dc, Rectangle area, ButtonState state) {
6775                         if ((state & ButtonState.Pushed) == ButtonState.Pushed) {
6776                                 dc.FillRectangle (SystemBrushes.Control, area.X + 1,
6777                                         area.Y + 1, area.Width - 2 , area.Height - 2);
6778
6779                                 dc.DrawRectangle (SystemPens.ControlDark, area.X,
6780                                         area.Y, area.Width, area.Height);
6781
6782                                 return;
6783                         }
6784
6785                         Brush sb_control = SystemBrushes.Control;
6786                         Brush sb_lightlight = SystemBrushes.ControlLightLight;
6787                         Brush sb_dark = SystemBrushes.ControlDark;
6788                         Brush sb_darkdark = SystemBrushes.ControlDarkDark;
6789
6790                         dc.FillRectangle (sb_control, area.X, area.Y, area.Width, 1);
6791                         dc.FillRectangle (sb_control, area.X, area.Y, 1, area.Height);
6792
6793                         dc.FillRectangle (sb_lightlight, area.X + 1, area.Y + 1, area.Width - 1, 1);
6794                         dc.FillRectangle (sb_lightlight, area.X + 1, area.Y + 2, 1,
6795                                 area.Height - 4);
6796
6797                         dc.FillRectangle (sb_dark, area.X + 1, area.Y + area.Height - 2,
6798                                 area.Width - 2, 1);
6799
6800                         dc.FillRectangle (sb_darkdark, area.X, area.Y + area.Height -1,
6801                                 area.Width , 1);
6802
6803                         dc.FillRectangle (sb_dark, area.X + area.Width - 2,
6804                                 area.Y + 1, 1, area.Height -3);
6805
6806                         dc.FillRectangle (sb_darkdark, area.X + area.Width -1,
6807                                 area.Y, 1, area.Height - 1);
6808
6809                         dc.FillRectangle (sb_control, area.X + 2,
6810                                 area.Y + 2, area.Width - 4, area.Height - 4);
6811
6812                 }
6813
6814                 public override void CPDrawBorderStyle (Graphics dc, Rectangle area, BorderStyle border_style) {
6815                         switch (border_style){
6816                         case BorderStyle.Fixed3D:
6817                                 dc.DrawLine (ResPool.GetPen (ColorControlDark), area.X, area.Y, area.X +area.Width, area.Y);
6818                                 dc.DrawLine (ResPool.GetPen (ColorControlDark), area.X, area.Y, area.X, area.Y + area.Height);
6819                                 dc.DrawLine (ResPool.GetPen (ColorControlLight), area.X , area.Y + area.Height - 1, area.X + area.Width ,
6820                                         area.Y + area.Height - 1);
6821                                 dc.DrawLine (ResPool.GetPen (ColorControlLight), area.X + area.Width -1 , area.Y, area.X + area.Width -1,
6822                                         area.Y + area.Height);
6823
6824                                 dc.DrawLine (ResPool.GetPen (ColorActiveBorder), area.X + 1, area.Bottom - 2, area.Right - 2, area.Bottom - 2);
6825                                 dc.DrawLine (ResPool.GetPen (ColorActiveBorder), area.Right - 2, area.Top + 1, area.Right - 2, area.Bottom - 2);
6826                                 dc.DrawLine (ResPool.GetPen (ColorControlDarkDark), area.X + 1, area.Top + 1, area.X + 1, area.Bottom - 3);
6827                                 dc.DrawLine (ResPool.GetPen (ColorControlDarkDark), area.X + 1, area.Top + 1, area.Right - 3, area.Top + 1);
6828                                 break;
6829                         case BorderStyle.FixedSingle:
6830                                 dc.DrawRectangle (ResPool.GetPen (ColorWindowFrame), area.X, area.Y, area.Width - 1, area.Height - 1);
6831                                 break;
6832                         case BorderStyle.None:
6833                         default:
6834                                 break;
6835                         }
6836
6837                 }
6838                 #endregion      // ControlPaint
6839
6840
6841         } //class
6842 }