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:
9 // The above copyright notice and this permission notice shall be
10 // included in all copies or substantial portions of the Software.
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.
20 // Copyright (c) 2004-2006 Novell, Inc.
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
30 using System.ComponentModel;
33 using System.Drawing.Drawing2D;
34 using System.Drawing.Imaging;
35 using System.Drawing.Printing;
36 using System.Drawing.Text;
38 using System.Windows.Forms.Theming;
40 namespace System.Windows.Forms
43 internal class ThemeWin32Classic : Theme
45 public override Version Version {
47 return new Version(0, 1, 0, 0);
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 tabd
64 const int MENU_BAR_ITEMS_SPACE = 8; // Space between menu bar items
66 #region Principal Theme Methods
67 public ThemeWin32Classic ()
69 defaultWindowBackColor = this.ColorWindow;
70 defaultWindowForeColor = this.ColorControlText;
71 window_border_font = new Font(FontFamily.GenericSansSerif, 8.25f, FontStyle.Bold);
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 string_format_menu_text.SetTabStops (0f, new float [] { 50f });
79 string_format_menu_text.FormatFlags |= StringFormatFlags.NoWrap;
81 string_format_menu_shortcut = new StringFormat ();
82 string_format_menu_shortcut.LineAlignment = StringAlignment.Center;
83 string_format_menu_shortcut.Alignment = StringAlignment.Far;
85 string_format_menu_menubar_text = new StringFormat ();
86 string_format_menu_menubar_text.LineAlignment = StringAlignment.Center;
87 string_format_menu_menubar_text.Alignment = StringAlignment.Center;
88 string_format_menu_menubar_text.HotkeyPrefix = HotkeyPrefix.Show;
91 public override void ResetDefaults() {
92 Console.WriteLine("NOT IMPLEMENTED: ResetDefault()");
93 //throw new NotImplementedException("Need to implement ResetDefaults() for Win32 theme");
96 public override bool DoubleBufferingSupported {
100 public override int HorizontalScrollBarHeight {
102 return XplatUI.HorizontalScrollBarHeight;
106 public override int VerticalScrollBarWidth {
108 return XplatUI.VerticalScrollBarWidth;
112 #endregion // Principal Theme Methods
114 #region Internal Methods
115 protected Brush GetControlBackBrush (Color c) {
116 if (c.ToArgb () == DefaultControlBackColor.ToArgb ())
117 return SystemBrushes.Control;
118 return ResPool.GetSolidBrush (c);
121 protected Brush GetControlForeBrush (Color c) {
122 if (c.ToArgb () == DefaultControlForeColor.ToArgb ())
123 return SystemBrushes.ControlText;
124 return ResPool.GetSolidBrush (c);
126 #endregion // Internal Methods
129 public override Font GetLinkFont (Control control)
131 return new Font (control.Font.FontFamily, control.Font.Size, control.Font.Style | FontStyle.Underline, control.Font.Unit);
133 #endregion // Control
135 #region OwnerDraw Support
136 public override void DrawOwnerDrawBackground (DrawItemEventArgs e)
138 if ((e.State & DrawItemState.Selected) == DrawItemState.Selected) {
139 e.Graphics.FillRectangle (SystemBrushes.Highlight, e.Bounds);
143 e.Graphics.FillRectangle (ResPool.GetSolidBrush(e.BackColor), e.Bounds);
146 public override void DrawOwnerDrawFocusRectangle (DrawItemEventArgs e)
148 if (e.State == DrawItemState.Focus)
149 CPDrawFocusRectangle (e.Graphics, e.Bounds, e.ForeColor, e.BackColor);
151 #endregion // OwnerDraw Support
154 #region Standard Button Style
155 public override void DrawButton (Graphics g, Button b, Rectangle textBounds, Rectangle imageBounds, Rectangle clipRectangle)
157 // Draw Button Background
158 DrawButtonBackground (g, b, clipRectangle);
160 // If we have an image, draw it
161 if (imageBounds.Size != Size.Empty)
162 DrawButtonImage (g, b, imageBounds);
164 // If we're focused, draw a focus rectangle
165 if (b.Focused && b.Enabled && b.ShowFocusCues)
166 DrawButtonFocus (g, b);
168 // If we have text, draw it
169 if (textBounds != Rectangle.Empty)
170 DrawButtonText (g, b, textBounds);
173 public virtual void DrawButtonBackground (Graphics g, Button button, Rectangle clipArea)
176 ThemeElements.DrawButton (g, button.ClientRectangle, ButtonThemeState.Pressed, button.BackColor, button.ForeColor);
177 else if (button.InternalSelected)
178 ThemeElements.DrawButton (g, button.ClientRectangle, ButtonThemeState.Default, button.BackColor, button.ForeColor);
179 else if (button.Entered)
180 ThemeElements.DrawButton (g, button.ClientRectangle, ButtonThemeState.Entered, button.BackColor, button.ForeColor);
181 else if (!button.Enabled)
182 ThemeElements.DrawButton (g, button.ClientRectangle, ButtonThemeState.Disabled, button.BackColor, button.ForeColor);
184 ThemeElements.DrawButton (g, button.ClientRectangle, ButtonThemeState.Normal, button.BackColor, button.ForeColor);
187 public virtual void DrawButtonFocus (Graphics g, Button button)
189 ControlPaint.DrawFocusRectangle (g, Rectangle.Inflate (button.ClientRectangle, -4, -4));
192 public virtual void DrawButtonImage (Graphics g, ButtonBase button, Rectangle imageBounds)
195 g.DrawImage (button.Image, imageBounds);
197 CPDrawImageDisabled (g, button.Image, imageBounds.Left, imageBounds.Top, ColorControl);
200 public virtual void DrawButtonText (Graphics g, ButtonBase button, Rectangle textBounds)
202 // Ensure that at least one line is going to get displayed.
203 // Line limit does not ensure that despite its description.
204 textBounds.Height = Math.Max (textBounds.Height, button.Font.Height);
207 TextRenderer.DrawTextInternal (g, button.Text, button.Font, textBounds, button.ForeColor, button.TextFormatFlags, button.UseCompatibleTextRendering);
209 DrawStringDisabled20 (g, button.Text, button.Font, textBounds, button.BackColor, button.TextFormatFlags, button.UseCompatibleTextRendering);
213 #region FlatStyle Button Style
214 public override void DrawFlatButton (Graphics g, ButtonBase b, Rectangle textBounds, Rectangle imageBounds, Rectangle clipRectangle)
216 // Draw Button Background
217 if (b.BackgroundImage == null)
218 DrawFlatButtonBackground (g, b, clipRectangle);
220 // If we have an image, draw it
221 if (imageBounds.Size != Size.Empty)
222 DrawFlatButtonImage (g, b, imageBounds);
224 // If we're focused, draw a focus rectangle
225 if (b.Focused && b.Enabled && b.ShowFocusCues)
226 DrawFlatButtonFocus (g, b);
228 // If we have text, draw it
229 if (textBounds != Rectangle.Empty)
230 DrawFlatButtonText (g, b, textBounds);
233 public virtual void DrawFlatButtonBackground (Graphics g, ButtonBase button, Rectangle clipArea)
236 ThemeElements.DrawFlatButton (g, button.ClientRectangle, ButtonThemeState.Pressed, button.BackColor, button.ForeColor, button.FlatAppearance);
237 else if (button.InternalSelected) {
239 ThemeElements.DrawFlatButton (g, button.ClientRectangle, ButtonThemeState.Default | ButtonThemeState.Entered, button.BackColor, button.ForeColor, button.FlatAppearance);
241 ThemeElements.DrawFlatButton (g, button.ClientRectangle, ButtonThemeState.Default, button.BackColor, button.ForeColor, button.FlatAppearance);
243 else if (button.Entered)
244 ThemeElements.DrawFlatButton (g, button.ClientRectangle, ButtonThemeState.Entered, button.BackColor, button.ForeColor, button.FlatAppearance);
245 else if (!button.Enabled)
246 ThemeElements.DrawFlatButton (g, button.ClientRectangle, ButtonThemeState.Disabled, button.BackColor, button.ForeColor, button.FlatAppearance);
248 ThemeElements.DrawFlatButton (g, button.ClientRectangle, ButtonThemeState.Normal, button.BackColor, button.ForeColor, button.FlatAppearance);
251 public virtual void DrawFlatButtonFocus (Graphics g, ButtonBase button)
253 if (!button.Pressed) {
254 Color focus_color = ControlPaint.Dark (button.BackColor);
255 g.DrawRectangle (ResPool.GetPen (focus_color), new Rectangle (button.ClientRectangle.Left + 4, button.ClientRectangle.Top + 4, button.ClientRectangle.Width - 9, button.ClientRectangle.Height - 9));
259 public virtual void DrawFlatButtonImage (Graphics g, ButtonBase button, Rectangle imageBounds)
261 // No changes from Standard for image for this theme
262 DrawButtonImage (g, button, imageBounds);
265 public virtual void DrawFlatButtonText (Graphics g, ButtonBase button, Rectangle textBounds)
267 // No changes from Standard for text for this theme
268 DrawButtonText (g, button, textBounds);
272 #region Popup Button Style
273 public override void DrawPopupButton (Graphics g, Button b, Rectangle textBounds, Rectangle imageBounds, Rectangle clipRectangle)
275 // Draw Button Background
276 DrawPopupButtonBackground (g, b, clipRectangle);
278 // If we have an image, draw it
279 if (imageBounds.Size != Size.Empty)
280 DrawPopupButtonImage (g, b, imageBounds);
282 // If we're focused, draw a focus rectangle
283 if (b.Focused && b.Enabled && b.ShowFocusCues)
284 DrawPopupButtonFocus (g, b);
286 // If we have text, draw it
287 if (textBounds != Rectangle.Empty)
288 DrawPopupButtonText (g, b, textBounds);
291 public virtual void DrawPopupButtonBackground (Graphics g, Button button, Rectangle clipArea)
294 ThemeElements.DrawPopupButton (g, button.ClientRectangle, ButtonThemeState.Pressed, button.BackColor, button.ForeColor);
295 else if (button.Entered)
296 ThemeElements.DrawPopupButton (g, button.ClientRectangle, ButtonThemeState.Entered, button.BackColor, button.ForeColor);
297 else if (button.InternalSelected)
298 ThemeElements.DrawPopupButton (g, button.ClientRectangle, ButtonThemeState.Default, button.BackColor, button.ForeColor);
299 else if (!button.Enabled)
300 ThemeElements.DrawPopupButton (g, button.ClientRectangle, ButtonThemeState.Disabled, button.BackColor, button.ForeColor);
302 ThemeElements.DrawPopupButton (g, button.ClientRectangle, ButtonThemeState.Normal, button.BackColor, button.ForeColor);
305 public virtual void DrawPopupButtonFocus (Graphics g, Button button)
307 // No changes from Standard for image for this theme
308 DrawButtonFocus (g, button);
311 public virtual void DrawPopupButtonImage (Graphics g, Button button, Rectangle imageBounds)
313 // No changes from Standard for image for this theme
314 DrawButtonImage (g, button, imageBounds);
317 public virtual void DrawPopupButtonText (Graphics g, Button button, Rectangle textBounds)
319 // No changes from Standard for image for this theme
320 DrawButtonText (g, button, textBounds);
324 #region Button Layout Calculations
326 public override Size CalculateButtonAutoSize (Button button)
328 Size ret_size = Size.Empty;
329 Size text_size = TextRenderer.MeasureTextInternal (button.Text, button.Font, button.UseCompatibleTextRendering);
330 Size image_size = button.Image == null ? Size.Empty : button.Image.Size;
333 if (button.Text.Length != 0) {
334 text_size.Height += 4;
335 text_size.Width += 4;
338 switch (button.TextImageRelation) {
339 case TextImageRelation.Overlay:
340 ret_size.Height = Math.Max (button.Text.Length == 0 ? 0 : text_size.Height, image_size.Height);
341 ret_size.Width = Math.Max (text_size.Width, image_size.Width);
343 case TextImageRelation.ImageAboveText:
344 case TextImageRelation.TextAboveImage:
345 ret_size.Height = text_size.Height + image_size.Height;
346 ret_size.Width = Math.Max (text_size.Width, image_size.Width);
348 case TextImageRelation.ImageBeforeText:
349 case TextImageRelation.TextBeforeImage:
350 ret_size.Height = Math.Max (text_size.Height, image_size.Height);
351 ret_size.Width = text_size.Width + image_size.Width;
356 ret_size.Height += (button.Padding.Vertical + 6);
357 ret_size.Width += (button.Padding.Horizontal + 6);
363 public override void CalculateButtonTextAndImageLayout (ButtonBase button, out Rectangle textRectangle, out Rectangle imageRectangle)
365 Image image = button.Image;
366 string text = button.Text;
367 Rectangle content_rect = button.ClientRectangle;
368 Size text_size = TextRenderer.MeasureTextInternal (text, button.Font, content_rect.Size, button.TextFormatFlags, button.UseCompatibleTextRendering);
369 Size image_size = image == null ? Size.Empty : image.Size;
371 textRectangle = Rectangle.Empty;
372 imageRectangle = Rectangle.Empty;
374 switch (button.TextImageRelation) {
375 case TextImageRelation.Overlay:
376 // Overlay is easy, text always goes here
377 textRectangle = Rectangle.Inflate (content_rect, -4, -4);
380 textRectangle.Offset (1, 1);
382 // Image is dependent on ImageAlign
388 int image_height = image.Height;
389 int image_width = image.Width;
391 switch (button.ImageAlign) {
392 case System.Drawing.ContentAlignment.TopLeft:
396 case System.Drawing.ContentAlignment.TopCenter:
397 image_x = (content_rect.Width - image_width) / 2;
400 case System.Drawing.ContentAlignment.TopRight:
401 image_x = content_rect.Width - image_width - 5;
404 case System.Drawing.ContentAlignment.MiddleLeft:
406 image_y = (content_rect.Height - image_height) / 2;
408 case System.Drawing.ContentAlignment.MiddleCenter:
409 image_x = (content_rect.Width - image_width) / 2;
410 image_y = (content_rect.Height - image_height) / 2;
412 case System.Drawing.ContentAlignment.MiddleRight:
413 image_x = content_rect.Width - image_width - 4;
414 image_y = (content_rect.Height - image_height) / 2;
416 case System.Drawing.ContentAlignment.BottomLeft:
418 image_y = content_rect.Height - image_height - 4;
420 case System.Drawing.ContentAlignment.BottomCenter:
421 image_x = (content_rect.Width - image_width) / 2;
422 image_y = content_rect.Height - image_height - 4;
424 case System.Drawing.ContentAlignment.BottomRight:
425 image_x = content_rect.Width - image_width - 4;
426 image_y = content_rect.Height - image_height - 4;
434 imageRectangle = new Rectangle (image_x, image_y, image_width, image_height);
436 case TextImageRelation.ImageAboveText:
437 content_rect.Inflate (-4, -4);
438 LayoutTextAboveOrBelowImage (content_rect, false, text_size, image_size, button.TextAlign, button.ImageAlign, out textRectangle, out imageRectangle);
440 case TextImageRelation.TextAboveImage:
441 content_rect.Inflate (-4, -4);
442 LayoutTextAboveOrBelowImage (content_rect, true, text_size, image_size, button.TextAlign, button.ImageAlign, out textRectangle, out imageRectangle);
444 case TextImageRelation.ImageBeforeText:
445 content_rect.Inflate (-4, -4);
446 LayoutTextBeforeOrAfterImage (content_rect, false, text_size, image_size, button.TextAlign, button.ImageAlign, out textRectangle, out imageRectangle);
448 case TextImageRelation.TextBeforeImage:
449 content_rect.Inflate (-4, -4);
450 LayoutTextBeforeOrAfterImage (content_rect, true, text_size, image_size, button.TextAlign, button.ImageAlign, out textRectangle, out imageRectangle);
455 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)
457 int element_spacing = 0; // Spacing between the Text and the Image
458 int total_width = textSize.Width + element_spacing + imageSize.Width;
461 element_spacing += 2;
463 // If the text is too big, chop it down to the size we have available to it
464 if (total_width > totalArea.Width) {
465 textSize.Width = totalArea.Width - element_spacing - imageSize.Width;
466 total_width = totalArea.Width;
469 int excess_width = totalArea.Width - total_width;
472 Rectangle final_text_rect;
473 Rectangle final_image_rect;
475 HorizontalAlignment h_text = GetHorizontalAlignment (textAlign);
476 HorizontalAlignment h_image = GetHorizontalAlignment (imageAlign);
478 if (h_image == HorizontalAlignment.Left)
480 else if (h_image == HorizontalAlignment.Right && h_text == HorizontalAlignment.Right)
481 offset = excess_width;
482 else if (h_image == HorizontalAlignment.Center && (h_text == HorizontalAlignment.Left || h_text == HorizontalAlignment.Center))
483 offset += (int)(excess_width / 3);
485 offset += (int)(2 * (excess_width / 3));
488 final_text_rect = new Rectangle (totalArea.Left + offset, AlignInRectangle (totalArea, textSize, textAlign).Top, textSize.Width, textSize.Height);
489 final_image_rect = new Rectangle (final_text_rect.Right + element_spacing, AlignInRectangle (totalArea, imageSize, imageAlign).Top, imageSize.Width, imageSize.Height);
492 final_image_rect = new Rectangle (totalArea.Left + offset, AlignInRectangle (totalArea, imageSize, imageAlign).Top, imageSize.Width, imageSize.Height);
493 final_text_rect = new Rectangle (final_image_rect.Right + element_spacing, AlignInRectangle (totalArea, textSize, textAlign).Top, textSize.Width, textSize.Height);
496 textRect = final_text_rect;
497 imageRect = final_image_rect;
500 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)
502 int element_spacing = 0; // Spacing between the Text and the Image
503 int total_height = textSize.Height + element_spacing + imageSize.Height;
506 element_spacing += 2;
508 if (textSize.Width > totalArea.Width)
509 textSize.Width = totalArea.Width;
511 // If the there isn't enough room and we're text first, cut out the image
512 if (total_height > totalArea.Height && textFirst) {
513 imageSize = Size.Empty;
514 total_height = totalArea.Height;
517 int excess_height = totalArea.Height - total_height;
520 Rectangle final_text_rect;
521 Rectangle final_image_rect;
523 VerticalAlignment v_text = GetVerticalAlignment (textAlign);
524 VerticalAlignment v_image = GetVerticalAlignment (imageAlign);
526 if (v_image == VerticalAlignment.Top)
528 else if (v_image == VerticalAlignment.Bottom && v_text == VerticalAlignment.Bottom)
529 offset = excess_height;
530 else if (v_image == VerticalAlignment.Center && (v_text == VerticalAlignment.Top || v_text == VerticalAlignment.Center))
531 offset += (int)(excess_height / 3);
533 offset += (int)(2 * (excess_height / 3));
536 final_text_rect = new Rectangle (AlignInRectangle (totalArea, textSize, textAlign).Left, totalArea.Top + offset, textSize.Width, textSize.Height);
537 final_image_rect = new Rectangle (AlignInRectangle (totalArea, imageSize, imageAlign).Left, final_text_rect.Bottom + element_spacing, imageSize.Width, imageSize.Height);
540 final_image_rect = new Rectangle (AlignInRectangle (totalArea, imageSize, imageAlign).Left, totalArea.Top + offset, imageSize.Width, imageSize.Height);
541 final_text_rect = new Rectangle (AlignInRectangle (totalArea, textSize, textAlign).Left, final_image_rect.Bottom + element_spacing, textSize.Width, textSize.Height);
543 if (final_text_rect.Bottom > totalArea.Bottom)
544 final_text_rect.Y = totalArea.Top;
547 textRect = final_text_rect;
548 imageRect = final_image_rect;
551 private HorizontalAlignment GetHorizontalAlignment (System.Drawing.ContentAlignment align)
554 case System.Drawing.ContentAlignment.BottomLeft:
555 case System.Drawing.ContentAlignment.MiddleLeft:
556 case System.Drawing.ContentAlignment.TopLeft:
557 return HorizontalAlignment.Left;
558 case System.Drawing.ContentAlignment.BottomCenter:
559 case System.Drawing.ContentAlignment.MiddleCenter:
560 case System.Drawing.ContentAlignment.TopCenter:
561 return HorizontalAlignment.Center;
562 case System.Drawing.ContentAlignment.BottomRight:
563 case System.Drawing.ContentAlignment.MiddleRight:
564 case System.Drawing.ContentAlignment.TopRight:
565 return HorizontalAlignment.Right;
568 return HorizontalAlignment.Left;
571 private enum VerticalAlignment
578 private VerticalAlignment GetVerticalAlignment (System.Drawing.ContentAlignment align)
581 case System.Drawing.ContentAlignment.TopLeft:
582 case System.Drawing.ContentAlignment.TopCenter:
583 case System.Drawing.ContentAlignment.TopRight:
584 return VerticalAlignment.Top;
585 case System.Drawing.ContentAlignment.MiddleLeft:
586 case System.Drawing.ContentAlignment.MiddleCenter:
587 case System.Drawing.ContentAlignment.MiddleRight:
588 return VerticalAlignment.Center;
589 case System.Drawing.ContentAlignment.BottomLeft:
590 case System.Drawing.ContentAlignment.BottomCenter:
591 case System.Drawing.ContentAlignment.BottomRight:
592 return VerticalAlignment.Bottom;
595 return VerticalAlignment.Top;
598 internal Rectangle AlignInRectangle (Rectangle outer, Size inner, System.Drawing.ContentAlignment align)
603 if (align == System.Drawing.ContentAlignment.BottomLeft || align == System.Drawing.ContentAlignment.MiddleLeft || align == System.Drawing.ContentAlignment.TopLeft)
605 else if (align == System.Drawing.ContentAlignment.BottomCenter || align == System.Drawing.ContentAlignment.MiddleCenter || align == System.Drawing.ContentAlignment.TopCenter)
606 x = Math.Max (outer.X + ((outer.Width - inner.Width) / 2), outer.Left);
607 else if (align == System.Drawing.ContentAlignment.BottomRight || align == System.Drawing.ContentAlignment.MiddleRight || align == System.Drawing.ContentAlignment.TopRight)
608 x = outer.Right - inner.Width;
609 if (align == System.Drawing.ContentAlignment.TopCenter || align == System.Drawing.ContentAlignment.TopLeft || align == System.Drawing.ContentAlignment.TopRight)
611 else if (align == System.Drawing.ContentAlignment.MiddleCenter || align == System.Drawing.ContentAlignment.MiddleLeft || align == System.Drawing.ContentAlignment.MiddleRight)
612 y = outer.Y + (outer.Height - inner.Height) / 2;
613 else if (align == System.Drawing.ContentAlignment.BottomCenter || align == System.Drawing.ContentAlignment.BottomRight || align == System.Drawing.ContentAlignment.BottomLeft)
614 y = outer.Bottom - inner.Height;
616 return new Rectangle (x, y, Math.Min (inner.Width, outer.Width), Math.Min (inner.Height, outer.Height));
622 public override void DrawButtonBase(Graphics dc, Rectangle clip_area, ButtonBase button)
624 // Draw the button: Draw border, etc.
625 ButtonBase_DrawButton(button, dc);
628 if (button.FlatStyle != FlatStyle.System && ((button.image != null) || (button.image_list != null)))
629 ButtonBase_DrawImage(button, dc);
631 // Draw the focus rectangle
632 if (ShouldPaintFocusRectagle (button))
633 ButtonBase_DrawFocus(button, dc);
636 if (button.Text != null && button.Text != String.Empty)
637 ButtonBase_DrawText(button, dc);
640 protected static bool ShouldPaintFocusRectagle (ButtonBase button)
642 return (button.Focused || button.paint_as_acceptbutton) && button.Enabled && button.ShowFocusCues;
645 protected virtual void ButtonBase_DrawButton (ButtonBase button, Graphics dc)
647 Rectangle borderRectangle;
648 bool check_or_radio = false;
649 bool check_or_radio_checked = false;
651 bool is_ColorControl = button.BackColor.ToArgb () == ColorControl.ToArgb () ? true : false;
653 CPColor cpcolor = is_ColorControl ? CPColor.Empty : ResPool.GetCPColor (button.BackColor);
655 if (button is CheckBox) {
656 check_or_radio = true;
657 check_or_radio_checked = ((CheckBox)button).Checked;
658 } else if (button is RadioButton) {
659 check_or_radio = true;
660 check_or_radio_checked = ((RadioButton)button).Checked;
663 if ((button.Focused || button.paint_as_acceptbutton) && button.Enabled && !check_or_radio) {
664 // shrink the rectangle for the normal button drawing inside the focus rectangle
665 borderRectangle = Rectangle.Inflate (button.ClientRectangle, -1, -1);
667 borderRectangle = button.ClientRectangle;
670 if (button.FlatStyle == FlatStyle.Popup) {
671 if (!button.is_pressed && !button.is_entered && !check_or_radio_checked)
672 Internal_DrawButton (dc, borderRectangle, 1, cpcolor, is_ColorControl, button.BackColor);
673 else if (!button.is_pressed && button.is_entered &&!check_or_radio_checked)
674 Internal_DrawButton (dc, borderRectangle, 2, cpcolor, is_ColorControl, button.BackColor);
675 else if (button.is_pressed || check_or_radio_checked)
676 Internal_DrawButton (dc, borderRectangle, 1, cpcolor, is_ColorControl, button.BackColor);
677 } else if (button.FlatStyle == FlatStyle.Flat) {
678 if (button.is_entered && !button.is_pressed && !check_or_radio_checked) {
679 if ((button.image == null) && (button.image_list == null)) {
680 Brush brush = is_ColorControl ? SystemBrushes.ControlDark : ResPool.GetSolidBrush (cpcolor.Dark);
681 dc.FillRectangle (brush, borderRectangle);
683 } else if (button.is_pressed || check_or_radio_checked) {
684 if ((button.image == null) && (button.image_list == null)) {
685 Brush brush = is_ColorControl ? SystemBrushes.ControlLightLight : ResPool.GetSolidBrush (cpcolor.LightLight);
686 dc.FillRectangle (brush, borderRectangle);
689 Pen pen = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
690 dc.DrawRectangle (pen, borderRectangle.X + 4, borderRectangle.Y + 4,
691 borderRectangle.Width - 9, borderRectangle.Height - 9);
694 Internal_DrawButton (dc, borderRectangle, 3, cpcolor, is_ColorControl, button.BackColor);
696 if ((!button.is_pressed || !button.Enabled) && !check_or_radio_checked)
697 Internal_DrawButton (dc, borderRectangle, 0, cpcolor, is_ColorControl, button.BackColor);
699 Internal_DrawButton (dc, borderRectangle, 1, cpcolor, is_ColorControl, button.BackColor);
703 private void Internal_DrawButton (Graphics dc, Rectangle rect, int state, CPColor cpcolor, bool is_ColorControl, Color backcolor)
706 case 0: // normal or normal disabled button
707 Pen pen = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
708 dc.DrawLine (pen, rect.X, rect.Y, rect.X, rect.Bottom - 2);
709 dc.DrawLine (pen, rect.X + 1, rect.Y, rect.Right - 2, rect.Y);
711 pen = is_ColorControl ? SystemPens.Control : ResPool.GetPen (backcolor);
712 dc.DrawLine (pen, rect.X + 1, rect.Y + 1, rect.X + 1, rect.Bottom - 3);
713 dc.DrawLine (pen, rect.X + 2, rect.Y + 1, rect.Right - 3, rect.Y + 1);
715 pen = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
716 dc.DrawLine (pen, rect.X + 1, rect.Bottom - 2, rect.Right - 2, rect.Bottom - 2);
717 dc.DrawLine (pen, rect.Right - 2, rect.Y + 1, rect.Right - 2, rect.Bottom - 3);
719 pen = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
720 dc.DrawLine (pen, rect.X, rect.Bottom - 1, rect.Right - 1, rect.Bottom - 1);
721 dc.DrawLine (pen, rect.Right - 1, rect.Y, rect.Right - 1, rect.Bottom - 2);
723 case 1: // popup button normal (or pressed normal or popup button)
724 pen = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
725 dc.DrawRectangle (pen, rect.X, rect.Y, rect.Width - 1, rect.Height - 1);
727 case 2: // popup button poped up
728 pen = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
729 dc.DrawLine (pen, rect.X, rect.Y, rect.X, rect.Bottom - 2);
730 dc.DrawLine (pen, rect.X + 1, rect.Y, rect.Right - 2, rect.Y);
732 pen = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
733 dc.DrawLine (pen, rect.X, rect.Bottom - 1, rect.Right - 1, rect.Bottom - 1);
734 dc.DrawLine (pen, rect.Right - 1, rect.Y, rect.Right - 1, rect.Bottom - 2);
736 case 3: // flat button not entered
737 pen = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
738 dc.DrawRectangle (pen, rect.X, rect.Y, rect.Width - 1, rect.Height - 1);
745 protected virtual void ButtonBase_DrawImage(ButtonBase button, Graphics dc)
747 // Need to draw a picture
754 int width = button.ClientSize.Width;
755 int height = button.ClientSize.Height;
757 if (button.ImageIndex != -1) { // We use ImageIndex instead of image_index since it will return -1 if image_list is null
758 i = button.image_list.Images[button.ImageIndex];
763 image_width = i.Width;
764 image_height = i.Height;
766 switch (button.ImageAlign) {
767 case ContentAlignment.TopLeft: {
773 case ContentAlignment.TopCenter: {
774 image_x = (width - image_width) / 2;
779 case ContentAlignment.TopRight: {
780 image_x = width - image_width - 5;
785 case ContentAlignment.MiddleLeft: {
787 image_y = (height - image_height) / 2;
791 case ContentAlignment.MiddleCenter: {
792 image_x = (width - image_width) / 2;
793 image_y = (height - image_height) / 2;
797 case ContentAlignment.MiddleRight: {
798 image_x = width - image_width - 4;
799 image_y = (height - image_height) / 2;
803 case ContentAlignment.BottomLeft: {
805 image_y = height - image_height - 4;
809 case ContentAlignment.BottomCenter: {
810 image_x = (width - image_width) / 2;
811 image_y = height - image_height - 4;
815 case ContentAlignment.BottomRight: {
816 image_x = width - image_width - 4;
817 image_y = height - image_height - 4;
828 dc.SetClip (new Rectangle(3, 3, width - 5, height - 5));
831 dc.DrawImage (i, image_x, image_y, image_width, image_height);
833 CPDrawImageDisabled (dc, i, image_x, image_y, ColorControl);
838 protected virtual void ButtonBase_DrawFocus(ButtonBase button, Graphics dc)
840 Color focus_color = button.ForeColor;
842 int inflate_value = -3;
844 if (!(button is CheckBox) && !(button is RadioButton)) {
847 if (button.FlatStyle == FlatStyle.Popup && !button.is_pressed)
848 focus_color = ControlPaint.Dark(button.BackColor);
850 dc.DrawRectangle (ResPool.GetPen (focus_color), button.ClientRectangle.X, button.ClientRectangle.Y,
851 button.ClientRectangle.Width - 1, button.ClientRectangle.Height - 1);
854 if (button.Focused) {
855 Rectangle rect = Rectangle.Inflate (button.ClientRectangle, inflate_value, inflate_value);
856 ControlPaint.DrawFocusRectangle (dc, rect);
860 protected virtual void ButtonBase_DrawText(ButtonBase button, Graphics dc)
862 Rectangle buttonRectangle = button.ClientRectangle;
863 Rectangle text_rect = Rectangle.Inflate(buttonRectangle, -4, -4);
865 if (button.is_pressed) {
870 // Ensure that at least one line is going to get displayed.
871 // Line limit does not ensure that despite its description.
872 text_rect.Height = Math.Max (button.Font.Height, text_rect.Height);
874 if (button.Enabled) {
875 dc.DrawString(button.Text, button.Font, ResPool.GetSolidBrush (button.ForeColor), text_rect, button.text_format);
877 if (button.FlatStyle == FlatStyle.Flat || button.FlatStyle == FlatStyle.Popup) {
878 dc.DrawString(button.Text, button.Font, ResPool.GetSolidBrush (ColorGrayText), text_rect, button.text_format);
880 CPDrawStringDisabled (dc, button.Text, button.Font, button.BackColor, text_rect, button.text_format);
885 public override Size ButtonBaseDefaultSize {
887 return new Size (75, 23);
890 #endregion // ButtonBase
894 public override void DrawCheckBox (Graphics g, CheckBox cb, Rectangle glyphArea, Rectangle textBounds, Rectangle imageBounds, Rectangle clipRectangle)
896 // Draw Button Background
897 if (cb.Appearance == Appearance.Button && cb.FlatStyle != FlatStyle.Flat)
898 ButtonBase_DrawButton (cb, g);
899 else if (cb.Appearance != Appearance.Button)
900 DrawCheckBoxGlyph (g, cb, glyphArea);
902 // Draw the borders and such for a Flat CheckBox Button
903 if (cb.Appearance == Appearance.Button && cb.FlatStyle == FlatStyle.Flat)
904 DrawFlatButton (g, cb, textBounds, imageBounds, clipRectangle);
906 // If we have an image, draw it
907 if (imageBounds.Size != Size.Empty)
908 DrawCheckBoxImage (g, cb, imageBounds);
910 if (cb.Focused && cb.Enabled && cb.ShowFocusCues && textBounds != Rectangle.Empty)
911 DrawCheckBoxFocus (g, cb, textBounds);
913 // If we have text, draw it
914 if (textBounds != Rectangle.Empty)
915 DrawCheckBoxText (g, cb, textBounds);
918 public virtual void DrawCheckBoxGlyph (Graphics g, CheckBox cb, Rectangle glyphArea)
921 ThemeElements.CurrentTheme.CheckBoxPainter.PaintCheckBox (g, glyphArea, cb.BackColor, cb.ForeColor, ElementState.Pressed, cb.FlatStyle, cb.CheckState);
922 else if (cb.InternalSelected)
923 ThemeElements.CurrentTheme.CheckBoxPainter.PaintCheckBox (g, glyphArea, cb.BackColor, cb.ForeColor, ElementState.Normal, cb.FlatStyle, cb.CheckState);
925 ThemeElements.CurrentTheme.CheckBoxPainter.PaintCheckBox (g, glyphArea, cb.BackColor, cb.ForeColor, ElementState.Hot, cb.FlatStyle, cb.CheckState);
926 else if (!cb.Enabled)
927 ThemeElements.CurrentTheme.CheckBoxPainter.PaintCheckBox (g, glyphArea, cb.BackColor, cb.ForeColor, ElementState.Disabled, cb.FlatStyle, cb.CheckState);
929 ThemeElements.CurrentTheme.CheckBoxPainter.PaintCheckBox (g, glyphArea, cb.BackColor, cb.ForeColor, ElementState.Normal, cb.FlatStyle, cb.CheckState);
932 public virtual void DrawCheckBoxFocus (Graphics g, CheckBox cb, Rectangle focusArea)
934 ControlPaint.DrawFocusRectangle (g, focusArea);
937 public virtual void DrawCheckBoxImage (Graphics g, CheckBox cb, Rectangle imageBounds)
940 g.DrawImage (cb.Image, imageBounds);
942 CPDrawImageDisabled (g, cb.Image, imageBounds.Left, imageBounds.Top, ColorControl);
945 public virtual void DrawCheckBoxText (Graphics g, CheckBox cb, Rectangle textBounds)
948 TextRenderer.DrawTextInternal (g, cb.Text, cb.Font, textBounds, cb.ForeColor, cb.TextFormatFlags, cb.UseCompatibleTextRendering);
950 DrawStringDisabled20 (g, cb.Text, cb.Font, textBounds, cb.BackColor, cb.TextFormatFlags, cb.UseCompatibleTextRendering);
953 public override void CalculateCheckBoxTextAndImageLayout (ButtonBase button, Point p, out Rectangle glyphArea, out Rectangle textRectangle, out Rectangle imageRectangle)
957 if (button is CheckBox)
958 check_size = (button as CheckBox).Appearance == Appearance.Normal ? 13 : 0;
960 glyphArea = new Rectangle (0, (button.Height - check_size) / 2, check_size, check_size);
962 Image image = button.Image;
963 string text = button.Text;
964 Rectangle content_rect = button.ClientRectangle;
965 content_rect.Width -= check_size;
966 content_rect.Offset (check_size, 0);
968 Size proposed = Size.Empty;
970 // Force wrapping if we aren't AutoSize and our text is too long
971 if (!button.AutoSize)
972 proposed.Width = button.Width - glyphArea.Width - 2;
974 Size text_size = TextRenderer.MeasureTextInternal (text, button.Font, proposed, button.TextFormatFlags, button.UseCompatibleTextRendering);
976 // Text can't be bigger than the content rectangle
977 text_size.Height = Math.Min (text_size.Height, content_rect.Height);
978 text_size.Width = Math.Min (text_size.Width, content_rect.Width);
980 Size image_size = image == null ? Size.Empty : image.Size;
982 textRectangle = Rectangle.Empty;
983 imageRectangle = Rectangle.Empty;
985 switch (button.TextImageRelation) {
986 case TextImageRelation.Overlay:
987 // Text is centered vertically, and 2 pixels to the right
988 textRectangle.X = content_rect.Left + 2;
989 textRectangle.Y = ((content_rect.Height - text_size.Height) / 2) - 1;
990 textRectangle.Size = text_size;
992 // Image is dependent on ImageAlign
998 int image_height = image.Height;
999 int image_width = image.Width;
1001 switch (button.ImageAlign) {
1002 case System.Drawing.ContentAlignment.TopLeft:
1006 case System.Drawing.ContentAlignment.TopCenter:
1007 image_x = (content_rect.Width - image_width) / 2;
1010 case System.Drawing.ContentAlignment.TopRight:
1011 image_x = content_rect.Width - image_width - 5;
1014 case System.Drawing.ContentAlignment.MiddleLeft:
1016 image_y = (content_rect.Height - image_height) / 2;
1018 case System.Drawing.ContentAlignment.MiddleCenter:
1019 image_x = (content_rect.Width - image_width) / 2;
1020 image_y = (content_rect.Height - image_height) / 2;
1022 case System.Drawing.ContentAlignment.MiddleRight:
1023 image_x = content_rect.Width - image_width - 4;
1024 image_y = (content_rect.Height - image_height) / 2;
1026 case System.Drawing.ContentAlignment.BottomLeft:
1028 image_y = content_rect.Height - image_height - 4;
1030 case System.Drawing.ContentAlignment.BottomCenter:
1031 image_x = (content_rect.Width - image_width) / 2;
1032 image_y = content_rect.Height - image_height - 4;
1034 case System.Drawing.ContentAlignment.BottomRight:
1035 image_x = content_rect.Width - image_width - 4;
1036 image_y = content_rect.Height - image_height - 4;
1044 imageRectangle = new Rectangle (image_x + check_size, image_y, image_width, image_height);
1046 case TextImageRelation.ImageAboveText:
1047 content_rect.Inflate (-4, -4);
1048 LayoutTextAboveOrBelowImage (content_rect, false, text_size, image_size, button.TextAlign, button.ImageAlign, out textRectangle, out imageRectangle);
1050 case TextImageRelation.TextAboveImage:
1051 content_rect.Inflate (-4, -4);
1052 LayoutTextAboveOrBelowImage (content_rect, true, text_size, image_size, button.TextAlign, button.ImageAlign, out textRectangle, out imageRectangle);
1054 case TextImageRelation.ImageBeforeText:
1055 content_rect.Inflate (-4, -4);
1056 LayoutTextBeforeOrAfterImage (content_rect, false, text_size, image_size, button.TextAlign, button.ImageAlign, out textRectangle, out imageRectangle);
1058 case TextImageRelation.TextBeforeImage:
1059 content_rect.Inflate (-4, -4);
1060 LayoutTextBeforeOrAfterImage (content_rect, true, text_size, image_size, button.TextAlign, button.ImageAlign, out textRectangle, out imageRectangle);
1065 public override Size CalculateCheckBoxAutoSize (CheckBox checkBox)
1067 Size ret_size = Size.Empty;
1068 Size text_size = TextRenderer.MeasureTextInternal (checkBox.Text, checkBox.Font, checkBox.UseCompatibleTextRendering);
1069 Size image_size = checkBox.Image == null ? Size.Empty : checkBox.Image.Size;
1071 // Pad the text size
1072 if (checkBox.Text.Length != 0) {
1073 text_size.Height += 4;
1074 text_size.Width += 4;
1077 switch (checkBox.TextImageRelation) {
1078 case TextImageRelation.Overlay:
1079 ret_size.Height = Math.Max (checkBox.Text.Length == 0 ? 0 : text_size.Height, image_size.Height);
1080 ret_size.Width = Math.Max (text_size.Width, image_size.Width);
1082 case TextImageRelation.ImageAboveText:
1083 case TextImageRelation.TextAboveImage:
1084 ret_size.Height = text_size.Height + image_size.Height;
1085 ret_size.Width = Math.Max (text_size.Width, image_size.Width);
1087 case TextImageRelation.ImageBeforeText:
1088 case TextImageRelation.TextBeforeImage:
1089 ret_size.Height = Math.Max (text_size.Height, image_size.Height);
1090 ret_size.Width = text_size.Width + image_size.Width;
1095 ret_size.Height += (checkBox.Padding.Vertical);
1096 ret_size.Width += (checkBox.Padding.Horizontal) + 15;
1098 // There seems to be a minimum height
1099 if (ret_size.Height == checkBox.Padding.Vertical)
1100 ret_size.Height += 14;
1106 public override void DrawCheckBox(Graphics dc, Rectangle clip_area, CheckBox checkbox) {
1107 StringFormat text_format;
1108 Rectangle client_rectangle;
1109 Rectangle text_rectangle;
1110 Rectangle checkbox_rectangle;
1111 int checkmark_size=13;
1112 int checkmark_space = 4;
1114 client_rectangle = checkbox.ClientRectangle;
1115 text_rectangle = client_rectangle;
1116 checkbox_rectangle = new Rectangle(text_rectangle.X, text_rectangle.Y, checkmark_size, checkmark_size);
1118 text_format = new StringFormat();
1119 text_format.Alignment = StringAlignment.Near;
1120 text_format.LineAlignment = StringAlignment.Center;
1121 if (checkbox.ShowKeyboardCuesInternal)
1122 text_format.HotkeyPrefix = HotkeyPrefix.Show;
1124 text_format.HotkeyPrefix = HotkeyPrefix.Hide;
1126 /* Calculate the position of text and checkbox rectangle */
1127 if (checkbox.appearance!=Appearance.Button) {
1128 switch(checkbox.check_alignment) {
1129 case ContentAlignment.BottomCenter: {
1130 checkbox_rectangle.X=(client_rectangle.Right-client_rectangle.Left)/2-checkmark_size/2;
1131 checkbox_rectangle.Y=client_rectangle.Bottom-checkmark_size;
1132 text_rectangle.X=client_rectangle.X;
1133 text_rectangle.Width=client_rectangle.Width;
1134 text_rectangle.Height=client_rectangle.Height-checkbox_rectangle.Y-checkmark_space;
1138 case ContentAlignment.BottomLeft: {
1139 checkbox_rectangle.X=client_rectangle.Left;
1140 checkbox_rectangle.Y=client_rectangle.Bottom-checkmark_size;
1141 text_rectangle.X=client_rectangle.X+checkmark_size+checkmark_space;
1142 text_rectangle.Width=client_rectangle.Width-checkmark_size-checkmark_space;
1146 case ContentAlignment.BottomRight: {
1147 checkbox_rectangle.X=client_rectangle.Right-checkmark_size;
1148 checkbox_rectangle.Y=client_rectangle.Bottom-checkmark_size;
1149 text_rectangle.X=client_rectangle.X;
1150 text_rectangle.Width=client_rectangle.Width-checkmark_size-checkmark_space;
1154 case ContentAlignment.MiddleCenter: {
1155 checkbox_rectangle.X=(client_rectangle.Right-client_rectangle.Left)/2-checkmark_size/2;
1156 checkbox_rectangle.Y=(client_rectangle.Bottom-client_rectangle.Top)/2-checkmark_size/2;
1157 text_rectangle.X=client_rectangle.X;
1158 text_rectangle.Width=client_rectangle.Width;
1163 case ContentAlignment.MiddleLeft: {
1164 checkbox_rectangle.X=client_rectangle.Left;
1165 checkbox_rectangle.Y=(client_rectangle.Bottom-client_rectangle.Top)/2-checkmark_size/2;
1166 text_rectangle.X=client_rectangle.X+checkmark_size+checkmark_space;
1167 text_rectangle.Width=client_rectangle.Width-checkmark_size-checkmark_space;
1171 case ContentAlignment.MiddleRight: {
1172 checkbox_rectangle.X=client_rectangle.Right-checkmark_size;
1173 checkbox_rectangle.Y=(client_rectangle.Bottom-client_rectangle.Top)/2-checkmark_size/2;
1174 text_rectangle.X=client_rectangle.X;
1175 text_rectangle.Width=client_rectangle.Width-checkmark_size-checkmark_space;
1179 case ContentAlignment.TopCenter: {
1180 checkbox_rectangle.X=(client_rectangle.Right-client_rectangle.Left)/2-checkmark_size/2;
1181 checkbox_rectangle.Y=client_rectangle.Top;
1182 text_rectangle.X=client_rectangle.X;
1183 text_rectangle.Width=client_rectangle.Width;
1184 text_rectangle.Y=checkmark_size+checkmark_space;
1185 text_rectangle.Height=client_rectangle.Height-checkmark_size-checkmark_space;
1189 case ContentAlignment.TopLeft: {
1190 checkbox_rectangle.X=client_rectangle.Left;
1191 text_rectangle.X=client_rectangle.X+checkmark_size+checkmark_space;
1192 text_rectangle.Width=client_rectangle.Width-checkmark_size-checkmark_space;
1196 case ContentAlignment.TopRight: {
1197 checkbox_rectangle.X=client_rectangle.Right-checkmark_size;
1198 text_rectangle.X=client_rectangle.X;
1199 text_rectangle.Width=client_rectangle.Width-checkmark_size-checkmark_space;
1204 text_rectangle.X=client_rectangle.X;
1205 text_rectangle.Width=client_rectangle.Width;
1208 /* Set the horizontal alignment of our text */
1209 switch(checkbox.text_alignment) {
1210 case ContentAlignment.BottomLeft:
1211 case ContentAlignment.MiddleLeft:
1212 case ContentAlignment.TopLeft: {
1213 text_format.Alignment=StringAlignment.Near;
1217 case ContentAlignment.BottomCenter:
1218 case ContentAlignment.MiddleCenter:
1219 case ContentAlignment.TopCenter: {
1220 text_format.Alignment=StringAlignment.Center;
1224 case ContentAlignment.BottomRight:
1225 case ContentAlignment.MiddleRight:
1226 case ContentAlignment.TopRight: {
1227 text_format.Alignment=StringAlignment.Far;
1232 /* Set the vertical alignment of our text */
1233 switch(checkbox.text_alignment) {
1234 case ContentAlignment.TopLeft:
1235 case ContentAlignment.TopCenter:
1236 case ContentAlignment.TopRight: {
1237 text_format.LineAlignment=StringAlignment.Near;
1241 case ContentAlignment.BottomLeft:
1242 case ContentAlignment.BottomCenter:
1243 case ContentAlignment.BottomRight: {
1244 text_format.LineAlignment=StringAlignment.Far;
1248 case ContentAlignment.MiddleLeft:
1249 case ContentAlignment.MiddleCenter:
1250 case ContentAlignment.MiddleRight: {
1251 text_format.LineAlignment=StringAlignment.Center;
1256 ButtonState state = ButtonState.Normal;
1257 if (checkbox.FlatStyle == FlatStyle.Flat) {
1258 state |= ButtonState.Flat;
1261 if (checkbox.Checked) {
1262 state |= ButtonState.Checked;
1265 if (checkbox.ThreeState && (checkbox.CheckState == CheckState.Indeterminate)) {
1266 state |= ButtonState.Checked;
1267 state |= ButtonState.Pushed;
1270 // finally make sure the pushed and inavtive states are rendered
1271 if (!checkbox.Enabled) {
1272 state |= ButtonState.Inactive;
1274 else if (checkbox.is_pressed) {
1275 state |= ButtonState.Pushed;
1280 CheckBox_DrawCheckBox(dc, checkbox, state, checkbox_rectangle);
1282 if ((checkbox.image != null) || (checkbox.image_list != null))
1283 ButtonBase_DrawImage(checkbox, dc);
1285 CheckBox_DrawText(checkbox, text_rectangle, dc, text_format);
1287 if (checkbox.Focused && checkbox.Enabled && checkbox.appearance != Appearance.Button && checkbox.Text != String.Empty && checkbox.ShowFocusCues) {
1288 SizeF text_size = dc.MeasureString (checkbox.Text, checkbox.Font);
1290 Rectangle focus_rect = Rectangle.Empty;
1291 focus_rect.X = text_rectangle.X;
1292 focus_rect.Y = (int)((text_rectangle.Height - text_size.Height) / 2);
1293 focus_rect.Size = text_size.ToSize ();
1294 CheckBox_DrawFocus (checkbox, dc, focus_rect);
1297 text_format.Dispose ();
1300 protected virtual void CheckBox_DrawCheckBox( Graphics dc, CheckBox checkbox, ButtonState state, Rectangle checkbox_rectangle )
1302 Brush brush = checkbox.BackColor.ToArgb () == ColorControl.ToArgb () ? SystemBrushes.Control : ResPool.GetSolidBrush (checkbox.BackColor);
1303 dc.FillRectangle (brush, checkbox.ClientRectangle);
1304 // render as per normal button
1305 if (checkbox.appearance==Appearance.Button) {
1306 ButtonBase_DrawButton (checkbox, dc);
1308 if ((checkbox.Focused) && checkbox.Enabled)
1309 ButtonBase_DrawFocus(checkbox, dc);
1311 // establish if we are rendering a flat style of some sort
1312 if (checkbox.FlatStyle == FlatStyle.Flat || checkbox.FlatStyle == FlatStyle.Popup) {
1313 DrawFlatStyleCheckBox (dc, checkbox_rectangle, checkbox);
1315 CPDrawCheckBox (dc, checkbox_rectangle, state);
1320 protected virtual void CheckBox_DrawText( CheckBox checkbox, Rectangle text_rectangle, Graphics dc, StringFormat text_format )
1322 DrawCheckBox_and_RadioButtonText (checkbox, text_rectangle, dc,
1323 text_format, checkbox.Appearance, checkbox.Checked);
1326 protected virtual void CheckBox_DrawFocus( CheckBox checkbox, Graphics dc, Rectangle text_rectangle )
1328 DrawInnerFocusRectangle (dc, text_rectangle, checkbox.BackColor);
1331 // renders a checkBox with the Flat and Popup FlatStyle
1332 protected virtual void DrawFlatStyleCheckBox (Graphics graphics, Rectangle rectangle, CheckBox checkbox)
1336 Rectangle checkbox_rectangle;
1337 Rectangle fill_rectangle;
1341 // set up our rectangles first
1342 if (checkbox.FlatStyle == FlatStyle.Popup && checkbox.is_entered) {
1343 // clip one pixel from bottom right for non popup rendered checkboxes
1344 checkbox_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max(rectangle.Width-1, 0), Math.Max(rectangle.Height-1,0));
1345 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));
1347 // clip two pixels from bottom right for non popup rendered checkboxes
1348 checkbox_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max(rectangle.Width-2, 0), Math.Max(rectangle.Height-2,0));
1349 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));
1353 // if disabled render in disabled state
1354 if (checkbox.Enabled) {
1355 // process the state of the checkbox
1356 if (checkbox.is_entered || checkbox.Capture) {
1357 // decide on which background color to use
1358 if (checkbox.FlatStyle == FlatStyle.Popup && checkbox.is_entered && checkbox.Capture) {
1359 graphics.FillRectangle(ResPool.GetSolidBrush (checkbox.BackColor), fill_rectangle);
1360 } else if (checkbox.FlatStyle == FlatStyle.Flat) {
1361 if (!checkbox.is_pressed) {
1362 graphics.FillRectangle(ResPool.GetSolidBrush (checkbox.BackColor), fill_rectangle);
1364 graphics.FillRectangle(ResPool.GetSolidBrush (ControlPaint.LightLight (checkbox.BackColor)), fill_rectangle);
1366 // use regular window background color
1367 graphics.FillRectangle(ResPool.GetSolidBrush (ControlPaint.LightLight (checkbox.BackColor)), fill_rectangle);
1370 // render the outer border
1371 if (checkbox.FlatStyle == FlatStyle.Flat) {
1372 ControlPaint.DrawBorder(graphics, checkbox_rectangle, checkbox.ForeColor, ButtonBorderStyle.Solid);
1374 // draw sunken effect
1375 CPDrawBorder3D (graphics, checkbox_rectangle, Border3DStyle.SunkenInner, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, checkbox.BackColor);
1378 graphics.FillRectangle(ResPool.GetSolidBrush (ControlPaint.LightLight (checkbox.BackColor)), fill_rectangle);
1380 if (checkbox.FlatStyle == FlatStyle.Flat) {
1381 ControlPaint.DrawBorder(graphics, checkbox_rectangle, checkbox.ForeColor, ButtonBorderStyle.Solid);
1383 // draw the outer border
1384 ControlPaint.DrawBorder(graphics, checkbox_rectangle, ControlPaint.DarkDark (checkbox.BackColor), ButtonBorderStyle.Solid);
1388 if (checkbox.FlatStyle == FlatStyle.Popup) {
1389 graphics.FillRectangle(SystemBrushes.Control, fill_rectangle);
1392 // draw disabled state,
1393 ControlPaint.DrawBorder(graphics, checkbox_rectangle, ColorControlDark, ButtonBorderStyle.Solid);
1396 if (checkbox.Checked) {
1397 /* Need to draw a check-mark */
1399 /* Make sure we've got at least a line width of 1 */
1400 lineWidth = Math.Max(3, fill_rectangle.Width/3);
1401 Scale=Math.Max(1, fill_rectangle.Width/9);
1403 // flat style check box is rendered inside a rectangle shifted down by one
1404 rect=new Rectangle(fill_rectangle.X, fill_rectangle.Y+1, fill_rectangle.Width, fill_rectangle.Height);
1405 if (checkbox.Enabled) {
1406 pen=ResPool.GetPen(checkbox.ForeColor);
1408 pen=SystemPens.ControlDark;
1411 for (int i=0; i<lineWidth; i++) {
1412 graphics.DrawLine(pen, rect.Left+lineWidth/2, rect.Top+lineWidth+i, rect.Left+lineWidth/2+2*Scale, rect.Top+lineWidth+2*Scale+i);
1413 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);
1418 private void DrawCheckBox_and_RadioButtonText (ButtonBase button_base, Rectangle text_rectangle, Graphics dc,
1419 StringFormat text_format, Appearance appearance, bool ischecked)
1421 // offset the text if it's pressed and a button
1422 if (appearance == Appearance.Button) {
1423 if (ischecked || (button_base.Capture && button_base.FlatStyle != FlatStyle.Flat)) {
1424 text_rectangle.X ++;
1425 text_rectangle.Y ++;
1428 text_rectangle.Inflate (-4, -4);
1431 /* Place the text; to be compatible with Windows place it after the checkbox has been drawn */
1433 // Windows seems to not wrap text in certain situations, this matches as close as I could get it
1434 if ((float)(button_base.Font.Height * 1.5f) > text_rectangle.Height) {
1435 text_format.FormatFlags |= StringFormatFlags.NoWrap;
1437 if (button_base.Enabled) {
1438 dc.DrawString (button_base.Text, button_base.Font, ResPool.GetSolidBrush (button_base.ForeColor), text_rectangle, text_format);
1439 } else if (button_base.FlatStyle == FlatStyle.Flat || button_base.FlatStyle == FlatStyle.Popup) {
1440 dc.DrawString (button_base.Text, button_base.Font, SystemBrushes.ControlDarkDark, text_rectangle, text_format);
1442 CPDrawStringDisabled (dc, button_base.Text, button_base.Font, button_base.BackColor, text_rectangle, text_format);
1445 #endregion // CheckBox
1447 #region CheckedListBox
1449 public override void DrawCheckedListBoxItem (CheckedListBox ctrl, DrawItemEventArgs e)
1451 Color back_color, fore_color;
1452 Rectangle item_rect = e.Bounds;
1457 if ((e.State & DrawItemState.Checked) == DrawItemState.Checked) {
1458 state = ButtonState.Checked;
1459 if ((e.State & DrawItemState.Inactive) == DrawItemState.Inactive)
1460 state |= ButtonState.Inactive;
1462 state = ButtonState.Normal;
1464 if (ctrl.ThreeDCheckBoxes == false)
1465 state |= ButtonState.Flat;
1467 Rectangle checkbox_rect = new Rectangle (2, (item_rect.Height - 11) / 2, 13, 13);
1468 ControlPaint.DrawCheckBox (e.Graphics,
1469 item_rect.X + checkbox_rect.X, item_rect.Y + checkbox_rect.Y,
1470 checkbox_rect.Width, checkbox_rect.Height,
1473 item_rect.X += checkbox_rect.Right;
1474 item_rect.Width -= checkbox_rect.Right;
1477 if ((e.State & DrawItemState.Selected) == DrawItemState.Selected) {
1478 back_color = ColorHighlight;
1479 fore_color = ColorHighlightText;
1482 back_color = e.BackColor;
1483 fore_color = e.ForeColor;
1486 e.Graphics.FillRectangle (ResPool.GetSolidBrush
1487 (back_color), item_rect);
1489 e.Graphics.DrawString (ctrl.GetItemText (ctrl.Items[e.Index]), e.Font,
1490 ResPool.GetSolidBrush (fore_color),
1491 item_rect, ctrl.StringFormat);
1493 if ((e.State & DrawItemState.Focus) == DrawItemState.Focus) {
1494 CPDrawFocusRectangle (e.Graphics, item_rect,
1495 fore_color, back_color);
1499 #endregion // CheckedListBox
1502 public override void DrawComboBoxItem (ComboBox ctrl, DrawItemEventArgs e)
1504 Color back_color, fore_color;
1505 Rectangle text_draw = e.Bounds;
1506 StringFormat string_format = new StringFormat ();
1507 string_format.FormatFlags = StringFormatFlags.LineLimit;
1509 if ((e.State & DrawItemState.Selected) == DrawItemState.Selected) {
1510 back_color = ColorHighlight;
1511 fore_color = ColorHighlightText;
1514 back_color = e.BackColor;
1515 fore_color = e.ForeColor;
1519 fore_color = ColorInactiveCaptionText;
1521 e.Graphics.FillRectangle (ResPool.GetSolidBrush (back_color), e.Bounds);
1523 if (e.Index != -1) {
1524 e.Graphics.DrawString (ctrl.GetItemText (ctrl.Items[e.Index]), e.Font,
1525 ResPool.GetSolidBrush (fore_color),
1526 text_draw, string_format);
1529 if ((e.State & DrawItemState.Focus) == DrawItemState.Focus) {
1530 CPDrawFocusRectangle (e.Graphics, e.Bounds, fore_color, back_color);
1533 string_format.Dispose ();
1536 public override void DrawFlatStyleComboButton (Graphics graphics, Rectangle rectangle, ButtonState state)
1538 Point[] arrow = new Point[3];
1548 rect=new Rectangle(rectangle.X+rectangle.Width/4, rectangle.Y+rectangle.Height/4, rectangle.Width/2, rectangle.Height/2);
1549 centerX=rect.Left+rect.Width/2;
1550 centerY=rect.Top+rect.Height/2;
1551 shiftX=Math.Max(1, rect.Width/8);
1552 shiftY=Math.Max(1, rect.Height/8);
1554 if ((state & ButtonState.Pushed)!=0) {
1561 P1=new Point(rect.Left + 1, centerY);
1562 P2=new Point(rect.Right - 1, centerY);
1563 P3=new Point(centerX, rect.Bottom - 1);
1569 /* Draw the arrow */
1570 if ((state & ButtonState.Inactive)!=0) {
1571 /* Move away from the shadow */
1572 arrow[0].X += 1; arrow[0].Y += 1;
1573 arrow[1].X += 1; arrow[1].Y += 1;
1574 arrow[2].X += 1; arrow[2].Y += 1;
1576 graphics.FillPolygon(SystemBrushes.ControlLightLight, arrow, FillMode.Winding);
1582 graphics.FillPolygon(SystemBrushes.ControlDark, arrow, FillMode.Winding);
1584 graphics.FillPolygon(SystemBrushes.ControlText, arrow, FillMode.Winding);
1587 public override void ComboBoxDrawNormalDropDownButton (ComboBox comboBox, Graphics g, Rectangle clippingArea, Rectangle area, ButtonState state)
1589 CPDrawComboButton (g, area, state);
1591 public override bool ComboBoxNormalDropDownButtonHasTransparentBackground (ComboBox comboBox, ButtonState state)
1595 public override bool ComboBoxDropDownButtonHasHotElementStyle (ComboBox comboBox)
1599 public override void ComboBoxDrawBackground (ComboBox comboBox, Graphics g, Rectangle clippingArea, FlatStyle style)
1601 if (!comboBox.Enabled)
1602 g.FillRectangle (ResPool.GetSolidBrush (ColorControl), comboBox.Bounds);
1604 if (comboBox.DropDownStyle == ComboBoxStyle.Simple)
1605 g.FillRectangle (ResPool.GetSolidBrush (comboBox.Parent.BackColor), comboBox.ClientRectangle);
1607 if (style == FlatStyle.Popup && (comboBox.Entered || comboBox.Focused)) {
1608 Rectangle area = comboBox.TextArea;
1611 g.DrawRectangle (ResPool.GetPen (SystemColors.ControlDark), area);
1612 g.DrawLine (ResPool.GetPen (SystemColors.ControlDark), comboBox.ButtonArea.X - 1, comboBox.ButtonArea.Top, comboBox.ButtonArea.X - 1, comboBox.ButtonArea.Bottom);
1614 bool is_flat = style == FlatStyle.Flat || style == FlatStyle.Popup;
1615 if (!is_flat && clippingArea.IntersectsWith (comboBox.TextArea))
1616 ControlPaint.DrawBorder3D (g, comboBox.TextArea, Border3DStyle.Sunken);
1618 public override bool CombBoxBackgroundHasHotElementStyle (ComboBox comboBox)
1625 public override int DataGridPreferredColumnWidth { get { return 75;} }
1626 public override int DataGridMinimumColumnCheckBoxHeight { get { return 16;} }
1627 public override int DataGridMinimumColumnCheckBoxWidth { get { return 16;} }
1628 public override Color DataGridAlternatingBackColor { get { return ColorWindow;} }
1629 public override Color DataGridBackColor { get { return ColorWindow;} }
1630 public override Color DataGridBackgroundColor { get { return ColorAppWorkspace;} }
1631 public override Color DataGridCaptionBackColor { get { return ColorActiveCaption;} }
1632 public override Color DataGridCaptionForeColor { get { return ColorActiveCaptionText;} }
1633 public override Color DataGridGridLineColor { get { return ColorControl;} }
1634 public override Color DataGridHeaderBackColor { get { return ColorControl;} }
1635 public override Color DataGridHeaderForeColor { get { return ColorControlText;} }
1636 public override Color DataGridLinkColor { get { return ColorHotTrack;} }
1637 public override Color DataGridLinkHoverColor { get { return ColorHotTrack;} }
1638 public override Color DataGridParentRowsBackColor { get { return ColorControl;} }
1639 public override Color DataGridParentRowsForeColor { get { return ColorWindowText;} }
1640 public override Color DataGridSelectionBackColor { get { return ColorActiveCaption;} }
1641 public override Color DataGridSelectionForeColor { get { return ColorActiveCaptionText;} }
1643 public override void DataGridPaint (PaintEventArgs pe, DataGrid grid)
1645 DataGridPaintCaption (pe.Graphics, pe.ClipRectangle, grid);
1646 DataGridPaintParentRows (pe.Graphics, pe.ClipRectangle, grid);
1647 DataGridPaintColumnHeaders (pe.Graphics, pe.ClipRectangle, grid);
1648 DataGridPaintRows (pe.Graphics, grid.cells_area, pe.ClipRectangle, grid);
1650 // Paint scrollBar corner
1651 if (grid.VScrollBar.Visible && grid.HScrollBar.Visible) {
1653 Rectangle corner = new Rectangle (grid.ClientRectangle.X + grid.ClientRectangle.Width - grid.VScrollBar.Width,
1654 grid.ClientRectangle.Y + grid.ClientRectangle.Height - grid.HScrollBar.Height,
1655 grid.VScrollBar.Width, grid.HScrollBar.Height);
1657 if (pe.ClipRectangle.IntersectsWith (corner)) {
1658 pe.Graphics.FillRectangle (ResPool.GetSolidBrush (grid.ParentRowsBackColor),
1664 public override void DataGridPaintCaption (Graphics g, Rectangle clip, DataGrid grid)
1666 Rectangle bounds = clip;
1667 bounds.Intersect (grid.caption_area);
1670 g.FillRectangle (ResPool.GetSolidBrush (grid.CaptionBackColor), bounds);
1673 g.DrawLine (ResPool.GetPen (grid.CurrentTableStyle.CurrentHeaderForeColor),
1674 bounds.X, bounds.Y + bounds.Height -1,
1675 bounds.X + bounds.Width, bounds.Y + bounds.Height -1);
1678 if (grid.CaptionText != String.Empty) {
1679 Rectangle text_rect = grid.caption_area;
1680 text_rect.Y += text_rect.Height / 2 - grid.CaptionFont.Height / 2;
1681 text_rect.Height = grid.CaptionFont.Height;
1683 g.DrawString (grid.CaptionText, grid.CaptionFont,
1684 ResPool.GetSolidBrush (grid.CaptionForeColor),
1689 if (bounds.IntersectsWith (grid.back_button_rect)) {
1690 g.DrawImage (grid.back_button_image, grid.back_button_rect);
1691 if (grid.back_button_mouseover) {
1692 CPDrawBorder3D (g, grid.back_button_rect, grid.back_button_active ? Border3DStyle.Sunken : Border3DStyle.Raised, all_sides);
1697 if (bounds.IntersectsWith (grid.parent_rows_button_rect)) {
1698 g.DrawImage (grid.parent_rows_button_image, grid.parent_rows_button_rect);
1699 if (grid.parent_rows_button_mouseover) {
1700 CPDrawBorder3D (g, grid.parent_rows_button_rect, grid.parent_rows_button_active ? Border3DStyle.Sunken : Border3DStyle.Raised, all_sides);
1705 public override void DataGridPaintColumnHeaders (Graphics g, Rectangle clip, DataGrid grid)
1707 Rectangle columns_area = grid.column_headers_area;
1709 // Paint corner shared between row and column header
1710 if (grid.CurrentTableStyle.CurrentRowHeadersVisible) {
1711 Rectangle rect_bloc = grid.column_headers_area;
1712 rect_bloc.Width = grid.RowHeaderWidth;
1713 if (clip.IntersectsWith (rect_bloc)) {
1714 if (grid.VisibleColumnCount > 0) {
1716 g.FillRectangle (ResPool.GetSolidBrush (grid.CurrentTableStyle.CurrentHeaderBackColor), rect_bloc);
1718 CPDrawBorder3D (g, rect_bloc, Border3DStyle.RaisedInner,
1719 Border3DSide.Left | Border3DSide.Right |
1720 Border3DSide.Top | Border3DSide.Bottom | Border3DSide.Middle,
1721 grid.CurrentTableStyle.CurrentHeaderBackColor);
1723 g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor), rect_bloc);
1727 columns_area.X += grid.RowHeaderWidth;
1728 columns_area.Width -= grid.RowHeaderWidth;
1732 Rectangle column_headers_area_complete = columns_area;
1733 column_headers_area_complete.Width = grid.column_headers_max_width;
1735 if (grid.CurrentTableStyle.CurrentRowHeadersVisible) {
1736 column_headers_area_complete.Width -= grid.RowHeaderWidth;
1739 // Set column painting
1740 Rectangle rect_columnhdr = new Rectangle ();
1742 Region current_clip;
1743 Region prev_clip = g.Clip;
1744 rect_columnhdr.Y = columns_area.Y;
1745 rect_columnhdr.Height = columns_area.Height;
1747 int column_cnt = grid.FirstVisibleColumn + grid.VisibleColumnCount;
1748 for (int column = grid.FirstVisibleColumn; column < column_cnt; column++) {
1749 if (grid.CurrentTableStyle.GridColumnStyles[column].bound == false)
1752 col_pixel = grid.GetColumnStartingPixel (column);
1753 rect_columnhdr.X = columns_area.X + col_pixel - grid.HorizPixelOffset;
1754 rect_columnhdr.Width = grid.CurrentTableStyle.GridColumnStyles[column].Width;
1756 if (clip.IntersectsWith (rect_columnhdr) == false)
1759 current_clip = new Region (rect_columnhdr);
1760 current_clip.Intersect (columns_area);
1761 current_clip.Intersect (prev_clip);
1762 g.Clip = current_clip;
1764 DataGridPaintColumnHeader (g, rect_columnhdr, grid, column);
1766 current_clip.Dispose ();
1771 Rectangle not_usedarea = column_headers_area_complete;
1772 not_usedarea.X = rect_columnhdr.X + rect_columnhdr.Width;
1773 not_usedarea.Width = grid.ClientRectangle.X + grid.ClientRectangle.Width - rect_columnhdr.X - rect_columnhdr.Height;
1774 g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor), not_usedarea);
1778 public override void DataGridPaintColumnHeader (Graphics g, Rectangle bounds, DataGrid grid, int col)
1781 g.FillRectangle (ResPool.GetSolidBrush (grid.CurrentTableStyle.HeaderBackColor), bounds);
1784 if (!grid.FlatMode) {
1785 g.DrawLine (ResPool.GetPen (ColorControlLightLight),
1786 bounds.X, bounds.Y, bounds.X + bounds.Width, bounds.Y);
1789 g.DrawLine (ResPool.GetPen (ColorControlLightLight),
1790 bounds.X, bounds.Y, bounds.X, bounds.Y + bounds.Height);
1792 g.DrawLine (ResPool.GetPen (ColorControlLightLight),
1793 bounds.X, bounds.Y + 2, bounds.X, bounds.Y + bounds.Height - 3);
1796 if (col == (grid.VisibleColumnCount -1)) {
1797 g.DrawLine (ResPool.GetPen (ColorControlDark),
1798 bounds.X + bounds.Width - 1, bounds.Y,
1799 bounds.X + bounds.Width - 1, bounds.Y + bounds.Height);
1801 g.DrawLine (ResPool.GetPen (ColorControlDark),
1802 bounds.X + bounds.Width - 1, bounds.Y + 2,
1803 bounds.X + bounds.Width - 1, bounds.Y + bounds.Height - 3);
1806 g.DrawLine (ResPool.GetPen (ColorControlDark),
1807 bounds.X, bounds.Y + bounds.Height - 1,
1808 bounds.X + bounds.Width, bounds.Y + bounds.Height - 1);
1814 DataGridColumnStyle style = grid.CurrentTableStyle.GridColumnStyles[col];
1816 if (style.ArrowDrawingMode != DataGridColumnStyle.ArrowDrawing.No)
1820 StringFormat format = new StringFormat ();
1821 format.FormatFlags |= StringFormatFlags.NoWrap;
1822 format.LineAlignment = StringAlignment.Center;
1823 format.Trimming = StringTrimming.Character;
1825 g.DrawString (style.HeaderText, grid.CurrentTableStyle.HeaderFont,
1826 ResPool.GetSolidBrush (grid.CurrentTableStyle.CurrentHeaderForeColor),
1830 if (style.ArrowDrawingMode != DataGridColumnStyle.ArrowDrawing.No) {
1831 Point pnt = new Point (bounds.X + bounds.Width + 4, bounds.Y + ((bounds.Height - 6)/2));
1833 if (style.ArrowDrawingMode == DataGridColumnStyle.ArrowDrawing.Ascending) {
1834 g.DrawLine (SystemPens.ControlLightLight, pnt.X + 6, pnt.Y + 6, pnt.X + 3, pnt.Y);
1835 g.DrawLine (SystemPens.ControlDark, pnt.X, pnt.Y + 6, pnt.X + 6, pnt.Y + 6);
1836 g.DrawLine (SystemPens.ControlDark, pnt.X, pnt.Y + 6, pnt.X + 3, pnt.Y);
1838 g.DrawLine (SystemPens.ControlLightLight, pnt.X + 6, pnt.Y, pnt.X + 3, pnt.Y + 6);
1839 g.DrawLine (SystemPens.ControlDark, pnt.X, pnt.Y, pnt.X + 6, pnt.Y);
1840 g.DrawLine (SystemPens.ControlDark, pnt.X, pnt.Y, pnt.X + 3, pnt.Y + 6);
1845 public override void DataGridPaintParentRows (Graphics g, Rectangle clip, DataGrid grid)
1847 Rectangle rect_row = new Rectangle ();
1849 rect_row.X = grid.ParentRowsArea.X;
1850 rect_row.Width = grid.ParentRowsArea.Width;
1851 rect_row.Height = (grid.CaptionFont.Height + 3);
1853 object[] parentRows = grid.data_source_stack.ToArray();
1855 Region current_clip;
1856 Region prev_clip = g.Clip;
1857 for (int row = 0; row < parentRows.Length; row++) {
1858 rect_row.Y = grid.ParentRowsArea.Y + row * rect_row.Height;
1860 if (clip.IntersectsWith (rect_row) == false)
1863 current_clip = new Region (rect_row);
1864 current_clip.Intersect (prev_clip);
1865 g.Clip = current_clip;
1867 DataGridPaintParentRow (g, rect_row, (DataGridDataSource)parentRows[parentRows.Length - row - 1], grid);
1869 current_clip.Dispose ();
1875 public override void DataGridPaintParentRow (Graphics g, Rectangle bounds, DataGridDataSource row, DataGrid grid)
1878 g.FillRectangle (ResPool.GetSolidBrush (grid.ParentRowsBackColor),
1881 Font bold_font = new Font (grid.Font.FontFamily, grid.Font.Size, grid.Font.Style | FontStyle.Bold);
1882 // set up some standard string formating variables
1883 StringFormat text_format = new StringFormat();
1884 text_format.LineAlignment = StringAlignment.Center;
1885 text_format.Alignment = StringAlignment.Near;
1887 string table_name = "";
1888 if (row.view is DataRowView)
1889 table_name = ((ITypedList)((DataRowView)row.view).DataView).GetListName (null) + ": ";
1892 Rectangle text_rect;
1895 text_size = g.MeasureString (table_name, bold_font).ToSize();
1896 text_rect = new Rectangle(new Point(bounds.X + 3, bounds.Y + bounds.Height - text_size.Height), text_size);
1898 g.DrawString (table_name,
1899 bold_font, ResPool.GetSolidBrush (grid.ParentRowsForeColor), text_rect, text_format);
1901 foreach (PropertyDescriptor pd in ((ICustomTypeDescriptor)row.view).GetProperties()) {
1902 if (typeof(IBindingList).IsAssignableFrom (pd.PropertyType))
1905 text_rect.X += text_rect.Size.Width + 5;
1907 string text = String.Format ("{0}: {1}",
1909 pd.GetValue (row.view));
1911 text_rect.Size = g.MeasureString (text, grid.Font).ToSize();
1912 text_rect.Y = bounds.Y + bounds.Height - text_rect.Height; // XXX
1915 grid.Font, ResPool.GetSolidBrush (grid.ParentRowsForeColor), text_rect, text_format);
1919 if (!grid.FlatMode) {
1920 CPDrawBorder3D (g, bounds, Border3DStyle.RaisedInner,
1921 Border3DSide.Left | Border3DSide.Right |
1922 Border3DSide.Top | Border3DSide.Bottom);
1926 public override void DataGridPaintRowHeaderArrow (Graphics g, Rectangle bounds, DataGrid grid)
1928 Point[] arrow = new Point[3];
1930 int centerX, centerY, shiftX;
1933 rect = new Rectangle (bounds.X + bounds.Width /4,
1934 bounds.Y + bounds.Height/4, bounds.Width / 2, bounds.Height / 2);
1936 centerX = rect.Left + rect.Width / 2;
1937 centerY = rect.Top + rect.Height / 2;
1938 shiftX = Math.Max (1, rect.Width / 8);
1941 P1 = new Point (centerX, rect.Top - 1);
1942 P2 = new Point (centerX, rect.Bottom);
1943 P3 = new Point (rect.Right, centerY);
1948 g.FillPolygon (ResPool.GetSolidBrush
1949 (grid.CurrentTableStyle.CurrentHeaderForeColor), arrow, FillMode.Winding);
1952 public override void DataGridPaintRowHeaderStar (Graphics g, Rectangle bounds, DataGrid grid)
1954 int x = bounds.X + 4;
1955 int y = bounds.Y + 3;
1956 Pen pen = ResPool.GetPen (grid.CurrentTableStyle.CurrentHeaderForeColor);
1958 g.DrawLine (pen, x + 4, y, x + 4, y + 8);
1959 g.DrawLine (pen, x, y + 4, x + 8, y + 4);
1960 g.DrawLine (pen, x + 1, y + 1, x + 7, y + 7);
1961 g.DrawLine (pen, x + 7, y + 1, x + 1, y + 7);
1964 public override void DataGridPaintRowHeader (Graphics g, Rectangle bounds, int row, DataGrid grid)
1966 bool is_add_row = grid.ShowEditRow && row == grid.DataGridRows.Length - 1;
1967 bool is_current_row = row == grid.CurrentCell.RowNumber;
1970 g.FillRectangle (ResPool.GetSolidBrush (grid.CurrentTableStyle.CurrentHeaderBackColor), bounds);
1973 if (is_current_row) {
1974 if (grid.IsChanging) {
1975 g.DrawString ("...", grid.Font,
1976 ResPool.GetSolidBrush (grid.CurrentTableStyle.CurrentHeaderForeColor),
1979 Rectangle rect = new Rectangle (bounds.X - 2, bounds.Y, 18, 18);
1980 DataGridPaintRowHeaderArrow (g, rect, grid);
1983 else if (is_add_row) {
1984 DataGridPaintRowHeaderStar (g, bounds, grid);
1987 if (!grid.FlatMode && !is_add_row) {
1988 CPDrawBorder3D (g, bounds, Border3DStyle.RaisedInner,
1989 Border3DSide.Left | Border3DSide.Right |
1990 Border3DSide.Top | Border3DSide.Bottom);
1994 public override void DataGridPaintRows (Graphics g, Rectangle cells, Rectangle clip, DataGrid grid)
1996 Rectangle rect_row = new Rectangle ();
1997 Rectangle not_usedarea = new Rectangle ();
1999 int rowcnt = grid.VisibleRowCount;
2001 bool showing_add_row = false;
2003 if (grid.RowsCount < grid.DataGridRows.Length) {
2004 /* the table has an add row */
2006 if (grid.FirstVisibleRow + grid.VisibleRowCount >= grid.DataGridRows.Length) {
2007 showing_add_row = true;
2011 rect_row.Width = cells.Width + grid.RowHeadersArea.Width;
2012 for (int r = 0; r < rowcnt; r++) {
2013 int row = grid.FirstVisibleRow + r;
2014 if (row == grid.DataGridRows.Length - 1)
2015 rect_row.Height = grid.DataGridRows[row].Height;
2017 rect_row.Height = grid.DataGridRows[row + 1].VerticalOffset - grid.DataGridRows[row].VerticalOffset;
2018 rect_row.Y = cells.Y + grid.DataGridRows[row].VerticalOffset - grid.DataGridRows[grid.FirstVisibleRow].VerticalOffset;
2019 if (clip.IntersectsWith (rect_row)) {
2020 if (grid.CurrentTableStyle.HasRelations
2021 && !(showing_add_row && row == grid.DataGridRows.Length - 1))
2022 DataGridPaintRelationRow (g, row, rect_row, false, clip, grid);
2024 DataGridPaintRow (g, row, rect_row, showing_add_row && row == grid.DataGridRows.Length - 1, clip, grid);
2029 // the rowcnt == 0 check is needed because
2030 // otherwise we'd draw over the caption on
2031 // empty datasources (since rect_row would be
2034 not_usedarea.Y = cells.Y;
2036 not_usedarea.Y = rect_row.Y + rect_row.Height;
2037 not_usedarea.Height = cells.Y + cells.Height - rect_row.Y - rect_row.Height;
2038 not_usedarea.Width = cells.Width + grid.RowHeadersArea.Width;
2040 g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor), not_usedarea);
2043 public override void DataGridPaintRelationRow (Graphics g, int row, Rectangle row_rect, bool is_newrow,
2044 Rectangle clip, DataGrid grid)
2046 Rectangle rect_header;
2047 Rectangle icon_bounds = new Rectangle ();
2048 Pen pen = ThemeEngine.Current.ResPool.GetPen (grid.CurrentTableStyle.ForeColor);
2050 /* paint the header if it's visible and intersects the clip */
2051 if (grid.CurrentTableStyle.CurrentRowHeadersVisible) {
2052 rect_header = row_rect;
2053 rect_header.Width = grid.RowHeaderWidth;
2054 row_rect.X += grid.RowHeaderWidth;
2055 if (clip.IntersectsWith (rect_header)) {
2056 DataGridPaintRowHeader (g, rect_header, row, grid);
2059 icon_bounds = rect_header;
2060 icon_bounds.X += icon_bounds.Width / 2;
2062 icon_bounds.Width = 8;
2063 icon_bounds.Height = 8;
2065 g.DrawRectangle (pen, icon_bounds);
2067 /* the - part of the icon */
2069 icon_bounds.X + 2, icon_bounds.Y + icon_bounds.Height / 2,
2070 icon_bounds.X + icon_bounds.Width - 2, icon_bounds.Y + icon_bounds.Height / 2);
2072 if (!grid.IsExpanded (row)) {
2073 /* the | part of the icon */
2075 icon_bounds.X + icon_bounds.Width / 2, icon_bounds.Y + 2,
2076 icon_bounds.X + icon_bounds.Width / 2, icon_bounds.Y + icon_bounds.Height - 2);
2080 Rectangle nested_rect = row_rect;
2082 if (grid.DataGridRows[row].IsExpanded)
2083 nested_rect.Height -= grid.DataGridRows[row].RelationHeight;
2085 DataGridPaintRowContents (g, row, nested_rect, is_newrow, clip, grid);
2087 if (grid.DataGridRows[row].IsExpanded) {
2088 // XXX we should create this in the
2089 // datagrid and cache it for use by
2090 // the theme instead of doing it each
2091 // time through here
2092 string[] relations = grid.CurrentTableStyle.Relations;
2093 StringBuilder relation_builder = new StringBuilder ("");
2095 for (int i = 0; i < relations.Length; i ++) {
2097 relation_builder.Append ("\n");
2099 relation_builder.Append (relations[i]);
2101 string relation_text = relation_builder.ToString ();
2103 StringFormat string_format = new StringFormat ();
2104 string_format.FormatFlags |= StringFormatFlags.NoWrap;
2107 //Region prev_clip = g.Clip;
2108 //Region current_clip;
2109 Rectangle rect_cell = row_rect;
2111 rect_cell.X = nested_rect.X + grid.GetColumnStartingPixel (grid.FirstVisibleColumn) - grid.HorizPixelOffset;
2112 rect_cell.Y += nested_rect.Height;
2113 rect_cell.Height = grid.DataGridRows[row].RelationHeight;
2115 rect_cell.Width = 0;
2116 int column_cnt = grid.FirstVisibleColumn + grid.VisibleColumnCount;
2117 for (int column = grid.FirstVisibleColumn; column < column_cnt; column++) {
2118 if (grid.CurrentTableStyle.GridColumnStyles[column].bound == false)
2120 rect_cell.Width += grid.CurrentTableStyle.GridColumnStyles[column].Width;
2122 rect_cell.Width = Math.Max (rect_cell.Width, grid.DataGridRows[row].relation_area.Width);
2124 g.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (grid.CurrentTableStyle.BackColor),
2128 /* draw the line leading from the +/- to the relation area */
2129 Rectangle outline = grid.DataGridRows[row].relation_area;
2130 outline.Y = rect_cell.Y;
2134 icon_bounds.X + icon_bounds.Width / 2, icon_bounds.Y + icon_bounds.Height,
2135 icon_bounds.X + icon_bounds.Width / 2, outline.Y + outline.Height / 2);
2138 icon_bounds.X + icon_bounds.Width / 2, outline.Y + outline.Height / 2,
2139 outline.X, outline.Y + outline.Height / 2);
2141 g.DrawRectangle (pen, outline);
2143 g.DrawString (relation_text, grid.LinkFont, ResPool.GetSolidBrush (grid.LinkColor),
2144 outline, string_format);
2146 if (row_rect.X + row_rect.Width > rect_cell.X + rect_cell.Width) {
2147 Rectangle not_usedarea = new Rectangle ();
2148 not_usedarea.X = rect_cell.X + rect_cell.Width;
2149 not_usedarea.Width = row_rect.X + row_rect.Width - rect_cell.X - rect_cell.Width;
2150 not_usedarea.Y = row_rect.Y;
2151 not_usedarea.Height = row_rect.Height;
2152 if (clip.IntersectsWith (not_usedarea))
2153 g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor),
2159 public override void DataGridPaintRowContents (Graphics g, int row, Rectangle row_rect, bool is_newrow,
2160 Rectangle clip, DataGrid grid)
2162 Rectangle rect_cell = new Rectangle ();
2164 Color backcolor, forecolor;
2165 Brush backBrush, foreBrush;
2166 Rectangle not_usedarea = Rectangle.Empty;
2168 rect_cell.Y = row_rect.Y;
2169 rect_cell.Height = row_rect.Height;
2171 if (grid.IsSelected (row)) {
2172 backcolor = grid.SelectionBackColor;
2173 forecolor = grid.SelectionForeColor;
2176 backcolor = grid.BackColor;
2178 backcolor = grid.AlternatingBackColor;
2181 forecolor = grid.ForeColor;
2185 backBrush = ResPool.GetSolidBrush (backcolor);
2186 foreBrush = ResPool.GetSolidBrush (forecolor);
2188 // PaintCells at row, column
2189 int column_cnt = grid.FirstVisibleColumn + grid.VisibleColumnCount;
2191 if (column_cnt > 0) {
2192 Region prev_clip = g.Clip;
2193 Region current_clip;
2195 for (int column = grid.FirstVisibleColumn; column < column_cnt; column++) {
2196 if (grid.CurrentTableStyle.GridColumnStyles[column].bound == false)
2199 col_pixel = grid.GetColumnStartingPixel (column);
2201 rect_cell.X = row_rect.X + col_pixel - grid.HorizPixelOffset;
2202 rect_cell.Width = grid.CurrentTableStyle.GridColumnStyles[column].Width;
2204 if (clip.IntersectsWith (rect_cell)) {
2205 current_clip = new Region (rect_cell);
2206 current_clip.Intersect (row_rect);
2207 current_clip.Intersect (prev_clip);
2208 g.Clip = current_clip;
2211 grid.CurrentTableStyle.GridColumnStyles[column].PaintNewRow (g, rect_cell,
2215 grid.CurrentTableStyle.GridColumnStyles[column].Paint (g, rect_cell, grid.ListManager, row,
2218 grid.RightToLeft == RightToLeft.Yes);
2221 current_clip.Dispose ();
2227 if (row_rect.X + row_rect.Width > rect_cell.X + rect_cell.Width) {
2228 not_usedarea.X = rect_cell.X + rect_cell.Width;
2229 not_usedarea.Width = row_rect.X + row_rect.Width - rect_cell.X - rect_cell.Width;
2230 not_usedarea.Y = row_rect.Y;
2231 not_usedarea.Height = row_rect.Height;
2235 not_usedarea = row_rect;
2238 if (!not_usedarea.IsEmpty && clip.IntersectsWith (not_usedarea))
2239 g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor),
2243 public override void DataGridPaintRow (Graphics g, int row, Rectangle row_rect, bool is_newrow,
2244 Rectangle clip, DataGrid grid)
2246 /* paint the header if it's visible and intersects the clip */
2247 if (grid.CurrentTableStyle.CurrentRowHeadersVisible) {
2248 Rectangle rect_header = row_rect;
2249 rect_header.Width = grid.RowHeaderWidth;
2250 row_rect.X += grid.RowHeaderWidth;
2251 if (clip.IntersectsWith (rect_header)) {
2252 DataGridPaintRowHeader (g, rect_header, row, grid);
2256 DataGridPaintRowContents (g, row, row_rect, is_newrow, clip, grid);
2259 #endregion // Datagrid
2262 #region DataGridView
2263 #region DataGridViewHeaderCell
2264 #region DataGridViewRowHeaderCell
2265 public override bool DataGridViewRowHeaderCellDrawBackground (DataGridViewRowHeaderCell cell, Graphics g, Rectangle bounds)
2270 public override bool DataGridViewRowHeaderCellDrawSelectionBackground (DataGridViewRowHeaderCell cell)
2275 public override bool DataGridViewRowHeaderCellDrawBorder (DataGridViewRowHeaderCell cell, Graphics g, Rectangle bounds)
2281 #region DataGridViewColumnHeaderCell
2282 public override bool DataGridViewColumnHeaderCellDrawBackground (DataGridViewColumnHeaderCell cell, Graphics g, Rectangle bounds)
2287 public override bool DataGridViewColumnHeaderCellDrawBorder (DataGridViewColumnHeaderCell cell, Graphics g, Rectangle bounds)
2293 public override bool DataGridViewHeaderCellHasPressedStyle (DataGridView dataGridView)
2298 public override bool DataGridViewHeaderCellHasHotStyle (DataGridView dataGridView)
2306 #region DateTimePicker
2307 protected virtual void DateTimePickerDrawBorder (DateTimePicker dateTimePicker, Graphics g, Rectangle clippingArea)
2309 this.CPDrawBorder3D (g, dateTimePicker.ClientRectangle, Border3DStyle.Sunken, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, dateTimePicker.BackColor);
2312 protected virtual void DateTimePickerDrawDropDownButton (DateTimePicker dateTimePicker, Graphics g, Rectangle clippingArea)
2314 ButtonState state = dateTimePicker.is_drop_down_visible ? ButtonState.Pushed : ButtonState.Normal;
2315 g.FillRectangle (ResPool.GetSolidBrush (ColorControl), dateTimePicker.drop_down_arrow_rect);
2316 this.CPDrawComboButton (
2318 dateTimePicker.drop_down_arrow_rect,
2322 public override void DrawDateTimePicker(Graphics dc, Rectangle clip_rectangle, DateTimePicker dtp)
2325 if (!clip_rectangle.IntersectsWith (dtp.ClientRectangle))
2328 // draw the outer border
2329 Rectangle button_bounds = dtp.ClientRectangle;
2330 DateTimePickerDrawBorder (dtp, dc, clip_rectangle);
2332 // deflate by the border width
2333 if (clip_rectangle.IntersectsWith (dtp.drop_down_arrow_rect)) {
2334 button_bounds.Inflate (-2,-2);
2335 if (!dtp.ShowUpDown) {
2336 DateTimePickerDrawDropDownButton (dtp, dc, clip_rectangle);
2338 ButtonState up_state = dtp.is_up_pressed ? ButtonState.Pushed : ButtonState.Normal;
2339 ButtonState down_state = dtp.is_down_pressed ? ButtonState.Pushed : ButtonState.Normal;
2340 Rectangle up_bounds = dtp.drop_down_arrow_rect;
2341 Rectangle down_bounds = dtp.drop_down_arrow_rect;
2343 up_bounds.Height = up_bounds.Height / 2;
2344 down_bounds.Y = up_bounds.Height;
2345 down_bounds.Height = dtp.Height - up_bounds.Height;
2346 if (down_bounds.Height > up_bounds.Height)
2349 down_bounds.Height -= 1;
2352 up_bounds.Inflate (-1, -1);
2353 down_bounds.Inflate (-1, -1);
2355 ControlPaint.DrawScrollButton (dc, up_bounds, ScrollButton.Up, up_state);
2356 ControlPaint.DrawScrollButton (dc, down_bounds, ScrollButton.Down, down_state);
2360 // render the date part
2361 if (!clip_rectangle.IntersectsWith (dtp.date_area_rect))
2364 // fill the background
2365 dc.FillRectangle (SystemBrushes.Window, dtp.date_area_rect);
2367 // Update date_area_rect if we are drawing the checkbox
2368 Rectangle date_area_rect = dtp.date_area_rect;
2369 if (dtp.ShowCheckBox) {
2370 Rectangle check_box_rect = dtp.CheckBoxRect;
2371 date_area_rect.X = date_area_rect.X + check_box_rect.Width + DateTimePicker.check_box_space * 2;
2372 date_area_rect.Width = date_area_rect.Width - check_box_rect.Width - DateTimePicker.check_box_space * 2;
2374 ButtonState bs = dtp.Checked ? ButtonState.Checked : ButtonState.Normal;
2375 CPDrawCheckBox(dc, check_box_rect, bs);
2377 if (dtp.is_checkbox_selected)
2378 CPDrawFocusRectangle (dc, check_box_rect, dtp.foreground_color, dtp.background_color);
2381 // render each text part
2382 using (StringFormat text_format = StringFormat.GenericTypographic)
2384 text_format.LineAlignment = StringAlignment.Near;
2385 text_format.Alignment = StringAlignment.Near;
2386 text_format.FormatFlags = text_format.FormatFlags | StringFormatFlags.MeasureTrailingSpaces | StringFormatFlags.NoWrap | StringFormatFlags.FitBlackBox;
2387 text_format.FormatFlags &= ~StringFormatFlags.NoClip;
2389 // Calculate the rectangles for each part
2390 if (dtp.part_data.Length > 0 && dtp.part_data[0].drawing_rectangle.IsEmpty)
2393 for (int i = 0; i < dtp.part_data.Length; i++)
2395 DateTimePicker.PartData fd = dtp.part_data[i];
2396 RectangleF text_rect = new RectangleF();
2397 string text = fd.GetText(dtp.Value);
2398 text_rect.Size = gr.MeasureString (text, dtp.Font, 250, text_format);
2400 text_rect.Width = Math.Max (dtp.CalculateMaxWidth(fd.value, gr, text_format), text_rect.Width);
2403 text_rect.X = dtp.part_data[i - 1].drawing_rectangle.Right;
2405 text_rect.X = date_area_rect.X;
2408 text_rect.Inflate (1, 0);
2409 fd.drawing_rectangle = text_rect;
2413 // draw the text part
2414 Brush text_brush = ResPool.GetSolidBrush (dtp.ShowCheckBox && dtp.Checked == false ?
2415 SystemColors.GrayText : dtp.ForeColor); // Use GrayText if Checked is false
2416 RectangleF clip_rectangleF = clip_rectangle;
2418 for (int i = 0; i < dtp.part_data.Length; i++)
2420 DateTimePicker.PartData fd = dtp.part_data [i];
2423 if (!clip_rectangleF.IntersectsWith (fd.drawing_rectangle))
2426 text = dtp.editing_part_index == i ? dtp.editing_text : fd.GetText (dtp.Value);
2428 PointF text_position = new PointF ();
2430 RectangleF text_rect;
2432 text_size = dc.MeasureString (text, dtp.Font, 250, text_format);
2433 text_position.X = (fd.drawing_rectangle.Left + fd.drawing_rectangle.Width / 2) - text_size.Width / 2;
2434 text_position.Y = (fd.drawing_rectangle.Top + fd.drawing_rectangle.Height / 2) - text_size.Height / 2;
2435 text_rect = new RectangleF (text_position, text_size);
2436 text_rect = RectangleF.Intersect (text_rect, date_area_rect);
2438 if (text_rect.IsEmpty)
2441 if (text_rect.Right >= date_area_rect.Right)
2442 text_format.FormatFlags &= ~StringFormatFlags.NoClip;
2444 text_format.FormatFlags |= StringFormatFlags.NoClip;
2447 dc.FillRectangle (SystemBrushes.Highlight, text_rect);
2448 dc.DrawString (text, dtp.Font, SystemBrushes.HighlightText, text_rect, text_format);
2451 dc.DrawString (text, dtp.Font, text_brush, text_rect, text_format);
2454 if (fd.drawing_rectangle.Right > date_area_rect.Right)
2455 break; // the next part would be not be visible, so don't draw anything more.
2460 public override bool DateTimePickerBorderHasHotElementStyle {
2466 public override Rectangle DateTimePickerGetDropDownButtonArea (DateTimePicker dateTimePicker)
2468 Rectangle rect = dateTimePicker.ClientRectangle;
2469 rect.X = rect.Right - SystemInformation.VerticalScrollBarWidth - 2;
2470 if (rect.Width > (SystemInformation.VerticalScrollBarWidth + 2)) {
2471 rect.Width = SystemInformation.VerticalScrollBarWidth;
2473 rect.Width = Math.Max (rect.Width - 2, 0);
2476 rect.Inflate (0, -2);
2480 public override Rectangle DateTimePickerGetDateArea (DateTimePicker dateTimePicker)
2482 Rectangle rect = dateTimePicker.ClientRectangle;
2483 if (dateTimePicker.ShowUpDown) {
2484 // set the space to the left of the up/down button
2485 if (rect.Width > (DateTimePicker.up_down_width + 4)) {
2486 rect.Width -= (DateTimePicker.up_down_width + 4);
2491 // set the space to the left of the up/down button
2492 // TODO make this use up down button
2493 if (rect.Width > (SystemInformation.VerticalScrollBarWidth + 4)) {
2494 rect.Width -= SystemInformation.VerticalScrollBarWidth;
2500 rect.Inflate (-2, -2);
2503 public override bool DateTimePickerDropDownButtonHasHotElementStyle {
2508 #endregion // DateTimePicker
2511 public override void DrawGroupBox (Graphics dc, Rectangle area, GroupBox box) {
2512 StringFormat text_format;
2517 dc.FillRectangle (GetControlBackBrush (box.BackColor), box.ClientRectangle);
2519 text_format = new StringFormat();
2520 text_format.HotkeyPrefix = HotkeyPrefix.Show;
2522 size = dc.MeasureString (box.Text, box.Font);
2525 if (size.Width > 0) {
2526 width = ((int) size.Width) + 7;
2528 if (width > box.Width - 16)
2529 width = box.Width - 16;
2532 y = box.Font.Height / 2;
2534 // Clip the are that the text will be in
2535 Region prev_clip = dc.Clip;
2536 dc.SetClip (new Rectangle (10, 0, width, box.Font.Height), CombineMode.Exclude);
2538 CPDrawBorder3D (dc, new Rectangle (0, y, box.Width, box.Height - y), Border3DStyle.Etched, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, box.BackColor);
2539 dc.Clip = prev_clip;
2542 if (box.Text.Length != 0) {
2544 dc.DrawString (box.Text, box.Font, ResPool.GetSolidBrush (box.ForeColor), 10, 0, text_format);
2546 CPDrawStringDisabled (dc, box.Text, box.Font, box.BackColor,
2547 new RectangleF (10, 0, width, box.Font.Height), text_format);
2551 text_format.Dispose ();
2554 public override Size GroupBoxDefaultSize {
2556 return new Size (200,100);
2562 public override Size HScrollBarDefaultSize {
2564 return new Size (80, this.ScrollBarButtonSize);
2568 #endregion // HScrollBar
2572 public override void DrawListBoxItem (ListBox ctrl, DrawItemEventArgs e)
2574 Color back_color, fore_color;
2576 if ((e.State & DrawItemState.Selected) == DrawItemState.Selected) {
2577 back_color = ColorHighlight;
2578 fore_color = ColorHighlightText;
2580 back_color = e.BackColor;
2581 fore_color = e.ForeColor;
2584 e.Graphics.FillRectangle (ResPool.GetSolidBrush (back_color), e.Bounds);
2586 e.Graphics.DrawString (ctrl.GetItemText (ctrl.Items[e.Index]), e.Font,
2587 ResPool.GetSolidBrush (fore_color),
2588 e.Bounds, ctrl.StringFormat);
2590 if ((e.State & DrawItemState.Focus) == DrawItemState.Focus)
2591 CPDrawFocusRectangle (e.Graphics, e.Bounds, fore_color, back_color);
2598 public override void DrawListViewItems (Graphics dc, Rectangle clip, ListView control)
2600 bool details = control.View == View.Details;
2601 int first = control.FirstVisibleIndex;
2602 int lastvisibleindex = control.LastVisibleIndex;
2605 if (control.VirtualMode)
2606 control.OnCacheVirtualItems (new CacheVirtualItemsEventArgs (first, lastvisibleindex));
2609 for (int i = first; i <= lastvisibleindex; i++) {
2610 ListViewItem item = control.GetItemAtDisplayIndex (i);
2611 if (clip.IntersectsWith (item.Bounds)) {
2613 bool owner_draw = false;
2614 if (control.OwnerDraw)
2615 owner_draw = DrawListViewItemOwnerDraw (dc, item, i);
2618 DrawListViewItem (dc, control, item);
2623 if (control.ShowGroups && control.View != View.List && control.Groups.Count > 0) {
2624 // Use InternalCount instead of Count to take into account Default Group as needed
2625 for (int i = 0; i < control.Groups.InternalCount; i++) {
2626 ListViewGroup group = control.Groups.GetInternalGroup (i);
2627 if (group.ItemCount > 0 && clip.IntersectsWith (group.HeaderBounds))
2628 DrawListViewGroupHeader (dc, control, group);
2632 ListViewInsertionMark insertion_mark = control.InsertionMark;
2633 int insertion_mark_index = insertion_mark.Index;
2634 if (insertion_mark.Bounds != Rectangle.Empty &&
2635 (control.View != View.Details && control.View != View.List) &&
2636 insertion_mark_index > -1 && insertion_mark_index < control.Items.Count) {
2638 Brush brush = ResPool.GetSolidBrush (insertion_mark.Color);
2639 dc.FillRectangle (brush, insertion_mark.Line);
2640 dc.FillPolygon (brush, insertion_mark.TopTriangle);
2641 dc.FillPolygon (brush, insertion_mark.BottomTriangle);
2645 // draw the gridlines
2646 if (details && control.GridLines) {
2647 int top = (control.HeaderStyle == ColumnHeaderStyle.None) ?
2648 2 : control.Font.Height + 2;
2650 // draw vertical gridlines
2651 foreach (ColumnHeader col in control.Columns)
2652 dc.DrawLine (SystemPens.Control,
2653 col.Rect.Right, top,
2654 col.Rect.Right, control.TotalHeight);
2655 // draw horizontal gridlines
2656 ListViewItem last_item = null;
2657 foreach (ListViewItem item in control.Items) {
2658 dc.DrawLine (SystemPens.Control,
2659 item.GetBounds (ItemBoundsPortion.Entire).Left, item.GetBounds (ItemBoundsPortion.Entire).Top,
2660 control.TotalWidth, item.GetBounds (ItemBoundsPortion.Entire).Top);
2664 // draw a line after at the bottom of the last item
2665 if (last_item != null) {
2666 dc.DrawLine (SystemPens.Control,
2667 last_item.GetBounds (ItemBoundsPortion.Entire).Left,
2668 last_item.GetBounds (ItemBoundsPortion.Entire).Bottom,
2670 last_item.GetBounds (ItemBoundsPortion.Entire).Bottom);
2674 // Draw corner between the two scrollbars
2675 if (control.h_scroll.Visible == true && control.v_scroll.Visible == true) {
2676 Rectangle rect = new Rectangle ();
2677 rect.X = control.h_scroll.Location.X + control.h_scroll.Width;
2678 rect.Width = control.v_scroll.Width;
2679 rect.Y = control.v_scroll.Location.Y + control.v_scroll.Height;
2680 rect.Height = control.h_scroll.Height;
2681 dc.FillRectangle (SystemBrushes.Control, rect);
2684 Rectangle box_select_rect = control.item_control.BoxSelectRectangle;
2685 if (!box_select_rect.Size.IsEmpty)
2686 dc.DrawRectangle (ResPool.GetDashPen (ColorControlText, DashStyle.Dot), box_select_rect);
2690 public override void DrawListViewHeader (Graphics dc, Rectangle clip, ListView control)
2692 bool details = (control.View == View.Details);
2694 // border is drawn directly in the Paint method
2695 if (details && control.HeaderStyle != ColumnHeaderStyle.None) {
2696 dc.FillRectangle (SystemBrushes.Control,
2697 0, 0, control.TotalWidth, control.Font.Height + 5);
2698 if (control.Columns.Count > 0) {
2699 foreach (ColumnHeader col in control.Columns) {
2700 Rectangle rect = col.Rect;
2701 rect.X -= control.h_marker;
2704 bool owner_draw = false;
2705 if (control.OwnerDraw)
2706 owner_draw = DrawListViewColumnHeaderOwnerDraw (dc, control, col, rect);
2711 ListViewDrawColumnHeaderBackground (control, col, dc, rect, clip);
2714 if (rect.Width <= 0)
2717 dc.DrawString (col.Text, control.Font,
2718 SystemBrushes.ControlText,
2721 int right = control.GetReorderedColumn (control.Columns.Count - 1).Rect.Right - control.h_marker;
2722 if (right < control.Right) {
2723 Rectangle rect = control.Columns [0].Rect;
2725 rect.Width = control.Right - right;
2726 ListViewDrawUnusedHeaderBackground (control, dc, rect, clip);
2732 protected virtual void ListViewDrawColumnHeaderBackground (ListView listView, ColumnHeader columnHeader, Graphics g, Rectangle area, Rectangle clippingArea)
2735 if (listView.HeaderStyle == ColumnHeaderStyle.Clickable)
2736 state = columnHeader.Pressed ? ButtonState.Pushed : ButtonState.Normal;
2738 state = ButtonState.Flat;
2739 CPDrawButton (g, area, state);
2742 protected virtual void ListViewDrawUnusedHeaderBackground (ListView listView, Graphics g, Rectangle area, Rectangle clippingArea)
2745 if (listView.HeaderStyle == ColumnHeaderStyle.Clickable)
2746 state = ButtonState.Normal;
2748 state = ButtonState.Flat;
2749 CPDrawButton (g, area, state);
2752 public override void DrawListViewHeaderDragDetails (Graphics dc, ListView view, ColumnHeader col, int target_x)
2754 Rectangle rect = col.Rect;
2755 rect.X -= view.h_marker;
2756 Color color = Color.FromArgb (0x7f, ColorControlDark.R, ColorControlDark.G, ColorControlDark.B);
2757 dc.FillRectangle (ResPool.GetSolidBrush (color), rect);
2760 if (rect.Width <= 0)
2762 color = Color.FromArgb (0x7f, ColorControlText.R, ColorControlText.G, ColorControlText.B);
2763 dc.DrawString (col.Text, view.Font, ResPool.GetSolidBrush (color), rect, col.Format);
2764 dc.DrawLine (ResPool.GetSizedPen (ColorHighlight, 2), target_x, 0, target_x, col.Rect.Height);
2768 protected virtual bool DrawListViewColumnHeaderOwnerDraw (Graphics dc, ListView control, ColumnHeader column, Rectangle bounds)
2770 ListViewItemStates state = ListViewItemStates.ShowKeyboardCues;
2772 state |= ListViewItemStates.Selected;
2774 DrawListViewColumnHeaderEventArgs args = new DrawListViewColumnHeaderEventArgs (dc,
2775 bounds, column.Index, column, state, SystemColors.ControlText, ThemeEngine.Current.ColorControl, DefaultFont);
2776 control.OnDrawColumnHeader (args);
2778 return !args.DrawDefault;
2781 protected virtual bool DrawListViewItemOwnerDraw (Graphics dc, ListViewItem item, int index)
2783 ListViewItemStates item_state = ListViewItemStates.ShowKeyboardCues;
2785 item_state |= ListViewItemStates.Selected;
2787 item_state |= ListViewItemStates.Focused;
2789 DrawListViewItemEventArgs args = new DrawListViewItemEventArgs (dc,
2790 item, item.Bounds, index, item_state);
2791 item.ListView.OnDrawItem (args);
2793 if (args.DrawDefault)
2796 if (item.ListView.View == View.Details) {
2797 int count = Math.Min (item.ListView.Columns.Count, item.SubItems.Count);
2799 // Do system drawing for subitems if no owner draw is done
2800 for (int j = 0; j < count; j++)
2801 if (!DrawListViewSubItemOwnerDraw (dc, item, item_state, j))
2802 DrawListViewSubItem (dc, item.ListView, item, j);
2809 protected virtual void DrawListViewItem (Graphics dc, ListView control, ListViewItem item)
2811 Rectangle rect_checkrect = item.CheckRectReal;
2812 Rectangle icon_rect = item.GetBounds (ItemBoundsPortion.Icon);
2813 Rectangle full_rect = item.GetBounds (ItemBoundsPortion.Entire);
2814 Rectangle text_rect = item.GetBounds (ItemBoundsPortion.Label);
2817 // Tile view doesn't support CheckBoxes
2818 if (control.CheckBoxes && control.View != View.Tile) {
2820 if (control.CheckBoxes) {
2822 if (control.StateImageList == null) {
2823 // Make sure we've got at least a line width of 1
2824 int check_wd = Math.Max (3, rect_checkrect.Width / 6);
2825 int scale = Math.Max (1, rect_checkrect.Width / 12);
2827 // set the checkbox background
2828 dc.FillRectangle (SystemBrushes.Window,
2830 // define a rectangle inside the border area
2831 Rectangle rect = new Rectangle (rect_checkrect.X + 2,
2832 rect_checkrect.Y + 2,
2833 rect_checkrect.Width - 4,
2834 rect_checkrect.Height - 4);
2835 Pen pen = ResPool.GetSizedPen (this.ColorWindowText, 2);
2836 dc.DrawRectangle (pen, rect);
2838 // Need to draw a check-mark
2840 Pen check_pen = ResPool.GetSizedPen (this.ColorWindowText, 1);
2841 // adjustments to get the check-mark at the right place
2842 rect.X ++; rect.Y ++;
2843 // following logic is taken from DrawFrameControl method
2844 int x_offset = rect.Width / 5;
2845 int y_offset = rect.Height / 3;
2846 for (int i = 0; i < check_wd; i++) {
2847 dc.DrawLine (check_pen, rect.Left + x_offset,
2848 rect.Top + y_offset + i,
2849 rect.Left + x_offset + 2 * scale,
2850 rect.Top + y_offset + 2 * scale + i);
2851 dc.DrawLine (check_pen,
2852 rect.Left + x_offset + 2 * scale,
2853 rect.Top + y_offset + 2 * scale + i,
2854 rect.Left + x_offset + 6 * scale,
2855 rect.Top + y_offset - 2 * scale + i);
2863 simage_idx = control.StateImageList.Images.Count > 1 ? 1 : -1;
2865 simage_idx = control.StateImageList.Images.Count > 1 ? 1 : 0;
2868 simage_idx = control.StateImageList.Images.Count > 0 ? 0 : -1;
2870 if (simage_idx > -1)
2871 control.StateImageList.Draw (dc, rect_checkrect.Location, simage_idx);
2875 ImageList image_list = control.View == View.LargeIcon
2877 || control.View == View.Tile
2879 ? control.LargeImageList : control.SmallImageList;
2880 if (image_list != null) {
2884 if (item.ImageKey != String.Empty)
2885 idx = image_list.Images.IndexOfKey (item.ImageKey);
2888 idx = item.ImageIndex;
2890 if (idx > -1 && idx < image_list.Images.Count)
2891 image_list.Draw (dc, icon_rect.Location, idx);
2894 // draw the item text
2895 // format for the item text
2896 StringFormat format = new StringFormat ();
2897 if (control.View == View.SmallIcon || control.View == View.LargeIcon)
2898 format.LineAlignment = StringAlignment.Near;
2900 format.LineAlignment = StringAlignment.Center;
2901 if (control.View == View.LargeIcon)
2902 format.Alignment = StringAlignment.Center;
2904 format.Alignment = StringAlignment.Near;
2907 if (control.LabelWrap && control.View != View.Details && control.View != View.Tile)
2909 if (control.LabelWrap && control.View != View.Details)
2911 format.FormatFlags = StringFormatFlags.LineLimit;
2913 format.FormatFlags = StringFormatFlags.NoWrap;
2915 if ((control.View == View.LargeIcon && !item.Focused)
2916 || control.View == View.Details
2918 || control.View == View.Tile
2921 format.Trimming = StringTrimming.EllipsisCharacter;
2923 Rectangle highlight_rect = text_rect;
2924 if (control.View == View.Details) { // Adjustments for Details view
2925 Size text_size = Size.Ceiling (dc.MeasureString (item.Text, item.Font));
2927 if (!control.FullRowSelect) // Selection shouldn't be outside the item bounds
2928 highlight_rect.Width = Math.Min (text_size.Width + 4, text_rect.Width);
2931 if (item.Selected && control.Focused)
2932 dc.FillRectangle (SystemBrushes.Highlight, highlight_rect);
2933 else if (item.Selected && !control.HideSelection)
2934 dc.FillRectangle (SystemBrushes.Control, highlight_rect);
2936 dc.FillRectangle (ResPool.GetSolidBrush (item.BackColor), text_rect);
2939 !control.Enabled ? SystemBrushes.ControlLight :
2940 (item.Selected && control.Focused) ? SystemBrushes.HighlightText :
2941 this.ResPool.GetSolidBrush (item.ForeColor);
2944 // Tile view renders its Text in a different fashion
2945 if (control.View == View.Tile) {
2946 // Item.Text is drawn using its first subitem's bounds
2947 dc.DrawString (item.Text, item.Font, textBrush, item.SubItems [0].Bounds, format);
2949 int count = Math.Min (control.Columns.Count, item.SubItems.Count);
2950 for (int i = 1; i < count; i++) {
2951 ListViewItem.ListViewSubItem sub_item = item.SubItems [i];
2952 if (sub_item.Text == null || sub_item.Text.Length == 0)
2955 Brush itemBrush = item.Selected && control.Focused ?
2956 SystemBrushes.HighlightText : GetControlForeBrush (sub_item.ForeColor);
2957 dc.DrawString (sub_item.Text, sub_item.Font, itemBrush, sub_item.Bounds, format);
2962 if (item.Text != null && item.Text.Length > 0) {
2963 Font font = item.Font;
2965 if (control.HotTracking && item.Hot)
2966 font = item.HotFont;
2969 if (item.Selected && control.Focused)
2970 dc.DrawString (item.Text, font, textBrush, highlight_rect, format);
2972 dc.DrawString (item.Text, font, textBrush, text_rect, format);
2975 if (control.View == View.Details && control.Columns.Count > 0) {
2976 // draw subitems for details view
2977 ListViewItem.ListViewSubItemCollection subItems = item.SubItems;
2978 int count = (control.Columns.Count < subItems.Count ?
2979 control.Columns.Count : subItems.Count);
2982 // 0th subitem is the item already drawn
2983 for (int index = 1; index < count; index++)
2984 DrawListViewSubItem (dc, control, item, index);
2986 // Fill in selection for remaining columns if Column.Count > SubItems.Count
2988 Rectangle sub_item_rect = text_rect;
2989 if (item.Selected && (control.Focused || !control.HideSelection) && control.FullRowSelect) {
2990 for (int index = count; index < control.Columns.Count; index++) {
2991 col = control.Columns [index];
2992 sub_item_rect.X = col.Rect.X - control.h_marker;
2993 sub_item_rect.Width = col.Wd;
2994 if (control.Focused)
2995 dc.FillRectangle (SystemBrushes.Highlight, sub_item_rect);
2997 dc.FillRectangle (SystemBrushes.Control, sub_item_rect);
3003 if (item.Focused && control.Focused) {
3004 Rectangle focus_rect = highlight_rect;
3005 if (control.FullRowSelect && control.View == View.Details) {
3007 foreach (ColumnHeader col in control.Columns)
3009 focus_rect = new Rectangle (0, full_rect.Y, width, full_rect.Height);
3012 CPDrawFocusRectangle (dc, focus_rect, ColorHighlightText, ColorHighlight);
3014 CPDrawFocusRectangle (dc, focus_rect, control.ForeColor, control.BackColor);
3020 protected virtual void DrawListViewSubItem (Graphics dc, ListView control, ListViewItem item, int index)
3022 ListViewItem.ListViewSubItem subItem = item.SubItems [index];
3023 ColumnHeader col = control.Columns [index];
3024 StringFormat format = new StringFormat ();
3025 format.Alignment = col.Format.Alignment;
3026 format.FormatFlags = StringFormatFlags.NoWrap;
3027 format.Trimming = StringTrimming.EllipsisCharacter;
3029 Rectangle sub_item_rect = subItem.Bounds;
3030 Rectangle sub_item_text_rect = sub_item_rect;
3031 sub_item_text_rect.X += 3;
3032 sub_item_text_rect.Width -= ListViewItemPaddingWidth;
3034 SolidBrush sub_item_back_br = null;
3035 SolidBrush sub_item_fore_br = null;
3036 Font sub_item_font = null;
3038 if (item.UseItemStyleForSubItems) {
3039 sub_item_back_br = ResPool.GetSolidBrush (item.BackColor);
3040 sub_item_fore_br = ResPool.GetSolidBrush (item.ForeColor);
3042 // Hot tracking for subitems only applies when UseStyle is true
3043 if (control.HotTracking && item.Hot)
3044 sub_item_font = item.HotFont;
3047 sub_item_font = item.Font;
3049 sub_item_back_br = ResPool.GetSolidBrush (subItem.BackColor);
3050 sub_item_fore_br = ResPool.GetSolidBrush (subItem.ForeColor);
3051 sub_item_font = subItem.Font;
3054 if (item.Selected && (control.Focused || !control.HideSelection) && control.FullRowSelect) {
3056 if (control.Focused) {
3057 bg = SystemBrushes.Highlight;
3058 text = SystemBrushes.HighlightText;
3060 bg = SystemBrushes.Control;
3061 text = sub_item_fore_br;
3065 dc.FillRectangle (bg, sub_item_rect);
3066 if (subItem.Text != null && subItem.Text.Length > 0)
3067 dc.DrawString (subItem.Text, sub_item_font,
3068 text, sub_item_text_rect, format);
3070 dc.FillRectangle (sub_item_back_br, sub_item_rect);
3071 if (subItem.Text != null && subItem.Text.Length > 0)
3072 dc.DrawString (subItem.Text, sub_item_font,
3074 sub_item_text_rect, format);
3081 protected virtual bool DrawListViewSubItemOwnerDraw (Graphics dc, ListViewItem item, ListViewItemStates state, int index)
3083 ListView control = item.ListView;
3084 ListViewItem.ListViewSubItem subitem = item.SubItems [index];
3086 DrawListViewSubItemEventArgs args = new DrawListViewSubItemEventArgs (dc, subitem.Bounds, item,
3087 subitem, item.Index, index, control.Columns [index], state);
3088 control.OnDrawSubItem (args);
3090 return !args.DrawDefault;
3093 protected virtual void DrawListViewGroupHeader (Graphics dc, ListView control, ListViewGroup group)
3095 Rectangle text_bounds = group.HeaderBounds;
3096 Rectangle header_bounds = group.HeaderBounds;
3097 text_bounds.Offset (8, 0);
3098 text_bounds.Inflate (-8, 0);
3099 Size text_size = control.text_size;
3101 Font font = new Font (control.Font, control.Font.Style | FontStyle.Bold);
3102 Brush brush = new LinearGradientBrush (new Point (header_bounds.Left, 0), new Point (header_bounds.Left + ListViewGroupLineWidth, 0),
3103 SystemColors.Desktop, Color.White);
3104 Pen pen = new Pen (brush);
3106 StringFormat sformat = new StringFormat ();
3107 switch (group.HeaderAlignment) {
3108 case HorizontalAlignment.Left:
3109 sformat.Alignment = StringAlignment.Near;
3111 case HorizontalAlignment.Center:
3112 sformat.Alignment = StringAlignment.Center;
3114 case HorizontalAlignment.Right:
3115 sformat.Alignment = StringAlignment.Far;
3119 sformat.LineAlignment = StringAlignment.Near;
3120 dc.DrawString (group.Header, font, SystemBrushes.ControlText, text_bounds, sformat);
3121 dc.DrawLine (pen, header_bounds.Left, header_bounds.Top + text_size.Height, header_bounds.Left + ListViewGroupLineWidth,
3122 header_bounds.Top + text_size.Height);
3131 public override bool ListViewHasHotHeaderStyle {
3138 public override int ListViewGetHeaderHeight (ListView listView, Font font)
3140 return font.Height + 5;
3143 public override Size ListViewCheckBoxSize {
3144 get { return new Size (16, 16); }
3147 public override int ListViewColumnHeaderHeight {
3151 public override int ListViewDefaultColumnWidth {
3155 public override int ListViewVerticalSpacing {
3159 public override int ListViewEmptyColumnWidth {
3163 public override int ListViewHorizontalSpacing {
3167 public override int ListViewItemPaddingWidth {
3171 public override Size ListViewDefaultSize {
3172 get { return new Size (121, 97); }
3175 public override int ListViewGroupHeight {
3179 public int ListViewGroupLineWidth {
3183 public override int ListViewTileWidthFactor {
3187 public override int ListViewTileHeightFactor {
3190 #endregion // ListView
3194 public override void CalcItemSize (Graphics dc, MenuItem item, int y, int x, bool menuBar)
3199 if (item.Visible == false) {
3205 if (item.Separator == true) {
3206 item.Height = SEPARATOR_HEIGHT;
3207 item.Width = SEPARATOR_MIN_WIDTH;
3211 if (item.MeasureEventDefined) {
3212 MeasureItemEventArgs mi = new MeasureItemEventArgs (dc, item.Index);
3213 item.PerformMeasureItem (mi);
3214 item.Height = mi.ItemHeight;
3215 item.Width = mi.ItemWidth;
3219 size = dc.MeasureString (item.Text, MenuFont, int.MaxValue, string_format_menu_text);
3220 item.Width = (int) size.Width;
3221 item.Height = (int) size.Height;
3224 if (item.Shortcut != Shortcut.None && item.ShowShortcut) {
3225 item.XTab = MenuCheckSize.Width + MENU_TAB_SPACE + (int) size.Width;
3226 size = dc.MeasureString (" " + item.GetShortCutText (), MenuFont);
3227 item.Width += MENU_TAB_SPACE + (int) size.Width;
3230 item.Width += 4 + (MenuCheckSize.Width * 2);
3232 item.Width += MENU_BAR_ITEMS_SPACE;
3236 if (item.Height < MenuHeight)
3237 item.Height = MenuHeight;
3241 // Updates the menu rect and returns the height
3242 public override int CalcMenuBarSize (Graphics dc, Menu menu, int width)
3248 foreach (MenuItem item in menu.MenuItems) {
3250 CalcItemSize (dc, item, y, x, true);
3252 if (x + item.Width > width) {
3260 item.MenuBar = true;
3262 if (y + item.Height > menu.Height)
3263 menu.Height = item.Height + y;
3270 public override void CalcPopupMenuSize (Graphics dc, Menu menu)
3278 while (start < menu.MenuItems.Count) {
3281 for (i = start; i < menu.MenuItems.Count; i++) {
3282 MenuItem item = menu.MenuItems [i];
3284 if ((i != start) && (item.Break || item.BarBreak))
3287 CalcItemSize (dc, item, y, x, false);
3290 if (item.Width > max)
3294 // Replace the -1 by the menu width (separators)
3295 for (n = start; n < i; n++, start++)
3296 menu.MenuItems [n].Width = max;
3298 if (y > menu.Height)
3310 menu.Width += SM_CXBORDER;
3311 menu.Height += SM_CYBORDER;
3314 // Draws a menu bar in a window
3315 public override void DrawMenuBar (Graphics dc, Menu menu, Rectangle rect)
3317 if (menu.Height == 0)
3318 CalcMenuBarSize (dc, menu, rect.Width);
3320 bool keynav = (menu as MainMenu).tracker.hotkey_active;
3321 HotkeyPrefix hp = MenuAccessKeysUnderlined || keynav ? HotkeyPrefix.Show : HotkeyPrefix.Hide;
3322 string_format_menu_menubar_text.HotkeyPrefix = hp;
3323 string_format_menu_text.HotkeyPrefix = hp;
3325 rect.Height = menu.Height;
3326 dc.FillRectangle (SystemBrushes.Menu, rect);
3328 for (int i = 0; i < menu.MenuItems.Count; i++) {
3329 MenuItem item = menu.MenuItems [i];
3330 Rectangle item_rect = item.bounds;
3331 item_rect.X += rect.X;
3332 item_rect.Y += rect.Y;
3333 item.MenuHeight = menu.Height;
3334 item.PerformDrawItem (new DrawItemEventArgs (dc, MenuFont, item_rect, i, item.Status));
3338 protected Bitmap CreateGlyphBitmap (Size size, MenuGlyph glyph, Color color)
3341 if (color.R == 0 && color.G == 0 && color.B == 0)
3342 bg_color = Color.White;
3344 bg_color = Color.Black;
3346 Bitmap bmp = new Bitmap (size.Width, size.Height);
3347 Graphics gr = Graphics.FromImage (bmp);
3348 Rectangle rect = new Rectangle (Point.Empty, size);
3349 gr.FillRectangle (ResPool.GetSolidBrush (bg_color), rect);
3350 CPDrawMenuGlyph (gr, rect, glyph, color, Color.Empty);
3351 bmp.MakeTransparent (bg_color);
3357 public override void DrawMenuItem (MenuItem item, DrawItemEventArgs e)
3359 StringFormat string_format;
3360 Rectangle rect_text = e.Bounds;
3362 if (item.Visible == false)
3366 string_format = string_format_menu_menubar_text;
3368 string_format = string_format_menu_text;
3370 if (item.Separator == true) {
3371 int liney = e.Bounds.Y + (e.Bounds.Height / 2);
3373 e.Graphics.DrawLine (SystemPens.ControlDark,
3374 e.Bounds.X, liney, e.Bounds.X + e.Bounds.Width, liney);
3376 e.Graphics.DrawLine (SystemPens.ControlLight,
3377 e.Bounds.X, liney + 1, e.Bounds.X + e.Bounds.Width, liney + 1);
3383 rect_text.X += MenuCheckSize.Width;
3385 if (item.BarBreak) { /* Draw vertical break bar*/
3386 Rectangle rect = e.Bounds;
3389 rect.Height = item.MenuHeight - 6;
3391 e.Graphics.DrawLine (SystemPens.ControlDark,
3392 rect.X, rect.Y , rect.X, rect.Y + rect.Height);
3394 e.Graphics.DrawLine (SystemPens.ControlLight,
3395 rect.X + 1, rect.Y , rect.X +1, rect.Y + rect.Height);
3400 Brush brush_text = null;
3401 Brush brush_back = null;
3403 if ((e.State & DrawItemState.Selected) == DrawItemState.Selected && !item.MenuBar) {
3404 color_text = ColorHighlightText;
3405 color_back = ColorHighlight;
3406 brush_text = SystemBrushes.HighlightText;
3407 brush_back = SystemBrushes.Highlight;
3409 color_text = ColorMenuText;
3410 color_back = ColorMenu;
3411 brush_text = ResPool.GetSolidBrush (ColorMenuText);
3412 brush_back = SystemBrushes.Menu;
3415 /* Draw background */
3417 e.Graphics.FillRectangle (brush_back, e.Bounds);
3420 e.Graphics.DrawString (item.Text, e.Font,
3422 rect_text, string_format);
3424 if (!item.MenuBar && item.Shortcut != Shortcut.None && item.ShowShortcut) {
3425 string str = item.GetShortCutText ();
3426 Rectangle rect = rect_text;
3428 rect.Width -= item.XTab;
3430 e.Graphics.DrawString (str, e.Font, brush_text,
3431 rect, string_format_menu_shortcut);
3435 Border3DStyle border_style = Border3DStyle.Adjust;
3436 if ((item.Status & DrawItemState.HotLight) != 0)
3437 border_style = Border3DStyle.RaisedInner;
3438 else if ((item.Status & DrawItemState.Selected) != 0)
3439 border_style = Border3DStyle.SunkenOuter;
3441 if (border_style != Border3DStyle.Adjust)
3442 CPDrawBorder3D(e.Graphics, e.Bounds, border_style, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, ColorMenu);
3445 if ((item.Status & DrawItemState.Selected) != DrawItemState.Selected) {
3446 e.Graphics.DrawString (item.Text, e.Font, Brushes.White,
3447 new RectangleF(rect_text.X + 1, rect_text.Y + 1, rect_text.Width, rect_text.Height),
3451 e.Graphics.DrawString (item.Text, e.Font, ResPool.GetSolidBrush(ColorGrayText), rect_text, string_format);
3455 if (item.MenuBar == false && (item.IsPopup || item.MdiList)) {
3457 int cx = MenuCheckSize.Width;
3458 int cy = MenuCheckSize.Height;
3459 Bitmap bmp = CreateGlyphBitmap (new Size (cx, cy), MenuGlyph.Arrow, color_text);
3462 e.Graphics.DrawImage (bmp, e.Bounds.X + e.Bounds.Width - cx,
3463 e.Bounds.Y + ((e.Bounds.Height - cy) /2));
3465 ControlPaint.DrawImageDisabled (e.Graphics, bmp, e.Bounds.X + e.Bounds.Width - cx,
3466 e.Bounds.Y + ((e.Bounds.Height - cy) /2), color_back);
3472 /* Draw checked or radio */
3473 if (item.MenuBar == false && item.Checked) {
3475 Rectangle area = e.Bounds;
3476 int cx = MenuCheckSize.Width;
3477 int cy = MenuCheckSize.Height;
3478 Bitmap bmp = CreateGlyphBitmap (new Size (cx, cy), item.RadioCheck ? MenuGlyph.Bullet : MenuGlyph.Checkmark, color_text);
3480 e.Graphics.DrawImage (bmp, area.X, e.Bounds.Y + ((e.Bounds.Height - cy) / 2));
3486 public override void DrawPopupMenu (Graphics dc, Menu menu, Rectangle cliparea, Rectangle rect)
3488 // Fill rectangle area
3489 dc.FillRectangle (SystemBrushes.Menu, cliparea);
3491 // Draw menu borders
3492 CPDrawBorder3D (dc, rect, Border3DStyle.Raised, all_sides);
3495 for (int i = 0; i < menu.MenuItems.Count; i++) {
3496 if (cliparea.IntersectsWith (menu.MenuItems [i].bounds)) {
3497 MenuItem item = menu.MenuItems [i];
3498 item.MenuHeight = menu.Height;
3499 item.PerformDrawItem (new DrawItemEventArgs (dc, MenuFont, item.bounds, i, item.Status));
3506 #region MonthCalendar
3508 // draw the month calendar
3509 public override void DrawMonthCalendar(Graphics dc, Rectangle clip_rectangle, MonthCalendar mc)
3511 Rectangle client_rectangle = mc.ClientRectangle;
3512 Size month_size = mc.SingleMonthSize;
3513 // cache local copies of Marshal-by-ref internal members (gets around error CS0197)
3514 Size calendar_spacing = (Size)((object)mc.calendar_spacing);
3515 Size date_cell_size = (Size)((object)mc.date_cell_size);
3517 // draw the singlecalendars
3520 // adjust for the position of the specific month
3521 for (int i=0; i < mc.CalendarDimensions.Height; i++)
3525 y_offset += month_size.Height + calendar_spacing.Height;
3527 // now adjust for x position
3528 for (int j=0; j < mc.CalendarDimensions.Width; j++)
3532 x_offset += month_size.Width + calendar_spacing.Width;
3539 Rectangle month_rect = new Rectangle (x_offset, y_offset, month_size.Width, month_size.Height);
3540 if (month_rect.IntersectsWith (clip_rectangle)) {
3552 Rectangle bottom_rect = new Rectangle (
3554 Math.Max(client_rectangle.Bottom - date_cell_size.Height - 3, 0),
3555 client_rectangle.Width,
3556 date_cell_size.Height + 2);
3557 // draw the today date if it's set
3558 if (mc.ShowToday && bottom_rect.IntersectsWith (clip_rectangle))
3560 dc.FillRectangle (GetControlBackBrush (mc.BackColor), bottom_rect);
3562 int today_offset = 5;
3563 if (mc.ShowTodayCircle)
3565 Rectangle today_circle_rect = new Rectangle (
3566 client_rectangle.X + 5,
3567 Math.Max(client_rectangle.Bottom - date_cell_size.Height - 2, 0),
3568 date_cell_size.Width,
3569 date_cell_size.Height);
3570 DrawTodayCircle (dc, today_circle_rect);
3571 today_offset += date_cell_size.Width + 5;
3573 // draw today's date
3574 StringFormat text_format = new StringFormat();
3575 text_format.LineAlignment = StringAlignment.Center;
3576 text_format.Alignment = StringAlignment.Near;
3577 Rectangle today_rect = new Rectangle (
3578 today_offset + client_rectangle.X,
3579 Math.Max(client_rectangle.Bottom - date_cell_size.Height, 0),
3580 Math.Max(client_rectangle.Width - today_offset, 0),
3581 date_cell_size.Height);
3582 dc.DrawString ("Today: " + DateTime.Now.ToShortDateString(), mc.bold_font, GetControlForeBrush (mc.ForeColor), today_rect, text_format);
3583 text_format.Dispose ();
3589 if (mc.owner == null)
3590 border_brush = GetControlBackBrush (mc.BackColor);
3592 border_brush = SystemBrushes.ControlDarkDark;
3594 // finally paint the borders of the calendars as required
3595 for (int i = 0; i <= mc.CalendarDimensions.Width; i++) {
3596 if (i == 0 && clip_rectangle.X == client_rectangle.X) {
3597 dc.FillRectangle (border_brush, client_rectangle.X, client_rectangle.Y, 1, client_rectangle.Height);
3598 } else if (i == mc.CalendarDimensions.Width && clip_rectangle.Right == client_rectangle.Right) {
3599 dc.FillRectangle (border_brush, client_rectangle.Right - 1, client_rectangle.Y, 1, client_rectangle.Height);
3601 Rectangle rect = new Rectangle (
3602 client_rectangle.X + (month_size.Width*i) + (calendar_spacing.Width * (i-1)) + 1,
3604 calendar_spacing.Width,
3605 client_rectangle.Height);
3606 if (i < mc.CalendarDimensions.Width && i > 0 && clip_rectangle.IntersectsWith (rect)) {
3607 dc.FillRectangle (border_brush, rect);
3611 for (int i = 0; i <= mc.CalendarDimensions.Height; i++) {
3612 if (i == 0 && clip_rectangle.Y == client_rectangle.Y) {
3613 dc.FillRectangle (border_brush, client_rectangle.X, client_rectangle.Y, client_rectangle.Width, 1);
3614 } else if (i == mc.CalendarDimensions.Height && clip_rectangle.Bottom == client_rectangle.Bottom) {
3615 dc.FillRectangle (border_brush, client_rectangle.X, client_rectangle.Bottom - 1, client_rectangle.Width, 1);
3617 Rectangle rect = new Rectangle (
3619 client_rectangle.Y + (month_size.Height*i) + (calendar_spacing.Height*(i-1)) + 1,
3620 client_rectangle.Width,
3621 calendar_spacing.Height);
3622 if (i < mc.CalendarDimensions.Height && i > 0 && clip_rectangle.IntersectsWith (rect)) {
3623 dc.FillRectangle (border_brush, rect);
3628 // draw the drop down border if need
3629 if (mc.owner != null) {
3630 Rectangle bounds = mc.ClientRectangle;
3631 if (clip_rectangle.Contains (mc.Location)) {
3632 // find out if top or left line to draw
3633 if(clip_rectangle.Contains (new Point (bounds.Left, bounds.Bottom))) {
3635 dc.DrawLine (SystemPens.ControlText, bounds.X, bounds.Y, bounds.X, bounds.Bottom-1);
3637 if(clip_rectangle.Contains (new Point (bounds.Right, bounds.Y))) {
3638 dc.DrawLine (SystemPens.ControlText, bounds.X, bounds.Y, bounds.Right-1, bounds.Y);
3641 if (clip_rectangle.Contains (new Point(bounds.Right, bounds.Bottom))) {
3642 // find out if bottom or right line to draw
3643 if(clip_rectangle.Contains (new Point (bounds.Left, bounds.Bottom))) {
3644 dc.DrawLine (SystemPens.ControlText, bounds.X, bounds.Bottom-1, bounds.Right-1, bounds.Bottom-1);
3646 if(clip_rectangle.Contains (new Point (bounds.Right, bounds.Y))) {
3647 dc.DrawLine (SystemPens.ControlText, bounds.Right-1, bounds.Y, bounds.Right-1, bounds.Bottom-1);
3653 // darws a single part of the month calendar (with one month)
3654 private void DrawSingleMonth(Graphics dc, Rectangle clip_rectangle, Rectangle rectangle, MonthCalendar mc, int row, int col)
3656 // cache local copies of Marshal-by-ref internal members (gets around error CS0197)
3657 Size title_size = (Size)((object)mc.title_size);
3658 Size date_cell_size = (Size)((object)mc.date_cell_size);
3659 DateTime current_month = (DateTime)((object)mc.current_month);
3660 DateTime sunday = new DateTime(2006, 10, 1);
3662 // draw the title back ground
3663 DateTime this_month = current_month.AddMonths (row*mc.CalendarDimensions.Width+col);
3664 Rectangle title_rect = new Rectangle(rectangle.X, rectangle.Y, title_size.Width, title_size.Height);
3665 if (title_rect.IntersectsWith (clip_rectangle)) {
3666 dc.FillRectangle (ResPool.GetSolidBrush (mc.TitleBackColor), title_rect);
3668 string title_text = this_month.ToString ("MMMM yyyy");
3669 dc.DrawString (title_text, mc.bold_font, ResPool.GetSolidBrush (mc.TitleForeColor), title_rect, mc.centered_format);
3671 if (mc.ShowYearUpDown) {
3672 Rectangle year_rect;
3673 Rectangle upRect, downRect;
3674 ButtonState upState, downState;
3676 mc.GetYearNameRectangles (title_rect, row * mc.CalendarDimensions.Width + col, out year_rect, out upRect, out downRect);
3677 dc.FillRectangle (ResPool.GetSolidBrush (SystemColors.Control), year_rect);
3678 dc.DrawString (this_month.ToString ("yyyy"), mc.bold_font, ResPool.GetSolidBrush (Color.Black), year_rect, mc.centered_format);
3680 upState = mc.IsYearGoingUp ? ButtonState.Pushed : ButtonState.Normal;
3681 downState = mc.IsYearGoingDown ? ButtonState.Pushed : ButtonState.Normal;
3683 ControlPaint.DrawScrollButton (dc, upRect, ScrollButton.Up, upState);
3684 ControlPaint.DrawScrollButton (dc, downRect, ScrollButton.Down, downState);
3687 // draw previous and next buttons if it's time
3688 if (row == 0 && col == 0)
3690 // draw previous button
3691 DrawMonthCalendarButton (
3697 (System.Drawing.Size)((object)mc.button_size),
3700 if (row == 0 && col == mc.CalendarDimensions.Width-1)
3703 DrawMonthCalendarButton (
3709 (System.Drawing.Size)((object)mc.button_size),
3714 // set the week offset and draw week nums if needed
3715 int col_offset = (mc.ShowWeekNumbers) ? 1 : 0;
3716 Rectangle day_name_rect = new Rectangle(
3718 rectangle.Y + title_size.Height,
3719 (7 + col_offset) * date_cell_size.Width,
3720 date_cell_size.Height);
3721 if (day_name_rect.IntersectsWith (clip_rectangle)) {
3722 dc.FillRectangle (GetControlBackBrush (mc.BackColor), day_name_rect);
3723 // draw the day names
3724 DayOfWeek first_day_of_week = mc.GetDayOfWeek(mc.FirstDayOfWeek);
3725 for (int i=0; i < 7; i++)
3727 int position = i - (int) first_day_of_week;
3730 position = 7 + position;
3733 Rectangle day_rect = new Rectangle(
3734 day_name_rect.X + ((i + col_offset)* date_cell_size.Width),
3736 date_cell_size.Width,
3737 date_cell_size.Height);
3738 dc.DrawString (sunday.AddDays (i + (int) first_day_of_week).ToString ("ddd"), mc.Font, ResPool.GetSolidBrush (mc.TitleBackColor), day_rect, mc.centered_format);
3741 // draw the vertical divider
3742 int vert_divider_y = Math.Max(title_size.Height+ date_cell_size.Height-1, 0);
3744 ResPool.GetPen (mc.ForeColor),
3745 rectangle.X + (col_offset * date_cell_size.Width) + mc.divider_line_offset,
3746 rectangle.Y + vert_divider_y,
3747 rectangle.Right - mc.divider_line_offset,
3748 rectangle.Y + vert_divider_y);
3752 // draw the actual date items in the grid (including the week numbers)
3753 Rectangle date_rect = new Rectangle (
3755 rectangle.Y + title_size.Height + date_cell_size.Height,
3756 date_cell_size.Width,
3757 date_cell_size.Height);
3758 int month_row_count = 0;
3759 bool draw_week_num_divider = false;
3760 DateTime current_date = mc.GetFirstDateInMonthGrid ( new DateTime (this_month.Year, this_month.Month, 1));
3761 for (int i=0; i < 6; i++)
3763 // establish if this row is in our clip_area
3764 Rectangle row_rect = new Rectangle (
3766 rectangle.Y + title_size.Height + (date_cell_size.Height * (i+1)),
3767 date_cell_size.Width * 7,
3768 date_cell_size.Height);
3769 if (mc.ShowWeekNumbers) {
3770 row_rect.Width += date_cell_size.Width;
3773 bool draw_row = row_rect.IntersectsWith (clip_rectangle);
3775 dc.FillRectangle (GetControlBackBrush (mc.BackColor), row_rect);
3777 // establish if this is a valid week to draw
3778 if (mc.IsValidWeekToDraw (this_month, current_date, row, col)) {
3779 month_row_count = i;
3782 // draw the week number if required
3783 if (mc.ShowWeekNumbers && month_row_count == i) {
3784 if (!draw_week_num_divider) {
3785 draw_week_num_divider = draw_row;
3787 // get the week for this row
3788 int week = mc.GetWeekOfYear (current_date);
3794 ResPool.GetSolidBrush (mc.TitleBackColor),
3796 mc.centered_format);
3798 date_rect.Offset(date_cell_size.Width, 0);
3801 // only draw the days if we have to
3802 if(month_row_count == i) {
3803 for (int j=0; j < 7; j++)
3806 DrawMonthCalendarDate (
3817 current_date = current_date.AddDays(1);
3818 date_rect.Offset(date_cell_size.Width, 0);
3821 // shift the rectangle down one row
3822 int offset = (mc.ShowWeekNumbers) ? -8 : -7;
3823 date_rect.Offset(offset*date_cell_size.Width, date_cell_size.Height);
3827 // month_row_count is zero based, so add one
3830 // draw week numbers if required
3831 if (draw_week_num_divider) {
3834 ResPool.GetPen (mc.ForeColor),
3835 rectangle.X + date_cell_size.Width - 1,
3836 rectangle.Y + title_size.Height + date_cell_size.Height + mc.divider_line_offset,
3837 rectangle.X + date_cell_size.Width - 1,
3838 rectangle.Y + title_size.Height + date_cell_size.Height + (month_row_count * date_cell_size.Height) - mc.divider_line_offset);
3842 // draws the pervious or next button
3843 private void DrawMonthCalendarButton (Graphics dc, Rectangle rectangle, MonthCalendar mc, Size title_size, int x_offset, Size button_size, bool is_previous)
3845 const int arrow_width = 4;
3846 const int arrow_height = 7;
3848 bool is_clicked = false;
3849 Rectangle button_rect;
3850 PointF arrow_center;
3851 PointF [] arrow_path = new PointF [3];
3853 // prepare the button
3856 is_clicked = mc.is_previous_clicked;
3858 button_rect = new Rectangle (
3859 rectangle.X + 1 + x_offset,
3860 rectangle.Y + 1 + ((title_size.Height - button_size.Height)/2),
3861 Math.Max(button_size.Width - 1, 0),
3862 Math.Max(button_size.Height - 1, 0));
3864 arrow_center = new PointF (button_rect.X + ((button_rect.Width + arrow_width) / 2.0f),
3865 rectangle.Y + ((button_rect.Height + arrow_height) / 2) + 1);
3867 arrow_center.X += 1;
3868 arrow_center.Y += 1;
3871 arrow_path [0].X = arrow_center.X;
3872 arrow_path [0].Y = arrow_center.Y - arrow_height / 2.0f + 0.5f;
3873 arrow_path [1].X = arrow_center.X;
3874 arrow_path [1].Y = arrow_center.Y + arrow_height / 2.0f + 0.5f;
3875 arrow_path [2].X = arrow_center.X - arrow_width;
3876 arrow_path [2].Y = arrow_center.Y + 0.5f;
3880 is_clicked = mc.is_next_clicked;
3882 button_rect = new Rectangle (
3883 rectangle.Right - 1 - x_offset - button_size.Width,
3884 rectangle.Y + 1 + ((title_size.Height - button_size.Height)/2),
3885 Math.Max(button_size.Width - 1, 0),
3886 Math.Max(button_size.Height - 1, 0));
3888 arrow_center = new PointF (button_rect.X + ((button_rect.Width + arrow_width) / 2.0f),
3889 rectangle.Y + ((button_rect.Height + arrow_height) / 2) + 1);
3891 arrow_center.X += 1;
3892 arrow_center.Y += 1;
3895 arrow_path [0].X = arrow_center.X - arrow_width;
3896 arrow_path [0].Y = arrow_center.Y - arrow_height / 2.0f + 0.5f;
3897 arrow_path [1].X = arrow_center.X - arrow_width;
3898 arrow_path [1].Y = arrow_center.Y + arrow_height / 2.0f + 0.5f;
3899 arrow_path [2].X = arrow_center.X;
3900 arrow_path [2].Y = arrow_center.Y + 0.5f;
3903 // fill the background
3904 dc.FillRectangle (SystemBrushes.Control, button_rect);
3907 dc.DrawRectangle (SystemPens.ControlDark, button_rect);
3910 CPDrawBorder3D (dc, button_rect, Border3DStyle.Raised, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom);
3913 dc.FillPolygon (SystemBrushes.ControlText, arrow_path);
3914 //dc.FillPolygon (SystemBrushes.ControlText, arrow_path, FillMode.Winding);
3918 // draws one day in the calendar grid
3919 private void DrawMonthCalendarDate (Graphics dc, Rectangle rectangle, MonthCalendar mc, DateTime date, DateTime month, int row, int col) {
3920 Color date_color = mc.ForeColor;
3921 Rectangle interior = new Rectangle (rectangle.X, rectangle.Y, Math.Max(rectangle.Width - 1, 0), Math.Max(rectangle.Height - 1, 0));
3923 // find out if we are the lead of the first calendar or the trail of the last calendar
3924 if (date.Year != month.Year || date.Month != month.Month) {
3925 DateTime check_date = month.AddMonths (-1);
3926 // check if it's the month before
3927 if (check_date.Year == date.Year && check_date.Month == date.Month && row == 0 && col == 0) {
3928 date_color = mc.TrailingForeColor;
3930 // check if it's the month after
3931 check_date = month.AddMonths (1);
3932 if (check_date.Year == date.Year && check_date.Month == date.Month && row == mc.CalendarDimensions.Height-1 && col == mc.CalendarDimensions.Width-1) {
3933 date_color = mc.TrailingForeColor;
3939 date_color = mc.ForeColor;
3942 const int inflate = -1;
3944 if (date == mc.SelectionStart.Date && date == mc.SelectionEnd.Date) {
3945 // see if the date is in the start of selection
3946 date_color = mc.BackColor;
3947 // draw the left hand of the back ground
3948 Rectangle selection_rect = Rectangle.Inflate (rectangle, inflate, inflate);
3949 dc.FillPie (ResPool.GetSolidBrush (mc.TitleBackColor), selection_rect, 0, 360);
3950 } else if (date == mc.SelectionStart.Date) {
3951 // see if the date is in the start of selection
3952 date_color = mc.BackColor;
3953 // draw the left hand of the back ground
3954 Rectangle selection_rect = Rectangle.Inflate (rectangle, inflate, inflate);
3955 dc.FillPie (ResPool.GetSolidBrush (mc.TitleBackColor), selection_rect, 90, 180);
3956 // fill the other side as a straight rect
3957 if (date < mc.SelectionEnd.Date)
3959 // use rectangle instead of rectangle to go all the way to edge of rect
3960 selection_rect.X = (int) Math.Floor((double)(rectangle.X + rectangle.Width / 2));
3961 selection_rect.Width = Math.Max(rectangle.Right - selection_rect.X, 0);
3962 dc.FillRectangle (ResPool.GetSolidBrush (mc.TitleBackColor), selection_rect);
3964 } else if (date == mc.SelectionEnd.Date) {
3965 // see if it is the end of selection
3966 date_color = mc.BackColor;
3967 // draw the left hand of the back ground
3968 Rectangle selection_rect = Rectangle.Inflate (rectangle, inflate, inflate);
3969 dc.FillPie (ResPool.GetSolidBrush (mc.TitleBackColor), selection_rect, 270, 180);
3970 // fill the other side as a straight rect
3971 if (date > mc.SelectionStart.Date) {
3972 selection_rect.X = rectangle.X;
3973 selection_rect.Width = rectangle.Width - (rectangle.Width / 2);
3974 dc.FillRectangle (ResPool.GetSolidBrush (mc.TitleBackColor), selection_rect);
3976 } else if (date > mc.SelectionStart.Date && date < mc.SelectionEnd.Date) {
3977 // now see if it's in the middle
3978 date_color = mc.BackColor;
3979 // draw the left hand of the back ground
3980 Rectangle selection_rect = Rectangle.Inflate (rectangle, 0, inflate);
3981 dc.FillRectangle (ResPool.GetSolidBrush (mc.TitleBackColor), selection_rect);
3984 // establish if it's a bolded font
3985 Font font = mc.IsBoldedDate (date) ? mc.bold_font : mc.Font;
3987 // just draw the date now
3988 dc.DrawString (date.Day.ToString(), font, ResPool.GetSolidBrush (date_color), rectangle, mc.centered_format);
3990 // today circle if needed
3991 if (mc.ShowTodayCircle && date == DateTime.Now.Date) {
3992 DrawTodayCircle (dc, interior);
3995 // draw the selection grid
3996 if (mc.is_date_clicked && mc.clicked_date == date) {
3997 Pen pen = ResPool.GetDashPen (Color.Black, DashStyle.Dot);
3998 dc.DrawRectangle (pen, interior);
4002 private void DrawTodayCircle (Graphics dc, Rectangle rectangle) {
4003 Color circle_color = Color.FromArgb (248, 0, 0);
4004 // draw the left hand of the circle
4005 Rectangle lhs_circle_rect = new Rectangle (rectangle.X + 1, rectangle.Y + 4, Math.Max(rectangle.Width - 2, 0), Math.Max(rectangle.Height - 5, 0));
4006 Rectangle rhs_circle_rect = new Rectangle (rectangle.X + 1, rectangle.Y + 1, Math.Max(rectangle.Width - 2, 0), Math.Max(rectangle.Height - 2, 0));
4007 Point [] curve_points = new Point [3];
4008 curve_points [0] = new Point (lhs_circle_rect.X, rhs_circle_rect.Y + rhs_circle_rect.Height/12);
4009 curve_points [1] = new Point (lhs_circle_rect.X + lhs_circle_rect.Width/9, rhs_circle_rect.Y);
4010 curve_points [2] = new Point (lhs_circle_rect.X + lhs_circle_rect.Width/2 + 1, rhs_circle_rect.Y);
4012 Pen pen = ResPool.GetSizedPen(circle_color, 2);
4013 dc.DrawArc (pen, lhs_circle_rect, 90, 180);
4014 dc.DrawArc (pen, rhs_circle_rect, 270, 180);
4015 dc.DrawCurve (pen, curve_points);
4016 dc.DrawLine (ResPool.GetPen (circle_color), curve_points [2], new Point (curve_points [2].X, lhs_circle_rect.Y));
4019 #endregion // MonthCalendar
4022 public override Size PanelDefaultSize {
4024 return new Size (200, 100);
4030 public override void DrawPictureBox (Graphics dc, Rectangle clip, PictureBox pb) {
4031 Rectangle client = pb.ClientRectangle;
4033 // FIXME - instead of drawing the whole picturebox every time
4034 // intersect the clip rectangle with the drawn picture and only draw what's needed,
4035 // Also, we only need a background fill where no image goes
4036 if (pb.Image != null) {
4037 switch (pb.SizeMode) {
4038 case PictureBoxSizeMode.StretchImage:
4039 dc.DrawImage (pb.Image, 0, 0, client.Width, client.Height);
4042 case PictureBoxSizeMode.CenterImage:
4043 dc.DrawImage (pb.Image, (client.Width / 2) - (pb.Image.Width / 2), (client.Height / 2) - (pb.Image.Height / 2));
4046 case PictureBoxSizeMode.Zoom:
4049 if (((float)pb.Image.Width / (float)pb.Image.Height) >= ((float)client.Width / (float)client.Height))
4050 image_size = new Size (client.Width, (pb.Image.Height * client.Width) / pb.Image.Width);
4052 image_size = new Size ((pb.Image.Width * client.Height) / pb.Image.Height, client.Height);
4054 dc.DrawImage (pb.Image, (client.Width / 2) - (image_size.Width / 2), (client.Height / 2) - (image_size.Height / 2), image_size.Width, image_size.Height);
4059 dc.DrawImage(pb.Image, 0, 0, pb.Image.Width, pb.Image.Height);
4067 public override Size PictureBoxDefaultSize {
4069 return new Size (100, 50);
4072 #endregion // PictureBox
4074 #region PrintPreviewControl
4075 public override int PrintPreviewControlPadding {
4079 public override Size PrintPreviewControlGetPageSize (PrintPreviewControl preview)
4081 int page_width, page_height;
4082 int padding = PrintPreviewControlPadding;
4083 PreviewPageInfo[] pis = preview.page_infos;
4085 if (preview.AutoZoom) {
4086 int height_available = preview.ClientRectangle.Height - (preview.Rows) * padding - 2 * padding;
4087 int width_available = preview.ClientRectangle.Width - (preview.Columns - 1) * padding - 2 * padding;
4089 float image_ratio = (float)pis[0].Image.Width / pis[0].Image.Height;
4091 /* try to lay things out using the width to determine the size */
4092 page_width = width_available / preview.Columns;
4093 page_height = (int)(page_width / image_ratio);
4095 /* does the height fit? */
4096 if (page_height * (preview.Rows + 1) > height_available) {
4097 /* no, lay things out via the height */
4098 page_height = height_available / (preview.Rows + 1);
4099 page_width = (int)(page_height * image_ratio);
4103 page_width = (int)(pis[0].Image.Width * preview.Zoom);
4104 page_height = (int)(pis[0].Image.Height * preview.Zoom);
4107 return new Size (page_width, page_height);
4110 public override void PrintPreviewControlPaint (PaintEventArgs pe, PrintPreviewControl preview, Size page_size)
4113 PreviewPageInfo[] pis = preview.page_infos;
4119 int width = page_size.Width * preview.Columns + padding * (preview.Columns - 1) + 2 * padding;
4120 int height = page_size.Height * (preview.Rows + 1) + padding * preview.Rows + 2 * padding;
4122 Rectangle viewport = preview.ViewPort;
4124 pe.Graphics.Clip = new Region (viewport);
4126 /* center things if we can */
4127 int off_x = viewport.Width / 2 - width / 2;
4128 if (off_x < 0) off_x = 0;
4129 int off_y = viewport.Height / 2 - height / 2;
4130 if (off_y < 0) off_y = 0;
4132 page_y = off_y + padding - preview.vbar_value;
4134 if (preview.StartPage > 0) {
4135 int p = preview.StartPage - 1;
4136 for (int py = 0; py < preview.Rows + 1; py ++) {
4137 page_x = off_x + padding - preview.hbar_value;
4138 for (int px = 0; px < preview.Columns; px ++) {
4139 if (p >= pis.Length)
4141 Image image = preview.image_cache[p];
4143 image = pis[p].Image;
4144 Rectangle dest = new Rectangle (new Point (page_x, page_y), page_size);
4146 pe.Graphics.DrawImage (image, dest, 0, 0, image.Width, image.Height, GraphicsUnit.Pixel);
4148 page_x += padding + page_size.Width;
4151 page_y += padding + page_size.Height;
4155 #endregion // PrintPreviewControl
4158 public override void DrawProgressBar (Graphics dc, Rectangle clip_rect, ProgressBar ctrl)
4160 Rectangle client_area = ctrl.client_area;
4163 CPDrawBorder3D (dc, ctrl.ClientRectangle, Border3DStyle.SunkenOuter, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom & ~Border3DSide.Middle, ColorControl);
4167 int max_blocks = int.MaxValue;
4168 int start_pixel = client_area.X;
4170 draw_mode = (int) ctrl.Style;
4172 switch (draw_mode) {
4174 case 1: { // Continuous
4176 pixels_to_draw = (int)(client_area.Width * ((double)(ctrl.Value - ctrl.Minimum) / (double)(Math.Max(ctrl.Maximum - ctrl.Minimum, 1))));
4177 dc.FillRectangle (ResPool.GetSolidBrush (progressbarblock_color), new Rectangle (client_area.X, client_area.Y, pixels_to_draw, client_area.Height));
4181 if (XplatUI.ThemesEnabled) {
4182 int ms_diff = (int) (DateTime.Now - ctrl.start).TotalMilliseconds;
4183 double percent_done = (double) ms_diff % (double)ctrl.MarqueeAnimationSpeed / (double)ctrl.MarqueeAnimationSpeed;
4185 start_pixel = client_area.X + (int) (client_area.Width * percent_done);
4192 Rectangle block_rect;
4193 int space_betweenblocks = 2;
4197 int block_count = 0;
4199 block_width = (client_area.Height * 2) / 3;
4200 barpos_pixels = (int)(((double)(ctrl.Value - ctrl.Minimum) * client_area.Width) / (Math.Max (ctrl.Maximum - ctrl.Minimum, 1)));
4201 increment = block_width + space_betweenblocks;
4203 block_rect = new Rectangle (start_pixel, client_area.Y, block_width, client_area.Height);
4205 if (max_blocks != int.MaxValue) {
4206 if (block_count >= max_blocks)
4208 if (block_rect.X > client_area.Width)
4209 block_rect.X -= client_area.Width;
4211 if ((block_rect.X - client_area.X) >= barpos_pixels)
4215 if (clip_rect.IntersectsWith (block_rect) == true) {
4216 dc.FillRectangle (ResPool.GetSolidBrush (progressbarblock_color), block_rect);
4219 block_rect.X += increment;
4227 public override Size ProgressBarDefaultSize {
4229 return new Size (100, 23);
4233 #endregion // ProgressBar
4236 public override void DrawRadioButton (Graphics dc, Rectangle clip_rectangle, RadioButton radio_button) {
4237 StringFormat text_format;
4238 Rectangle client_rectangle;
4239 Rectangle text_rectangle;
4240 Rectangle radiobutton_rectangle;
4241 int radiobutton_size = 13;
4242 int radiobutton_space = 4;
4244 client_rectangle = radio_button.ClientRectangle;
4245 text_rectangle = client_rectangle;
4246 radiobutton_rectangle = new Rectangle(text_rectangle.X, text_rectangle.Y, radiobutton_size, radiobutton_size);
4248 text_format = new StringFormat();
4249 text_format.Alignment = StringAlignment.Near;
4250 text_format.LineAlignment = StringAlignment.Center;
4251 text_format.HotkeyPrefix = HotkeyPrefix.Show;
4253 /* Calculate the position of text and checkbox rectangle */
4254 if (radio_button.appearance!=Appearance.Button) {
4255 switch(radio_button.radiobutton_alignment) {
4256 case ContentAlignment.BottomCenter: {
4257 radiobutton_rectangle.X=(client_rectangle.Right-client_rectangle.Left)/2-radiobutton_size/2;
4258 radiobutton_rectangle.Y=client_rectangle.Bottom-radiobutton_size;
4259 text_rectangle.X=client_rectangle.X;
4260 text_rectangle.Width=client_rectangle.Width;
4261 text_rectangle.Height=client_rectangle.Height-radiobutton_size-radiobutton_space;
4265 case ContentAlignment.BottomLeft: {
4266 radiobutton_rectangle.X=client_rectangle.Left;
4267 radiobutton_rectangle.Y=client_rectangle.Bottom-radiobutton_size;
4268 text_rectangle.X=client_rectangle.X+radiobutton_size+radiobutton_space;
4269 text_rectangle.Width=client_rectangle.Width-radiobutton_size-radiobutton_space;
4273 case ContentAlignment.BottomRight: {
4274 radiobutton_rectangle.X=client_rectangle.Right-radiobutton_size;
4275 radiobutton_rectangle.Y=client_rectangle.Bottom-radiobutton_size;
4276 text_rectangle.X=client_rectangle.X;
4277 text_rectangle.Width=client_rectangle.Width-radiobutton_size-radiobutton_space;
4281 case ContentAlignment.MiddleCenter: {
4282 radiobutton_rectangle.X=(client_rectangle.Right-client_rectangle.Left)/2-radiobutton_size/2;
4283 radiobutton_rectangle.Y=(client_rectangle.Bottom-client_rectangle.Top)/2-radiobutton_size/2;
4284 text_rectangle.X=client_rectangle.X;
4285 text_rectangle.Width=client_rectangle.Width;
4290 case ContentAlignment.MiddleLeft: {
4291 radiobutton_rectangle.X=client_rectangle.Left;
4292 radiobutton_rectangle.Y=(client_rectangle.Bottom-client_rectangle.Top)/2-radiobutton_size/2;
4293 text_rectangle.X=client_rectangle.X+radiobutton_size+radiobutton_space;
4294 text_rectangle.Width=client_rectangle.Width-radiobutton_size-radiobutton_space;
4298 case ContentAlignment.MiddleRight: {
4299 radiobutton_rectangle.X=client_rectangle.Right-radiobutton_size;
4300 radiobutton_rectangle.Y=(client_rectangle.Bottom-client_rectangle.Top)/2-radiobutton_size/2;
4301 text_rectangle.X=client_rectangle.X;
4302 text_rectangle.Width=client_rectangle.Width-radiobutton_size-radiobutton_space;
4306 case ContentAlignment.TopCenter: {
4307 radiobutton_rectangle.X=(client_rectangle.Right-client_rectangle.Left)/2-radiobutton_size/2;
4308 radiobutton_rectangle.Y=client_rectangle.Top;
4309 text_rectangle.X=client_rectangle.X;
4310 text_rectangle.Y=radiobutton_size+radiobutton_space;
4311 text_rectangle.Width=client_rectangle.Width;
4312 text_rectangle.Height=client_rectangle.Height-radiobutton_size-radiobutton_space;
4316 case ContentAlignment.TopLeft: {
4317 radiobutton_rectangle.X=client_rectangle.Left;
4318 radiobutton_rectangle.Y=client_rectangle.Top;
4319 text_rectangle.X=client_rectangle.X+radiobutton_size+radiobutton_space;
4320 text_rectangle.Width=client_rectangle.Width-radiobutton_size-radiobutton_space;
4324 case ContentAlignment.TopRight: {
4325 radiobutton_rectangle.X=client_rectangle.Right-radiobutton_size;
4326 radiobutton_rectangle.Y=client_rectangle.Top;
4327 text_rectangle.X=client_rectangle.X;
4328 text_rectangle.Width=client_rectangle.Width-radiobutton_size-radiobutton_space;
4333 text_rectangle.X=client_rectangle.X;
4334 text_rectangle.Width=client_rectangle.Width;
4337 /* Set the horizontal alignment of our text */
4338 switch(radio_button.text_alignment) {
4339 case ContentAlignment.BottomLeft:
4340 case ContentAlignment.MiddleLeft:
4341 case ContentAlignment.TopLeft: {
4342 text_format.Alignment=StringAlignment.Near;
4346 case ContentAlignment.BottomCenter:
4347 case ContentAlignment.MiddleCenter:
4348 case ContentAlignment.TopCenter: {
4349 text_format.Alignment=StringAlignment.Center;
4353 case ContentAlignment.BottomRight:
4354 case ContentAlignment.MiddleRight:
4355 case ContentAlignment.TopRight: {
4356 text_format.Alignment=StringAlignment.Far;
4361 /* Set the vertical alignment of our text */
4362 switch(radio_button.text_alignment) {
4363 case ContentAlignment.TopLeft:
4364 case ContentAlignment.TopCenter:
4365 case ContentAlignment.TopRight: {
4366 text_format.LineAlignment=StringAlignment.Near;
4370 case ContentAlignment.BottomLeft:
4371 case ContentAlignment.BottomCenter:
4372 case ContentAlignment.BottomRight: {
4373 text_format.LineAlignment=StringAlignment.Far;
4377 case ContentAlignment.MiddleLeft:
4378 case ContentAlignment.MiddleCenter:
4379 case ContentAlignment.MiddleRight: {
4380 text_format.LineAlignment=StringAlignment.Center;
4385 ButtonState state = ButtonState.Normal;
4386 if (radio_button.FlatStyle == FlatStyle.Flat) {
4387 state |= ButtonState.Flat;
4390 if (radio_button.Checked) {
4391 state |= ButtonState.Checked;
4394 if (!radio_button.Enabled) {
4395 state |= ButtonState.Inactive;
4399 RadioButton_DrawButton(radio_button, dc, state, radiobutton_rectangle);
4401 if ((radio_button.image != null) || (radio_button.image_list != null))
4402 ButtonBase_DrawImage(radio_button, dc);
4404 RadioButton_DrawText(radio_button, text_rectangle, dc, text_format);
4406 if (radio_button.Focused && radio_button.Enabled && radio_button.appearance != Appearance.Button && radio_button.Text != String.Empty && radio_button.ShowFocusCues) {
4407 SizeF text_size = dc.MeasureString (radio_button.Text, radio_button.Font);
4409 Rectangle focus_rect = Rectangle.Empty;
4410 focus_rect.X = text_rectangle.X;
4411 focus_rect.Y = (int)((text_rectangle.Height - text_size.Height) / 2);
4412 focus_rect.Size = text_size.ToSize ();
4414 RadioButton_DrawFocus (radio_button, dc, focus_rect);
4417 text_format.Dispose ();
4420 protected virtual void RadioButton_DrawButton(RadioButton radio_button, Graphics dc, ButtonState state, Rectangle radiobutton_rectangle)
4422 dc.FillRectangle(GetControlBackBrush (radio_button.BackColor), radio_button.ClientRectangle);
4424 if (radio_button.appearance==Appearance.Button) {
4425 ButtonBase_DrawButton (radio_button, dc);
4427 if ((radio_button.Focused) && radio_button.Enabled)
4428 ButtonBase_DrawFocus(radio_button, dc);
4430 // establish if we are rendering a flat style of some sort
4431 if (radio_button.FlatStyle == FlatStyle.Flat || radio_button.FlatStyle == FlatStyle.Popup) {
4432 DrawFlatStyleRadioButton (dc, radiobutton_rectangle, radio_button);
4434 CPDrawRadioButton(dc, radiobutton_rectangle, state);
4439 protected virtual void RadioButton_DrawText(RadioButton radio_button, Rectangle text_rectangle, Graphics dc, StringFormat text_format)
4441 DrawCheckBox_and_RadioButtonText (radio_button, text_rectangle, dc,
4442 text_format, radio_button.Appearance, radio_button.Checked);
4445 protected virtual void RadioButton_DrawFocus(RadioButton radio_button, Graphics dc, Rectangle text_rectangle)
4447 DrawInnerFocusRectangle (dc, text_rectangle, radio_button.BackColor);
4451 // renders a radio button with the Flat and Popup FlatStyle
4452 protected virtual void DrawFlatStyleRadioButton (Graphics graphics, Rectangle rectangle, RadioButton radio_button)
4456 if (radio_button.Enabled) {
4458 // draw the outer flatstyle arcs
4459 if (radio_button.FlatStyle == FlatStyle.Flat) {
4460 graphics.DrawArc (SystemPens.ControlDarkDark, rectangle, 0, 359);
4462 // fill in the area depending on whether or not the mouse is hovering
4463 if ((radio_button.is_entered || radio_button.Capture) && !radio_button.is_pressed) {
4464 graphics.FillPie (SystemBrushes.ControlLight, rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2, 0, 359);
4466 graphics.FillPie (SystemBrushes.ControlLightLight, rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2, 0, 359);
4469 // must be a popup radio button
4471 graphics.FillPie (SystemBrushes.ControlLightLight, rectangle, 0, 359);
4473 if (radio_button.is_entered || radio_button.Capture) {
4474 // draw the popup 3d button knob
4475 graphics.DrawArc (SystemPens.ControlLight, rectangle.X+1, rectangle.Y+1, rectangle.Width-2, rectangle.Height-2, 0, 359);
4477 graphics.DrawArc (SystemPens.ControlDark, rectangle, 135, 180);
4478 graphics.DrawArc (SystemPens.ControlLightLight, rectangle, 315, 180);
4481 // just draw lighter flatstyle outer circle
4482 graphics.DrawArc (SystemPens.ControlDark, rectangle, 0, 359);
4487 // fill control background color regardless of actual backcolor
4488 graphics.FillPie (SystemBrushes.Control, rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2, 0, 359);
4489 // draw the ark as control dark
4490 graphics.DrawArc (SystemPens.ControlDark, rectangle, 0, 359);
4494 if (radio_button.Checked) {
4495 lineWidth = Math.Max (1, Math.Min(rectangle.Width, rectangle.Height)/3);
4497 Pen dot_pen = SystemPens.ControlDarkDark;
4498 Brush dot_brush = SystemBrushes.ControlDarkDark;
4500 if (!radio_button.Enabled || ((radio_button.FlatStyle == FlatStyle.Popup) && radio_button.is_pressed)) {
4501 dot_pen = SystemPens.ControlDark;
4502 dot_brush = SystemBrushes.ControlDark;
4505 if (rectangle.Height > 13) {
4506 graphics.FillPie (dot_brush, rectangle.X + lineWidth, rectangle.Y + lineWidth, rectangle.Width - lineWidth * 2, rectangle.Height - lineWidth * 2, 0, 359);
4508 int x_half_pos = (rectangle.Width / 2) + rectangle.X;
4509 int y_half_pos = (rectangle.Height / 2) + rectangle.Y;
4511 graphics.DrawLine (dot_pen, x_half_pos - 1, y_half_pos, x_half_pos + 2, y_half_pos);
4512 graphics.DrawLine (dot_pen, x_half_pos - 1, y_half_pos + 1, x_half_pos + 2, y_half_pos + 1);
4514 graphics.DrawLine (dot_pen, x_half_pos, y_half_pos - 1, x_half_pos, y_half_pos + 2);
4515 graphics.DrawLine (dot_pen, x_half_pos + 1, y_half_pos - 1, x_half_pos + 1, y_half_pos + 2);
4520 public override Size RadioButtonDefaultSize {
4522 return new Size (104,24);
4527 public override void DrawRadioButton (Graphics g, RadioButton rb, Rectangle glyphArea, Rectangle textBounds, Rectangle imageBounds, Rectangle clipRectangle)
4529 // Draw Button Background
4530 if (rb.FlatStyle == FlatStyle.Flat || rb.FlatStyle == FlatStyle.Popup) {
4531 glyphArea.Height -= 2;
4532 glyphArea.Width -= 2;
4535 DrawRadioButtonGlyph (g, rb, glyphArea);
4537 // If we have an image, draw it
4538 if (imageBounds.Size != Size.Empty)
4539 DrawRadioButtonImage (g, rb, imageBounds);
4541 if (rb.Focused && rb.Enabled && rb.ShowFocusCues && textBounds.Size != Size.Empty)
4542 DrawRadioButtonFocus (g, rb, textBounds);
4544 // If we have text, draw it
4545 if (textBounds != Rectangle.Empty)
4546 DrawRadioButtonText (g, rb, textBounds);
4549 public virtual void DrawRadioButtonGlyph (Graphics g, RadioButton rb, Rectangle glyphArea)
4552 ThemeElements.CurrentTheme.RadioButtonPainter.PaintRadioButton (g, glyphArea, rb.BackColor, rb.ForeColor, ElementState.Pressed, rb.FlatStyle, rb.Checked);
4553 else if (rb.InternalSelected)
4554 ThemeElements.CurrentTheme.RadioButtonPainter.PaintRadioButton (g, glyphArea, rb.BackColor, rb.ForeColor, ElementState.Normal, rb.FlatStyle, rb.Checked);
4555 else if (rb.Entered)
4556 ThemeElements.CurrentTheme.RadioButtonPainter.PaintRadioButton (g, glyphArea, rb.BackColor, rb.ForeColor, ElementState.Hot, rb.FlatStyle, rb.Checked);
4557 else if (!rb.Enabled)
4558 ThemeElements.CurrentTheme.RadioButtonPainter.PaintRadioButton (g, glyphArea, rb.BackColor, rb.ForeColor, ElementState.Disabled, rb.FlatStyle, rb.Checked);
4560 ThemeElements.CurrentTheme.RadioButtonPainter.PaintRadioButton (g, glyphArea, rb.BackColor, rb.ForeColor, ElementState.Normal, rb.FlatStyle, rb.Checked);
4563 public virtual void DrawRadioButtonFocus (Graphics g, RadioButton rb, Rectangle focusArea)
4565 ControlPaint.DrawFocusRectangle (g, focusArea);
4568 public virtual void DrawRadioButtonImage (Graphics g, RadioButton rb, Rectangle imageBounds)
4571 g.DrawImage (rb.Image, imageBounds);
4573 CPDrawImageDisabled (g, rb.Image, imageBounds.Left, imageBounds.Top, ColorControl);
4576 public virtual void DrawRadioButtonText (Graphics g, RadioButton rb, Rectangle textBounds)
4579 TextRenderer.DrawTextInternal (g, rb.Text, rb.Font, textBounds, rb.ForeColor, rb.TextFormatFlags, rb.UseCompatibleTextRendering);
4581 DrawStringDisabled20 (g, rb.Text, rb.Font, textBounds, rb.BackColor, rb.TextFormatFlags, rb.UseCompatibleTextRendering);
4584 public override Size CalculateRadioButtonAutoSize (RadioButton rb)
4586 Size ret_size = Size.Empty;
4587 Size text_size = TextRenderer.MeasureTextInternal (rb.Text, rb.Font, rb.UseCompatibleTextRendering);
4588 Size image_size = rb.Image == null ? Size.Empty : rb.Image.Size;
4590 // Pad the text size
4591 if (rb.Text.Length != 0) {
4592 text_size.Height += 4;
4593 text_size.Width += 4;
4596 switch (rb.TextImageRelation) {
4597 case TextImageRelation.Overlay:
4598 ret_size.Height = Math.Max (rb.Text.Length == 0 ? 0 : text_size.Height, image_size.Height);
4599 ret_size.Width = Math.Max (text_size.Width, image_size.Width);
4601 case TextImageRelation.ImageAboveText:
4602 case TextImageRelation.TextAboveImage:
4603 ret_size.Height = text_size.Height + image_size.Height;
4604 ret_size.Width = Math.Max (text_size.Width, image_size.Width);
4606 case TextImageRelation.ImageBeforeText:
4607 case TextImageRelation.TextBeforeImage:
4608 ret_size.Height = Math.Max (text_size.Height, image_size.Height);
4609 ret_size.Width = text_size.Width + image_size.Width;
4614 ret_size.Height += (rb.Padding.Vertical);
4615 ret_size.Width += (rb.Padding.Horizontal) + 15;
4617 // There seems to be a minimum height
4618 if (ret_size.Height == rb.Padding.Vertical)
4619 ret_size.Height += 14;
4624 public override void CalculateRadioButtonTextAndImageLayout (ButtonBase b, Point offset, out Rectangle glyphArea, out Rectangle textRectangle, out Rectangle imageRectangle)
4626 CalculateCheckBoxTextAndImageLayout (b, offset, out glyphArea, out textRectangle, out imageRectangle);
4629 #endregion // RadioButton
4632 public override void DrawScrollBar (Graphics dc, Rectangle clip, ScrollBar bar)
4634 int scrollbutton_width = bar.scrollbutton_width;
4635 int scrollbutton_height = bar.scrollbutton_height;
4636 Rectangle first_arrow_area;
4637 Rectangle second_arrow_area;
4638 Rectangle thumb_pos;
4640 thumb_pos = bar.ThumbPos;
4643 first_arrow_area = new Rectangle(0, 0, bar.Width, scrollbutton_height);
4644 bar.FirstArrowArea = first_arrow_area;
4646 second_arrow_area = new Rectangle(0, bar.ClientRectangle.Height - scrollbutton_height, bar.Width, scrollbutton_height);
4647 bar.SecondArrowArea = second_arrow_area;
4649 thumb_pos.Width = bar.Width;
4650 bar.ThumbPos = thumb_pos;
4652 Brush VerticalBrush;
4653 /* Background, upper track */
4654 if (bar.thumb_moving == ScrollBar.ThumbMoving.Backwards)
4655 VerticalBrush = ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (255, 63, 63, 63), Color.Black);
4657 VerticalBrush = ResPool.GetHatchBrush (HatchStyle.Percent50, ColorScrollBar, Color.White);
4658 Rectangle UpperTrack = new Rectangle (0, 0, bar.ClientRectangle.Width, bar.ThumbPos.Bottom);
4659 if (clip.IntersectsWith (UpperTrack))
4660 dc.FillRectangle (VerticalBrush, UpperTrack);
4662 /* Background, lower track */
4663 if (bar.thumb_moving == ScrollBar.ThumbMoving.Forward)
4664 VerticalBrush = ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (255, 63, 63, 63), Color.Black);
4666 VerticalBrush = ResPool.GetHatchBrush (HatchStyle.Percent50, ColorScrollBar, Color.White);
4667 Rectangle LowerTrack = new Rectangle (0, bar.ThumbPos.Bottom, bar.ClientRectangle.Width, bar.ClientRectangle.Height - bar.ThumbPos.Bottom);
4668 if (clip.IntersectsWith (LowerTrack))
4669 dc.FillRectangle (VerticalBrush, LowerTrack);
4672 if (clip.IntersectsWith (first_arrow_area))
4673 CPDrawScrollButton (dc, first_arrow_area, ScrollButton.Up, bar.firstbutton_state);
4674 if (clip.IntersectsWith (second_arrow_area))
4675 CPDrawScrollButton (dc, second_arrow_area, ScrollButton.Down, bar.secondbutton_state);
4677 first_arrow_area = new Rectangle(0, 0, scrollbutton_width, bar.Height);
4678 bar.FirstArrowArea = first_arrow_area;
4680 second_arrow_area = new Rectangle (bar.ClientRectangle.Width - scrollbutton_width, 0, scrollbutton_width, bar.Height);
4681 bar.SecondArrowArea = second_arrow_area;
4683 thumb_pos.Height = bar.Height;
4684 bar.ThumbPos = thumb_pos;
4686 Brush HorizontalBrush;
4687 //Background, left track
4688 if (bar.thumb_moving == ScrollBar.ThumbMoving.Backwards)
4689 HorizontalBrush = ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (255, 63, 63, 63), Color.Black);
4691 HorizontalBrush = ResPool.GetHatchBrush (HatchStyle.Percent50, ColorScrollBar, Color.White);
4692 Rectangle LeftTrack = new Rectangle (0, 0, bar.ThumbPos.Right, bar.ClientRectangle.Height);
4693 if (clip.IntersectsWith (LeftTrack))
4694 dc.FillRectangle (HorizontalBrush, LeftTrack);
4696 //Background, right track
4697 if (bar.thumb_moving == ScrollBar.ThumbMoving.Forward)
4698 HorizontalBrush = ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (255, 63, 63, 63), Color.Black);
4700 HorizontalBrush = ResPool.GetHatchBrush (HatchStyle.Percent50, ColorScrollBar, Color.White);
4701 Rectangle RightTrack = new Rectangle (bar.ThumbPos.Right, 0, bar.ClientRectangle.Width - bar.ThumbPos.Right, bar.ClientRectangle.Height);
4702 if (clip.IntersectsWith (RightTrack))
4703 dc.FillRectangle (HorizontalBrush, RightTrack);
4706 if (clip.IntersectsWith (first_arrow_area))
4707 CPDrawScrollButton (dc, first_arrow_area, ScrollButton.Left, bar.firstbutton_state);
4708 if (clip.IntersectsWith (second_arrow_area))
4709 CPDrawScrollButton (dc, second_arrow_area, ScrollButton.Right, bar.secondbutton_state);
4713 ScrollBar_DrawThumb(bar, thumb_pos, clip, dc);
4716 protected virtual void ScrollBar_DrawThumb(ScrollBar bar, Rectangle thumb_pos, Rectangle clip, Graphics dc)
4718 if (bar.Enabled && thumb_pos.Width > 0 && thumb_pos.Height > 0 && clip.IntersectsWith(thumb_pos))
4719 DrawScrollButtonPrimitive(dc, thumb_pos, ButtonState.Normal);
4722 public override int ScrollBarButtonSize {
4726 public override bool ScrollBarHasHotElementStyles {
4732 public override bool ScrollBarHasPressedThumbStyle {
4738 public override bool ScrollBarHasHoverArrowButtonStyle {
4743 #endregion // ScrollBar
4746 public override void DrawStatusBar (Graphics real_dc, Rectangle clip, StatusBar sb) {
4747 Rectangle area = sb.ClientRectangle;
4748 int horz_border = 2;
4749 int vert_border = 2;
4751 Image backbuffer = new Bitmap (sb.ClientSize.Width, sb.ClientSize.Height, real_dc);
4752 Graphics dc = Graphics.FromImage (backbuffer);
4754 DrawStatusBarBackground (dc, clip, sb);
4756 if (!sb.ShowPanels && sb.Text != String.Empty) {
4757 string text = sb.Text;
4758 StringFormat string_format = new StringFormat ();
4759 string_format.Trimming = StringTrimming.Character;
4760 string_format.FormatFlags = StringFormatFlags.NoWrap;
4762 if (text.Length > 127)
4763 text = text.Substring (0, 127);
4765 if (text [0] == '\t') {
4766 string_format.Alignment = StringAlignment.Center;
4767 text = text.Substring (1);
4768 if (text [0] == '\t') {
4769 string_format.Alignment = StringAlignment.Far;
4770 text = text.Substring (1);
4774 dc.DrawString (text, sb.Font, ResPool.GetSolidBrush (sb.ForeColor),
4775 new Rectangle(area.X + 2, area.Y + 2, area.Width - 4, area.Height - 4), string_format);
4776 string_format.Dispose ();
4777 } else if (sb.ShowPanels) {
4778 Brush br_forecolor = GetControlForeBrush (sb.ForeColor);
4779 int prev_x = area.X + horz_border;
4780 int y = area.Y + vert_border;
4781 for (int i = 0; i < sb.Panels.Count; i++) {
4782 Rectangle pr = new Rectangle (prev_x, y,
4783 sb.Panels [i].Width, area.Height);
4784 prev_x += pr.Width + StatusBarHorzGapWidth;
4785 if (pr.IntersectsWith (clip))
4786 DrawStatusBarPanel (dc, pr, i, br_forecolor, sb.Panels [i]);
4791 DrawStatusBarSizingGrip (dc, clip, sb, area);
4793 real_dc.DrawImage (backbuffer, 0, 0);
4795 backbuffer.Dispose ();
4799 protected virtual void DrawStatusBarBackground (Graphics dc, Rectangle clip, StatusBar sb)
4801 bool is_color_control = sb.BackColor.ToArgb () == ColorControl.ToArgb ();
4803 Brush brush = is_color_control ? SystemBrushes.Control : ResPool.GetSolidBrush (sb.BackColor);
4804 dc.FillRectangle (brush, clip);
4807 protected virtual void DrawStatusBarSizingGrip (Graphics dc, Rectangle clip, StatusBar sb, Rectangle area)
4809 area = new Rectangle (area.Right - 16 - 2, area.Bottom - 12 - 1, 16, 16);
4810 CPDrawSizeGrip (dc, ColorControl, area);
4813 protected virtual void DrawStatusBarPanel (Graphics dc, Rectangle area, int index,
4814 Brush br_forecolor, StatusBarPanel panel) {
4815 int border_size = 3; // this is actually const, even if the border style is none
4816 int icon_width = 16;
4818 area.Height -= border_size;
4820 DrawStatusBarPanelBackground (dc, area, panel);
4822 if (panel.Style == StatusBarPanelStyle.OwnerDraw) {
4823 StatusBarDrawItemEventArgs e = new StatusBarDrawItemEventArgs (
4824 dc, panel.Parent.Font, area, index, DrawItemState.Default,
4825 panel, panel.Parent.ForeColor, panel.Parent.BackColor);
4826 panel.Parent.OnDrawItemInternal (e);
4830 if (panel.Text == String.Empty)
4833 string text = panel.Text;
4834 StringFormat string_format = new StringFormat ();
4835 string_format.Trimming = StringTrimming.Character;
4836 string_format.FormatFlags = StringFormatFlags.NoWrap;
4839 if (text [0] == '\t') {
4840 string_format.Alignment = StringAlignment.Center;
4841 text = text.Substring (1);
4842 if (text [0] == '\t') {
4843 string_format.Alignment = StringAlignment.Far;
4844 text = text.Substring (1);
4848 Rectangle string_rect = Rectangle.Empty;
4852 int y = (area.Height / 2 - (int) panel.Parent.Font.Size / 2) - 1;
4854 switch (panel.Alignment) {
4855 case HorizontalAlignment.Right:
4856 len = (int) dc.MeasureString (text, panel.Parent.Font).Width;
4857 x = area.Right - len - 4;
4858 string_rect = new Rectangle (x, y,
4859 area.Right - x - border_size,
4860 area.Bottom - y - border_size);
4861 if (panel.Icon != null) {
4862 icon_x = x - icon_width - 2;
4865 case HorizontalAlignment.Center:
4866 len = (int) dc.MeasureString (text, panel.Parent.Font).Width;
4867 x = area.Left + ((panel.Width - len) / 2);
4869 string_rect = new Rectangle (x, y,
4870 area.Right - x - border_size,
4871 area.Bottom - y - border_size);
4873 if (panel.Icon != null) {
4874 icon_x = x - icon_width - 2;
4880 int left = area.Left + border_size;;
4881 if (panel.Icon != null) {
4882 icon_x = area.Left + 2;
4883 left = icon_x + icon_width + 2;
4887 string_rect = new Rectangle (x, y,
4888 area.Right - x - border_size,
4889 area.Bottom - y - border_size);
4893 RectangleF clip_bounds = dc.ClipBounds;
4895 dc.DrawString (text, panel.Parent.Font, br_forecolor, string_rect, string_format);
4896 dc.SetClip (clip_bounds);
4898 if (panel.Icon != null) {
4899 dc.DrawIcon (panel.Icon, new Rectangle (icon_x, y, icon_width, icon_width));
4903 protected virtual void DrawStatusBarPanelBackground (Graphics dc, Rectangle area, StatusBarPanel panel)
4905 if (panel.BorderStyle != StatusBarPanelBorderStyle.None) {
4906 Border3DStyle border_style = Border3DStyle.SunkenOuter;
4907 if (panel.BorderStyle == StatusBarPanelBorderStyle.Raised)
4908 border_style = Border3DStyle.RaisedInner;
4910 CPDrawBorder3D(dc, area, border_style, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, panel.Parent.BackColor);
4914 public override int StatusBarSizeGripWidth {
4918 public override int StatusBarHorzGapWidth {
4922 public override Size StatusBarDefaultSize {
4924 return new Size (100, 22);
4927 #endregion // StatusBar
4931 #region TabControl settings
4933 public override Size TabControlDefaultItemSize {
4934 get { return ThemeElements.CurrentTheme.TabControlPainter.DefaultItemSize; }
4937 public override Point TabControlDefaultPadding {
4938 get { return ThemeElements.CurrentTheme.TabControlPainter.DefaultPadding; }
4941 public override int TabControlMinimumTabWidth {
4942 get { return ThemeElements.CurrentTheme.TabControlPainter.MinimumTabWidth; }
4945 public override Rectangle TabControlSelectedDelta {
4946 get { return ThemeElements.CurrentTheme.TabControlPainter.SelectedTabDelta; }
4949 public override int TabControlSelectedSpacing {
4950 get { return ThemeElements.CurrentTheme.TabControlPainter.SelectedSpacing; }
4953 public override int TabPanelOffsetX {
4954 get { return ThemeElements.CurrentTheme.TabControlPainter.TabPanelOffset.X; }
4957 public override int TabPanelOffsetY {
4958 get { return ThemeElements.CurrentTheme.TabControlPainter.TabPanelOffset.Y; }
4961 public override int TabControlColSpacing {
4962 get { return ThemeElements.CurrentTheme.TabControlPainter.ColSpacing; }
4965 public override Point TabControlImagePadding {
4966 get { return ThemeElements.CurrentTheme.TabControlPainter.ImagePadding; }
4969 public override int TabControlScrollerWidth {
4970 get {return ThemeElements.CurrentTheme.TabControlPainter.ScrollerWidth; }
4974 public override Size TabControlGetSpacing (TabControl tab)
4977 return ThemeElements.CurrentTheme.TabControlPainter.RowSpacing (tab);
4979 throw new Exception ("Invalid Appearance value: " + tab.Appearance);
4984 public override void DrawTabControl (Graphics dc, Rectangle area, TabControl tab)
4986 ThemeElements.CurrentTheme.TabControlPainter.Draw (dc, area, tab);
4989 public override Rectangle TabControlGetLeftScrollRect (TabControl tab)
4991 return ThemeElements.CurrentTheme.TabControlPainter.GetLeftScrollRect (tab);
4994 public override Rectangle TabControlGetRightScrollRect (TabControl tab)
4996 return ThemeElements.CurrentTheme.TabControlPainter.GetRightScrollRect (tab);
4999 public override Rectangle TabControlGetDisplayRectangle (TabControl tab)
5001 return ThemeElements.CurrentTheme.TabControlPainter.GetDisplayRectangle (tab);
5004 public override Rectangle TabControlGetPanelRect (TabControl tab)
5006 return ThemeElements.CurrentTheme.TabControlPainter.GetTabPanelRect (tab);
5012 public override void TextBoxBaseFillBackground (TextBoxBase textBoxBase, Graphics g, Rectangle clippingArea)
5014 if (textBoxBase.backcolor_set || (textBoxBase.Enabled && !textBoxBase.read_only)) {
5015 g.FillRectangle(ResPool.GetSolidBrush(textBoxBase.BackColor), clippingArea);
5017 g.FillRectangle(ResPool.GetSolidBrush(ColorControl), clippingArea);
5021 public override bool TextBoxBaseHandleWmNcPaint (TextBoxBase textBoxBase, ref Message m)
5026 public override bool TextBoxBaseShouldPaintBackground (TextBoxBase textBoxBase)
5033 public override void DrawToolBar (Graphics dc, Rectangle clip_rectangle, ToolBar control)
5035 StringFormat format = new StringFormat ();
5036 format.Trimming = StringTrimming.EllipsisCharacter;
5037 format.LineAlignment = StringAlignment.Center;
5038 if (control.ShowKeyboardCuesInternal)
5039 format.HotkeyPrefix = HotkeyPrefix.Show;
5041 format.HotkeyPrefix = HotkeyPrefix.Hide;
5043 if (control.TextAlign == ToolBarTextAlign.Underneath)
5044 format.Alignment = StringAlignment.Center;
5046 format.Alignment = StringAlignment.Near;
5048 if (control is PropertyGrid.PropertyToolBar) {
5049 dc.FillRectangle (ResPool.GetSolidBrush(control.BackColor), clip_rectangle);
5051 if (clip_rectangle.X == 0) {
5052 dc.DrawLine (SystemPens.ControlLightLight, clip_rectangle.X, 1, clip_rectangle.X, control.Bottom);
5055 if (clip_rectangle.Y < 2) {
5056 dc.DrawLine (SystemPens.ControlLightLight, clip_rectangle.X, 1, clip_rectangle.Right, 1);
5059 if (clip_rectangle.Bottom == control.Bottom) {
5060 dc.DrawLine (SystemPens.ControlDark, clip_rectangle.X, clip_rectangle.Bottom - 1, clip_rectangle.Right, clip_rectangle.Bottom - 1);
5063 if (clip_rectangle.Right == control.Right) {
5064 dc.DrawLine (SystemPens.ControlDark, clip_rectangle.Right - 1, 1, clip_rectangle.Right - 1, control.Bottom - 1);
5068 if (control.Appearance != ToolBarAppearance.Flat || control.Parent == null) {
5069 dc.FillRectangle (SystemBrushes.Control, clip_rectangle);
5072 if (control.Divider && clip_rectangle.Y < 2) {
5073 if (clip_rectangle.Y < 1) {
5074 dc.DrawLine (SystemPens.ControlDark, clip_rectangle.X, 0, clip_rectangle.Right, 0);
5076 dc.DrawLine (SystemPens.ControlLightLight, clip_rectangle.X, 1, clip_rectangle.Right, 1);
5082 foreach (ToolBarItem item in control.items)
5083 if (item.Button.Visible && clip_rectangle.IntersectsWith (item.Rectangle))
5084 DrawToolBarButton (dc, control, item, format);
5089 protected virtual void DrawToolBarButton (Graphics dc, ToolBar control, ToolBarItem item, StringFormat format)
5091 bool is_flat = (control.Appearance == ToolBarAppearance.Flat);
5093 DrawToolBarButtonBorder (dc, item, is_flat);
5095 switch (item.Button.Style) {
5096 case ToolBarButtonStyle.DropDownButton:
5097 if (control.DropDownArrows)
5098 DrawToolBarDropDownArrow (dc, item, is_flat);
5099 DrawToolBarButtonContents (dc, control, item, format);
5102 case ToolBarButtonStyle.Separator:
5104 DrawToolBarSeparator (dc, item);
5107 case ToolBarButtonStyle.ToggleButton:
5108 DrawToolBarToggleButtonBackground (dc, item);
5109 DrawToolBarButtonContents (dc, control, item, format);
5113 DrawToolBarButtonContents (dc, control, item, format);
5118 const Border3DSide all_sides = Border3DSide.Left | Border3DSide.Top | Border3DSide.Right | Border3DSide.Bottom;
5120 protected virtual void DrawToolBarButtonBorder (Graphics dc, ToolBarItem item, bool is_flat)
5122 if (item.Button.Style == ToolBarButtonStyle.Separator)
5125 Border3DStyle style;
5128 if (item.Button.Pushed || item.Pressed)
5129 style = Border3DStyle.SunkenOuter;
5130 else if (item.Hilight)
5131 style = Border3DStyle.RaisedInner;
5136 if (item.Button.Pushed || item.Pressed)
5137 style = Border3DStyle.Sunken;
5139 style = Border3DStyle.Raised;
5142 Rectangle rect = item.Rectangle;
5143 if ((item.Button.Style == ToolBarButtonStyle.DropDownButton) && (item.Button.Parent.DropDownArrows) && is_flat)
5144 rect.Width -= ToolBarDropDownWidth;
5146 CPDrawBorder3D (dc, rect, style, all_sides);
5149 protected virtual void DrawToolBarSeparator (Graphics dc, ToolBarItem item)
5151 Rectangle area = item.Rectangle;
5152 int offset = (int) SystemPens.Control.Width + 1;
5153 dc.DrawLine (SystemPens.ControlDark, area.X + 1, area.Y, area.X + 1, area.Bottom);
5154 dc.DrawLine (SystemPens.ControlLight, area.X + offset, area.Y, area.X + offset, area.Bottom);
5157 protected virtual void DrawToolBarToggleButtonBackground (Graphics dc, ToolBarItem item)
5160 Rectangle area = item.Rectangle;
5161 area.X += ToolBarImageGripWidth;
5162 area.Y += ToolBarImageGripWidth;
5163 area.Width -= 2 * ToolBarImageGripWidth;
5164 area.Height -= 2 * ToolBarImageGripWidth;
5166 if (item.Button.Pushed)
5167 brush = (Brush) ResPool.GetHatchBrush (HatchStyle.Percent50, ColorScrollBar, ColorControlLightLight);
5168 else if (item.Button.PartialPush)
5169 brush = SystemBrushes.ControlLight;
5171 brush = SystemBrushes.Control;
5173 dc.FillRectangle (brush, area);
5176 protected virtual void DrawToolBarDropDownArrow (Graphics dc, ToolBarItem item, bool is_flat)
5178 Rectangle rect = item.Rectangle;
5179 rect.X = item.Rectangle.Right - ToolBarDropDownWidth;
5180 rect.Width = ToolBarDropDownWidth;
5184 CPDrawBorder3D (dc, rect, Border3DStyle.SunkenOuter, all_sides);
5185 else if (item.Button.Pushed || item.Pressed)
5186 CPDrawBorder3D (dc, rect, Border3DStyle.SunkenOuter, all_sides);
5187 else if (item.Hilight)
5188 CPDrawBorder3D (dc, rect, Border3DStyle.RaisedInner, all_sides);
5191 CPDrawBorder3D (dc, rect, Border3DStyle.Flat, all_sides);
5192 else if (item.Button.Pushed || item.Pressed)
5193 CPDrawBorder3D (dc, Rectangle.Inflate(rect, -1, -1), Border3DStyle.SunkenOuter, all_sides);
5195 CPDrawBorder3D (dc, rect, Border3DStyle.Raised, all_sides);
5198 PointF [] vertices = new PointF [3];
5199 PointF ddCenter = new PointF (rect.X + (rect.Width/2.0f), rect.Y + (rect.Height / 2));
5201 // Increase vertical and horizontal position by 1 when button is pressed
5202 if (item.Pressed || item.Button.Pushed || item.DDPressed) {
5207 vertices [0].X = ddCenter.X - ToolBarDropDownArrowWidth / 2.0f + 0.5f;
5208 vertices [0].Y = ddCenter.Y;
5209 vertices [1].X = ddCenter.X + ToolBarDropDownArrowWidth / 2.0f + 0.5f;
5210 vertices [1].Y = ddCenter.Y;
5211 vertices [2].X = ddCenter.X + 0.5f; // 0.5 is added for adjustment
5212 vertices [2].Y = ddCenter.Y + ToolBarDropDownArrowHeight;
5213 dc.FillPolygon (SystemBrushes.ControlText, vertices);
5216 protected virtual void DrawToolBarButtonContents (Graphics dc, ToolBar control, ToolBarItem item, StringFormat format)
5218 if (item.Button.Image != null) {
5219 int x = item.ImageRectangle.X + ToolBarImageGripWidth;
5220 int y = item.ImageRectangle.Y + ToolBarImageGripWidth;
5222 // Increase vertical and horizontal position by 1 when button is pressed
5223 if (item.Pressed || item.Button.Pushed) {
5228 if (item.Button.Enabled)
5229 dc.DrawImage (item.Button.Image, x, y);
5231 CPDrawImageDisabled (dc, item.Button.Image, x, y, ColorControl);
5234 Rectangle text_rect = item.TextRectangle;
5235 if (text_rect.Width <= 0 || text_rect.Height <= 0)
5238 if (item.Pressed || item.Button.Pushed) {
5243 if (item.Button.Enabled)
5244 dc.DrawString (item.Button.Text, control.Font, SystemBrushes.ControlText, text_rect, format);
5246 CPDrawStringDisabled (dc, item.Button.Text, control.Font, control.BackColor, text_rect, format);
5249 // Grip width for the ToolBar
5250 public override int ToolBarGripWidth {
5254 // Grip width for the Image on the ToolBarButton
5255 public override int ToolBarImageGripWidth {
5259 // width of the separator
5260 public override int ToolBarSeparatorWidth {
5264 // width of the dropdown arrow rect
5265 public override int ToolBarDropDownWidth {
5269 // width for the dropdown arrow on the ToolBarButton
5270 public override int ToolBarDropDownArrowWidth {
5274 // height for the dropdown arrow on the ToolBarButton
5275 public override int ToolBarDropDownArrowHeight {
5279 public override Size ToolBarDefaultSize {
5281 return new Size (100, 42);
5285 public override bool ToolBarHasHotElementStyles (ToolBar toolBar)
5287 return toolBar.Appearance == ToolBarAppearance.Flat;
5290 public override bool ToolBarHasHotCheckedElementStyles {
5295 #endregion // ToolBar
5298 public override void DrawToolTip(Graphics dc, Rectangle clip_rectangle, ToolTip.ToolTipWindow control)
5300 ToolTipDrawBackground (dc, clip_rectangle, control);
5302 Rectangle text_rect = Rectangle.Inflate (control.ClientRectangle, -2, -1);
5304 Color foreground = control.ForeColor;
5306 Color foreground = this.ColorInfoText;
5308 TextFormatFlags flags = TextFormatFlags.HidePrefix | TextFormatFlags.SingleLine | TextFormatFlags.VerticalCenter;
5309 TextRenderer.DrawTextInternal (dc, control.Text, control.Font, text_rect, foreground, flags, false);
5312 protected virtual void ToolTipDrawBackground (Graphics dc, Rectangle clip_rectangle, ToolTip.ToolTipWindow control)
5315 Brush back_brush = ResPool.GetSolidBrush (control.BackColor);;
5317 Brush back_brush = SystemBrushes.Info;
5319 dc.FillRectangle (back_brush, control.ClientRectangle);
5320 dc.DrawRectangle (SystemPens.WindowFrame, 0, 0, control.Width - 1, control.Height - 1);
5323 public override Size ToolTipSize(ToolTip.ToolTipWindow tt, string text)
5325 Size size = TextRenderer.MeasureTextInternal (text, tt.Font, false);
5333 public override bool ToolTipTransparentBackground {
5338 #endregion // ToolTip
5340 #region BalloonWindow
5342 NotifyIcon.BalloonWindow balloon_window;
5344 public override void ShowBalloonWindow (IntPtr handle, int timeout, string title, string text, ToolTipIcon icon)
5346 Control control = Control.FromHandle(handle);
5348 if (control == null)
5351 if (balloon_window != null) {
5352 balloon_window.Close ();
5353 balloon_window.Dispose ();
5356 balloon_window = new NotifyIcon.BalloonWindow (handle);
5357 balloon_window.Title = title;
5358 balloon_window.Text = text;
5359 balloon_window.Icon = icon;
5360 balloon_window.Timeout = timeout;
5361 balloon_window.Show ();
5364 private const int balloon_iconsize = 16;
5365 private const int balloon_bordersize = 8;
5367 public override void DrawBalloonWindow (Graphics dc, Rectangle clip, NotifyIcon.BalloonWindow control)
5369 Brush solidbrush = ResPool.GetSolidBrush (this.ColorInfoText);
5370 Rectangle rect = control.ClientRectangle;
5371 int iconsize = (control.Icon == ToolTipIcon.None) ? 0 : balloon_iconsize;
5373 // Rectangle borders and background.
5374 dc.FillRectangle (ResPool.GetSolidBrush (ColorInfo), rect);
5375 dc.DrawRectangle (ResPool.GetPen (ColorWindowFrame), 0, 0, rect.Width - 1, rect.Height - 1);
5379 switch (control.Icon) {
5380 case ToolTipIcon.Info: {
5381 image = ThemeEngine.Current.Images(UIIcon.MessageBoxInfo, balloon_iconsize);
5385 case ToolTipIcon.Warning: {
5386 image = ThemeEngine.Current.Images(UIIcon.MessageBoxError, balloon_iconsize);
5390 case ToolTipIcon.Error: {
5391 image = ThemeEngine.Current.Images(UIIcon.MessageBoxWarning, balloon_iconsize);
5401 if (control.Icon != ToolTipIcon.None)
5402 dc.DrawImage (image, new Rectangle (balloon_bordersize, balloon_bordersize, iconsize, iconsize));
5405 Rectangle titlerect = new Rectangle (rect.X + balloon_bordersize + iconsize + (iconsize > 0 ? balloon_bordersize : 0),
5406 rect.Y + balloon_bordersize,
5407 rect.Width - ((3 * balloon_bordersize) + iconsize),
5408 rect.Height - (2 * balloon_bordersize));
5410 Font titlefont = new Font (control.Font.FontFamily, control.Font.Size, control.Font.Style | FontStyle.Bold, control.Font.Unit);
5411 dc.DrawString (control.Title, titlefont, solidbrush, titlerect, control.Format);
5414 Rectangle textrect = new Rectangle (rect.X + balloon_bordersize,
5415 rect.Y + balloon_bordersize,
5416 rect.Width - (2 * balloon_bordersize),
5417 rect.Height - (2 * balloon_bordersize));
5419 StringFormat textformat = control.Format;
5420 textformat.LineAlignment = StringAlignment.Far;
5421 dc.DrawString (control.Text, control.Font, solidbrush, textrect, textformat);
5424 public override Rectangle BalloonWindowRect (NotifyIcon.BalloonWindow control)
5426 Rectangle deskrect = Screen.GetWorkingArea (control);
5427 SizeF maxsize = new SizeF (250, 200);
5429 SizeF titlesize = TextRenderer.MeasureString (control.Title, control.Font, maxsize, control.Format);
5430 SizeF textsize = TextRenderer.MeasureString (control.Text, control.Font, maxsize, control.Format);
5432 if (titlesize.Height < balloon_iconsize)
5433 titlesize.Height = balloon_iconsize;
5435 Rectangle rect = new Rectangle ();
5436 rect.Height = (int) (titlesize.Height + textsize.Height + (3 * balloon_bordersize));
5437 rect.Width = (int) ((titlesize.Width > textsize.Width) ? titlesize.Width : textsize.Width) + (2 * balloon_bordersize);
5438 rect.X = deskrect.Width - rect.Width - 2;
5439 rect.Y = deskrect.Height - rect.Height - 2;
5444 #endregion // BalloonWindow
5447 public override int TrackBarValueFromMousePosition (int x, int y, TrackBar tb)
5449 int result = tb.Value;
5450 int value_pos = tb.Value;
5451 float pixels_betweenticks;
5452 Rectangle thumb_pos = Rectangle.Empty, thumb_area = Rectangle.Empty;
5453 Point channel_startpoint = Point.Empty, na_point = Point.Empty;
5455 GetTrackBarDrawingInfo (tb, out pixels_betweenticks, out thumb_area, out thumb_pos, out channel_startpoint, out na_point, out na_point);
5457 /* Convert thumb position from mouse position to value*/
5458 if (tb.Orientation == Orientation.Vertical) {
5459 value_pos = (int)Math.Round (((thumb_area.Bottom - y - (float)thumb_pos.Height / 2) / (float)pixels_betweenticks), 0);
5461 if (value_pos + tb.Minimum > tb.Maximum)
5462 value_pos = tb.Maximum - tb.Minimum;
5463 else if (value_pos + tb.Minimum < tb.Minimum)
5466 result = value_pos + tb.Minimum;
5468 value_pos = (int)Math.Round (((x - channel_startpoint.X - (float)thumb_pos.Width / 2) / (float) pixels_betweenticks), 0);
5470 if (value_pos + tb.Minimum > tb.Maximum)
5471 value_pos = tb.Maximum - tb.Minimum;
5472 else if (value_pos + tb.Minimum < tb.Minimum)
5475 result = value_pos + tb.Minimum;
5481 private void GetTrackBarDrawingInfo (TrackBar tb, out float pixels_betweenticks, out Rectangle thumb_area, out Rectangle thumb_pos, out Point channel_startpoint, out Point bottomtick_startpoint, out Point toptick_startpoint)
5483 thumb_area = Rectangle.Empty;
5484 thumb_pos = Rectangle.Empty;
5486 if (tb.Orientation == Orientation.Vertical) {
5487 toptick_startpoint = new Point ();
5488 bottomtick_startpoint = new Point ();
5489 channel_startpoint = new Point ();
5491 const int space_from_right = 8;
5492 const int space_from_left = 8;
5493 const int space_from_bottom = 11;
5494 Rectangle area = tb.ClientRectangle;
5496 switch (tb.TickStyle) {
5497 case TickStyle.BottomRight:
5498 case TickStyle.None:
5499 channel_startpoint.Y = 8;
5500 channel_startpoint.X = 9;
5501 bottomtick_startpoint.Y = 13;
5502 bottomtick_startpoint.X = 24;
5504 case TickStyle.TopLeft:
5505 channel_startpoint.Y = 8;
5506 channel_startpoint.X = 19;
5507 toptick_startpoint.Y = 13;
5508 toptick_startpoint.X = 8;
5510 case TickStyle.Both:
5511 channel_startpoint.Y = 8;
5512 channel_startpoint.X = 18;
5513 bottomtick_startpoint.Y = 13;
5514 bottomtick_startpoint.X = 32;
5515 toptick_startpoint.Y = 13;
5516 toptick_startpoint.X = 8;
5522 thumb_area.X = area.X + channel_startpoint.X;
5523 thumb_area.Y = area.Y + channel_startpoint.Y;
5524 thumb_area.Height = area.Height - space_from_right - space_from_left;
5525 thumb_area.Width = 4;
5527 pixel_len = thumb_area.Height - 11;
5528 if (tb.Maximum == tb.Minimum) {
5529 pixels_betweenticks = 0;
5531 pixels_betweenticks = pixel_len / (tb.Maximum - tb.Minimum);
5534 thumb_pos.Y = thumb_area.Bottom - space_from_bottom - (int)(pixels_betweenticks * (float)(tb.Value - tb.Minimum));
5536 toptick_startpoint = new Point ();
5537 bottomtick_startpoint = new Point ();
5538 channel_startpoint = new Point ();
5540 const int space_from_right = 8;
5541 const int space_from_left = 8;
5542 Rectangle area = tb.ClientRectangle;
5544 switch (tb.TickStyle) {
5545 case TickStyle.BottomRight:
5546 case TickStyle.None:
5547 channel_startpoint.X = 8;
5548 channel_startpoint.Y = 9;
5549 bottomtick_startpoint.X = 13;
5550 bottomtick_startpoint.Y = 24;
5552 case TickStyle.TopLeft:
5553 channel_startpoint.X = 8;
5554 channel_startpoint.Y = 19;
5555 toptick_startpoint.X = 13;
5556 toptick_startpoint.Y = 8;
5558 case TickStyle.Both:
5559 channel_startpoint.X = 8;
5560 channel_startpoint.Y = 18;
5561 bottomtick_startpoint.X = 13;
5562 bottomtick_startpoint.Y = 32;
5563 toptick_startpoint.X = 13;
5564 toptick_startpoint.Y = 8;
5570 thumb_area.X = area.X + channel_startpoint.X;
5571 thumb_area.Y = area.Y + channel_startpoint.Y;
5572 thumb_area.Width = area.Width - space_from_right - space_from_left;
5573 thumb_area.Height = 4;
5575 pixel_len = thumb_area.Width - 11;
5576 if (tb.Maximum == tb.Minimum) {
5577 pixels_betweenticks = 0;
5579 pixels_betweenticks = pixel_len / (tb.Maximum - tb.Minimum);
5582 thumb_pos.X = channel_startpoint.X + (int)(pixels_betweenticks * (float) (tb.Value - tb.Minimum));
5585 thumb_pos.Size = TrackBarGetThumbSize (tb);
5588 protected virtual Size TrackBarGetThumbSize (TrackBar trackBar)
5590 /* Draw thumb fixed 10x22 size */
5591 return new Size (10, 22);
5595 protected interface ITrackBarTickPainter
5597 void Paint (float x1, float y1, float x2, float y2);
5600 class TrackBarTickPainter : ITrackBarTickPainter
5602 readonly Graphics g;
5604 public TrackBarTickPainter (Graphics g, Pen pen)
5609 public void Paint (float x1, float y1, float x2, float y2)
5611 g.DrawLine (pen, x1, y1, x2, y2);
5614 protected virtual ITrackBarTickPainter GetTrackBarTickPainter (Graphics g)
5616 return new TrackBarTickPainter (g, ResPool.GetPen (pen_ticks_color));
5620 #region DrawTrackBar_Vertical
5621 private void DrawTrackBar_Vertical (Graphics dc, Rectangle clip_rectangle, TrackBar tb,
5622 ref Rectangle thumb_pos, ref Rectangle thumb_area, Brush br_thumb,
5623 float ticks, int value_pos, bool mouse_value) {
5625 Point toptick_startpoint = new Point ();
5626 Point bottomtick_startpoint = new Point ();
5627 Point channel_startpoint = new Point ();
5629 float pixels_betweenticks;
5630 Rectangle area = tb.ClientRectangle;
5632 GetTrackBarDrawingInfo (tb, out pixels_betweenticks, out thumb_area, out thumb_pos, out channel_startpoint, out bottomtick_startpoint, out toptick_startpoint);
5635 TrackBarDrawVerticalTrack (dc, thumb_area, channel_startpoint, clip_rectangle);
5639 switch (tb.TickStyle) {
5640 case TickStyle.BottomRight:
5641 case TickStyle.None:
5642 thumb_pos.X = channel_startpoint.X - 8;
5643 TrackBarDrawVerticalThumbRight (dc, thumb_pos, br_thumb, clip_rectangle, tb);
5645 case TickStyle.TopLeft:
5646 thumb_pos.X = channel_startpoint.X - 10;
5647 TrackBarDrawVerticalThumbLeft (dc, thumb_pos, br_thumb, clip_rectangle, tb);
5650 thumb_pos.X = area.X + 10;
5651 TrackBarDrawVerticalThumb (dc, thumb_pos, br_thumb, clip_rectangle, tb);
5656 pixel_len = thumb_area.Height - 11;
5657 pixels_betweenticks = pixel_len / ticks;
5659 thumb_area.X = thumb_pos.X;
5660 thumb_area.Y = channel_startpoint.Y;
5661 thumb_area.Width = thumb_pos.Height;
5664 if (pixels_betweenticks <= 0)
5666 if (tb.TickStyle == TickStyle.None)
5668 Region outside = new Region (area);
5669 outside.Exclude (thumb_area);
5671 if (outside.IsVisible (clip_rectangle)) {
5672 ITrackBarTickPainter tick_painter = TrackBarGetVerticalTickPainter (dc);
5674 if ((tb.TickStyle & TickStyle.BottomRight) == TickStyle.BottomRight) {
5675 float x = area.X + bottomtick_startpoint.X;
5676 for (float inc = 0; inc < pixel_len + 1; inc += pixels_betweenticks) {
5677 float y = area.Y + bottomtick_startpoint.Y + inc;
5678 tick_painter.Paint (
5680 x + (inc == 0 || inc + pixels_betweenticks >= pixel_len + 1 ? 3 : 2), y);
5684 if ((tb.TickStyle & TickStyle.TopLeft) == TickStyle.TopLeft) {
5685 float x = area.X + toptick_startpoint.X;
5686 for (float inc = 0; inc < (pixel_len + 1); inc += pixels_betweenticks) {
5687 float y = area.Y + toptick_startpoint.Y + inc;
5688 tick_painter.Paint (
5689 x - (inc == 0 || inc + pixels_betweenticks >= pixel_len + 1 ? 3 : 2), y,
5700 protected virtual void TrackBarDrawVerticalTrack (Graphics dc, Rectangle thumb_area, Point channel_startpoint, Rectangle clippingArea)
5702 dc.FillRectangle (SystemBrushes.ControlDark, channel_startpoint.X, channel_startpoint.Y,
5703 1, thumb_area.Height);
5705 dc.FillRectangle (SystemBrushes.ControlDarkDark, channel_startpoint.X + 1, channel_startpoint.Y,
5706 1, thumb_area.Height);
5708 dc.FillRectangle (SystemBrushes.ControlLight, channel_startpoint.X + 3, channel_startpoint.Y,
5709 1, thumb_area.Height);
5714 protected virtual void TrackBarDrawVerticalThumbRight (Graphics dc, Rectangle thumb_pos, Brush br_thumb, Rectangle clippingArea, TrackBar trackBar)
5716 Pen pen = SystemPens.ControlLightLight;
5717 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X, thumb_pos.Y + 10);
5718 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X + 16, thumb_pos.Y);
5719 dc.DrawLine (pen, thumb_pos.X + 16, thumb_pos.Y, thumb_pos.X + 16 + 4, thumb_pos.Y + 4);
5721 pen = SystemPens.ControlDark;
5722 dc.DrawLine (pen, thumb_pos.X + 1, thumb_pos.Y + 9, thumb_pos.X + 15, thumb_pos.Y + 9);
5723 dc.DrawLine (pen, thumb_pos.X + 16, thumb_pos.Y + 9, thumb_pos.X + 16 + 4, thumb_pos.Y + 9 - 4);
5725 pen = SystemPens.ControlDarkDark;
5726 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 10, thumb_pos.X + 16, thumb_pos.Y + 10);
5727 dc.DrawLine (pen, thumb_pos.X + 16, thumb_pos.Y + 10, thumb_pos.X + 16 + 5, thumb_pos.Y + 10 - 5);
5729 dc.FillRectangle (br_thumb, thumb_pos.X + 1, thumb_pos.Y + 1, 16, 8);
5730 dc.FillRectangle (br_thumb, thumb_pos.X + 17, thumb_pos.Y + 2, 1, 6);
5731 dc.FillRectangle (br_thumb, thumb_pos.X + 18, thumb_pos.Y + 3, 1, 4);
5732 dc.FillRectangle (br_thumb, thumb_pos.X + 19, thumb_pos.Y + 4, 1, 2);
5735 protected virtual void TrackBarDrawVerticalThumbLeft (Graphics dc, Rectangle thumb_pos, Brush br_thumb, Rectangle clippingArea, TrackBar trackBar)
5737 Pen pen = SystemPens.ControlLightLight;
5738 dc.DrawLine (pen, thumb_pos.X + 4, thumb_pos.Y, thumb_pos.X + 4 + 16, thumb_pos.Y);
5739 dc.DrawLine (pen, thumb_pos.X + 4, thumb_pos.Y, thumb_pos.X, thumb_pos.Y + 4);
5741 pen = SystemPens.ControlDark;
5742 dc.DrawLine (pen, thumb_pos.X + 4, thumb_pos.Y + 9, thumb_pos.X + 4 + 16, thumb_pos.Y + 9);
5743 dc.DrawLine (pen, thumb_pos.X + 4, thumb_pos.Y + 9, thumb_pos.X, thumb_pos.Y + 5);
5744 dc.DrawLine (pen, thumb_pos.X + 19, thumb_pos.Y + 9, thumb_pos.X + 19, thumb_pos.Y + 1);
5746 pen = SystemPens.ControlDarkDark;
5747 dc.DrawLine (pen, thumb_pos.X + 4, thumb_pos.Y + 10, thumb_pos.X + 4 + 16, thumb_pos.Y + 10);
5748 dc.DrawLine (pen, thumb_pos.X + 4, thumb_pos.Y + 10, thumb_pos.X - 1, thumb_pos.Y + 5);
5749 dc.DrawLine (pen, thumb_pos.X + 20, thumb_pos.Y, thumb_pos.X + 20, thumb_pos.Y + 10);
5751 dc.FillRectangle (br_thumb, thumb_pos.X + 4, thumb_pos.Y + 1, 15, 8);
5752 dc.FillRectangle (br_thumb, thumb_pos.X + 3, thumb_pos.Y + 2, 1, 6);
5753 dc.FillRectangle (br_thumb, thumb_pos.X + 2, thumb_pos.Y + 3, 1, 4);
5754 dc.FillRectangle (br_thumb, thumb_pos.X + 1, thumb_pos.Y + 4, 1, 2);
5757 protected virtual void TrackBarDrawVerticalThumb (Graphics dc, Rectangle thumb_pos, Brush br_thumb, Rectangle clippingArea, TrackBar trackBar)
5759 Pen pen = SystemPens.ControlLightLight;
5760 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X, thumb_pos.Y + 9);
5761 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X + 19, thumb_pos.Y);
5763 pen = SystemPens.ControlDark;
5764 dc.DrawLine (pen, thumb_pos.X + 1, thumb_pos.Y + 9, thumb_pos.X + 19, thumb_pos.Y + 9);
5765 dc.DrawLine (pen, thumb_pos.X + 10, thumb_pos.Y + 1, thumb_pos.X + 19, thumb_pos.Y + 8);
5767 pen = SystemPens.ControlDarkDark;
5768 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 10, thumb_pos.X + 20, thumb_pos.Y + 10);
5769 dc.DrawLine (pen, thumb_pos.X + 20, thumb_pos.Y, thumb_pos.X + 20, thumb_pos.Y + 9);
5771 dc.FillRectangle (br_thumb, thumb_pos.X + 1, thumb_pos.Y + 1, 18, 8);
5776 protected virtual ITrackBarTickPainter TrackBarGetVerticalTickPainter (Graphics g)
5778 return GetTrackBarTickPainter (g);
5783 #region DrawTrackBar_Horizontal
5787 Does not matter the size of the control, Win32 always draws:
5788 - Ticks starting from pixel 13, 8
5789 - Channel starting at pos 8, 19 and ends at Width - 8
5790 - Autosize makes always the control 45 pixels high
5791 - Ticks are draw at (channel.Witdh - 10) / (Maximum - Minimum)
5794 private void DrawTrackBar_Horizontal (Graphics dc, Rectangle clip_rectangle, TrackBar tb,
5795 ref Rectangle thumb_pos, ref Rectangle thumb_area, Brush br_thumb,
5796 float ticks, int value_pos, bool mouse_value) {
5797 Point toptick_startpoint = new Point ();
5798 Point bottomtick_startpoint = new Point ();
5799 Point channel_startpoint = new Point ();
5801 float pixels_betweenticks;
5802 Rectangle area = tb.ClientRectangle;
5804 GetTrackBarDrawingInfo (tb , out pixels_betweenticks, out thumb_area, out thumb_pos, out channel_startpoint, out bottomtick_startpoint, out toptick_startpoint);
5807 TrackBarDrawHorizontalTrack (dc, thumb_area, channel_startpoint, clip_rectangle);
5811 switch (tb.TickStyle) {
5812 case TickStyle.BottomRight:
5813 case TickStyle.None:
5814 thumb_pos.Y = channel_startpoint.Y - 8;
5815 TrackBarDrawHorizontalThumbBottom (dc, thumb_pos, br_thumb, clip_rectangle, tb);
5817 case TickStyle.TopLeft:
5818 thumb_pos.Y = channel_startpoint.Y - 10;
5819 TrackBarDrawHorizontalThumbTop (dc, thumb_pos, br_thumb, clip_rectangle, tb);
5822 thumb_pos.Y = area.Y + 10;
5823 TrackBarDrawHorizontalThumb (dc, thumb_pos, br_thumb, clip_rectangle, tb);
5828 pixel_len = thumb_area.Width - 11;
5829 pixels_betweenticks = pixel_len / ticks;
5831 thumb_area.Y = thumb_pos.Y;
5832 thumb_area.X = channel_startpoint.X;
5833 thumb_area.Height = thumb_pos.Height;
5835 if (pixels_betweenticks <= 0)
5837 if (tb.TickStyle == TickStyle.None)
5839 Region outside = new Region (area);
5840 outside.Exclude (thumb_area);
5842 if (outside.IsVisible (clip_rectangle)) {
5843 ITrackBarTickPainter tick_painter = TrackBarGetHorizontalTickPainter (dc);
5845 if ((tb.TickStyle & TickStyle.BottomRight) == TickStyle.BottomRight) {
5846 float y = area.Y + bottomtick_startpoint.Y;
5847 for (float inc = 0; inc < pixel_len + 1; inc += pixels_betweenticks) {
5848 float x = area.X + bottomtick_startpoint.X + inc;
5849 tick_painter.Paint (
5851 x, y + (inc == 0 || inc + pixels_betweenticks >= pixel_len + 1 ? 3 : 2));
5855 if ((tb.TickStyle & TickStyle.TopLeft) == TickStyle.TopLeft) {
5856 float y = area.Y + toptick_startpoint.Y;
5857 for (float inc = 0; inc < pixel_len + 1; inc += pixels_betweenticks) {
5858 float x = area.X + toptick_startpoint.X + inc;
5859 tick_painter.Paint (
5860 x, y - (inc == 0 || (inc + pixels_betweenticks) >= pixel_len + 1 ? 3 : 2),
5871 protected virtual void TrackBarDrawHorizontalTrack (Graphics dc, Rectangle thumb_area, Point channel_startpoint, Rectangle clippingArea)
5873 dc.FillRectangle (SystemBrushes.ControlDark, channel_startpoint.X, channel_startpoint.Y,
5874 thumb_area.Width, 1);
5876 dc.FillRectangle (SystemBrushes.ControlDarkDark, channel_startpoint.X, channel_startpoint.Y + 1,
5877 thumb_area.Width, 1);
5879 dc.FillRectangle (SystemBrushes.ControlLight, channel_startpoint.X, channel_startpoint.Y + 3,
5880 thumb_area.Width, 1);
5885 protected virtual void TrackBarDrawHorizontalThumbBottom (Graphics dc, Rectangle thumb_pos, Brush br_thumb, Rectangle clippingArea, TrackBar trackBar)
5887 Pen pen = SystemPens.ControlLightLight;
5888 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X + 10, thumb_pos.Y);
5889 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X, thumb_pos.Y + 16);
5890 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 16, thumb_pos.X + 4, thumb_pos.Y + 16 + 4);
5892 pen = SystemPens.ControlDark;
5893 dc.DrawLine (pen, thumb_pos.X + 9, thumb_pos.Y + 1, thumb_pos.X + 9, thumb_pos.Y + 15);
5894 dc.DrawLine (pen, thumb_pos.X + 9, thumb_pos.Y + 16, thumb_pos.X + 9 - 4, thumb_pos.Y + 16 + 4);
5896 pen = SystemPens.ControlDarkDark;
5897 dc.DrawLine (pen, thumb_pos.X + 10, thumb_pos.Y, thumb_pos.X + 10, thumb_pos.Y + 16);
5898 dc.DrawLine (pen, thumb_pos.X + 10, thumb_pos.Y + 16, thumb_pos.X + 10 - 5, thumb_pos.Y + 16 + 5);
5900 dc.FillRectangle (br_thumb, thumb_pos.X + 1, thumb_pos.Y + 1, 8, 16);
5901 dc.FillRectangle (br_thumb, thumb_pos.X + 2, thumb_pos.Y + 17, 6, 1);
5902 dc.FillRectangle (br_thumb, thumb_pos.X + 3, thumb_pos.Y + 18, 4, 1);
5903 dc.FillRectangle (br_thumb, thumb_pos.X + 4, thumb_pos.Y + 19, 2, 1);
5906 protected virtual void TrackBarDrawHorizontalThumbTop (Graphics dc, Rectangle thumb_pos, Brush br_thumb, Rectangle clippingArea, TrackBar trackBar)
5908 Pen pen = SystemPens.ControlLightLight;
5909 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 4, thumb_pos.X, thumb_pos.Y + 4 + 16);
5910 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 4, thumb_pos.X + 4, thumb_pos.Y);
5912 pen = SystemPens.ControlDark;
5913 dc.DrawLine (pen, thumb_pos.X + 9, thumb_pos.Y + 4, thumb_pos.X + 9, thumb_pos.Y + 4 + 16);
5914 dc.DrawLine (pen, thumb_pos.X + 9, thumb_pos.Y + 4, thumb_pos.X + 5, thumb_pos.Y);
5915 dc.DrawLine (pen, thumb_pos.X + 9, thumb_pos.Y + 19, thumb_pos.X + 1, thumb_pos.Y + 19);
5917 pen = SystemPens.ControlDarkDark;
5918 dc.DrawLine (pen, thumb_pos.X + 10, thumb_pos.Y + 4, thumb_pos.X + 10, thumb_pos.Y + 4 + 16);
5919 dc.DrawLine (pen, thumb_pos.X + 10, thumb_pos.Y + 4, thumb_pos.X + 5, thumb_pos.Y - 1);
5920 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 20, thumb_pos.X + 10, thumb_pos.Y + 20);
5922 dc.FillRectangle (br_thumb, thumb_pos.X + 1, thumb_pos.Y + 4, 8, 15);
5923 dc.FillRectangle (br_thumb, thumb_pos.X + 2, thumb_pos.Y + 3, 6, 1);
5924 dc.FillRectangle (br_thumb, thumb_pos.X + 3, thumb_pos.Y + 2, 4, 1);
5925 dc.FillRectangle (br_thumb, thumb_pos.X + 4, thumb_pos.Y + 1, 2, 1);
5928 protected virtual void TrackBarDrawHorizontalThumb (Graphics dc, Rectangle thumb_pos, Brush br_thumb, Rectangle clippingArea, TrackBar trackBar)
5930 Pen pen = SystemPens.ControlLightLight;
5931 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X + 9, thumb_pos.Y);
5932 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X, thumb_pos.Y + 19);
5934 pen = SystemPens.ControlDark;
5935 dc.DrawLine (pen, thumb_pos.X + 9, thumb_pos.Y + 1, thumb_pos.X + 9, thumb_pos.Y + 19);
5936 dc.DrawLine (pen, thumb_pos.X + 1, thumb_pos.Y + 10, thumb_pos.X + 8, thumb_pos.Y + 19);
5938 pen = SystemPens.ControlDarkDark;
5939 dc.DrawLine (pen, thumb_pos.X + 10, thumb_pos.Y, thumb_pos.X + 10, thumb_pos.Y + 20);
5940 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 20, thumb_pos.X + 9, thumb_pos.Y + 20);
5942 dc.FillRectangle (br_thumb, thumb_pos.X + 1, thumb_pos.Y + 1, 8, 18);
5947 protected virtual ITrackBarTickPainter TrackBarGetHorizontalTickPainter (Graphics g)
5949 return GetTrackBarTickPainter (g);
5954 public override void DrawTrackBar (Graphics dc, Rectangle clip_rectangle, TrackBar tb)
5959 float ticks = (tb.Maximum - tb.Minimum) / tb.tickFrequency; /* N of ticks draw*/
5961 Rectangle thumb_pos = tb.ThumbPos;
5962 Rectangle thumb_area = tb.ThumbArea;
5964 if (tb.thumb_pressed) {
5965 value_pos = tb.thumb_mouseclick;
5968 value_pos = tb.Value - tb.Minimum;
5969 mouse_value = false;
5972 area = tb.ClientRectangle;
5975 br_thumb = (Brush) ResPool.GetHatchBrush (HatchStyle.Percent50, ColorControlLightLight, ColorControlLight);
5976 } else if (tb.thumb_pressed == true) {
5977 br_thumb = (Brush) ResPool.GetHatchBrush (HatchStyle.Percent50, ColorControlLight, ColorControl);
5979 br_thumb = SystemBrushes.Control;
5983 /* Control Background */
5984 if (tb.BackColor.ToArgb () == DefaultControlBackColor.ToArgb ()) {
5985 dc.FillRectangle (SystemBrushes.Control, clip_rectangle);
5987 dc.FillRectangle (ResPool.GetSolidBrush (tb.BackColor), clip_rectangle);
5991 CPDrawFocusRectangle(dc, area, tb.ForeColor, tb.BackColor);
5994 if (tb.Orientation == Orientation.Vertical) {
5995 DrawTrackBar_Vertical (dc, clip_rectangle, tb, ref thumb_pos, ref thumb_area,
5996 br_thumb, ticks, value_pos, mouse_value);
5999 DrawTrackBar_Horizontal (dc, clip_rectangle, tb, ref thumb_pos, ref thumb_area,
6000 br_thumb, ticks, value_pos, mouse_value);
6003 tb.ThumbPos = thumb_pos;
6004 tb.ThumbArea = thumb_area;
6007 public override Size TrackBarDefaultSize {
6009 return new Size (104, 42);
6013 public override bool TrackBarHasHotThumbStyle {
6018 #endregion // TrackBar
6021 public override void UpDownBaseDrawButton (Graphics g, Rectangle bounds, bool top, VisualStyles.PushButtonState state)
6023 ControlPaint.DrawScrollButton (g, bounds, top ? ScrollButton.Up : ScrollButton.Down, state == VisualStyles.PushButtonState.Pressed ? ButtonState.Pushed : ButtonState.Normal);
6026 public override bool UpDownBaseHasHotButtonStyle {
6034 public override Size VScrollBarDefaultSize {
6036 return new Size (this.ScrollBarButtonSize, 80);
6039 #endregion // VScrollBar
6042 public override Size TreeViewDefaultSize {
6044 return new Size (121, 97);
6048 public override void TreeViewDrawNodePlusMinus (TreeView treeView, TreeNode node, Graphics dc, int x, int middle)
6050 int height = treeView.ActualItemHeight - 2;
6051 dc.FillRectangle (ResPool.GetSolidBrush (treeView.BackColor), (x + 4) - (height / 2), node.GetY() + 1, height, height);
6053 dc.DrawRectangle (SystemPens.ControlDarkDark, x, middle - 4, 8, 8);
6055 if (node.IsExpanded) {
6056 dc.DrawLine (SystemPens.ControlDarkDark, x + 2, middle, x + 6, middle);
6058 dc.DrawLine (SystemPens.ControlDarkDark, x + 2, middle, x + 6, middle);
6059 dc.DrawLine (SystemPens.ControlDarkDark, x + 4, middle - 2, x + 4, middle + 2);
6064 #region Managed window
6065 public override int ManagedWindowTitleBarHeight (InternalWindowManager wm)
6067 if (wm.IsToolWindow && !wm.IsMinimized)
6068 return SystemInformation.ToolWindowCaptionHeight;
6069 if (wm.Form.FormBorderStyle == FormBorderStyle.None)
6071 return SystemInformation.CaptionHeight;
6074 public override int ManagedWindowBorderWidth (InternalWindowManager wm)
6076 if ((wm.IsToolWindow && wm.form.FormBorderStyle == FormBorderStyle.FixedToolWindow) ||
6083 public override int ManagedWindowIconWidth (InternalWindowManager wm)
6085 return ManagedWindowTitleBarHeight (wm) - 5;
6088 public override void ManagedWindowSetButtonLocations (InternalWindowManager wm)
6090 TitleButtons buttons = wm.TitleButtons;
6091 Form form = wm.form;
6093 buttons.HelpButton.Visible = form.HelpButton;
6095 foreach (TitleButton button in buttons) {
6096 button.Visible = false;
6099 switch (form.FormBorderStyle) {
6100 case FormBorderStyle.None:
6101 if (form.WindowState != FormWindowState.Normal)
6102 goto case FormBorderStyle.Sizable;
6104 case FormBorderStyle.FixedToolWindow:
6105 case FormBorderStyle.SizableToolWindow:
6106 buttons.CloseButton.Visible = true;
6107 if (form.WindowState != FormWindowState.Normal)
6108 goto case FormBorderStyle.Sizable;
6110 case FormBorderStyle.FixedSingle:
6111 case FormBorderStyle.Fixed3D:
6112 case FormBorderStyle.FixedDialog:
6113 case FormBorderStyle.Sizable:
6114 switch (form.WindowState) {
6115 case FormWindowState.Normal:
6116 buttons.MinimizeButton.Visible = true;
6117 buttons.MaximizeButton.Visible = true;
6118 buttons.RestoreButton.Visible = false;
6120 case FormWindowState.Maximized:
6121 buttons.MinimizeButton.Visible = true;
6122 buttons.MaximizeButton.Visible = false;
6123 buttons.RestoreButton.Visible = true;
6125 case FormWindowState.Minimized:
6126 buttons.MinimizeButton.Visible = false;
6127 buttons.MaximizeButton.Visible = true;
6128 buttons.RestoreButton.Visible = true;
6131 buttons.CloseButton.Visible = true;
6135 // Respect MinimizeBox/MaximizeBox
6136 if (form.MinimizeBox == false && form.MaximizeBox == false) {
6137 buttons.MinimizeButton.Visible = false;
6138 buttons.MaximizeButton.Visible = false;
6139 } else if (form.MinimizeBox == false)
6140 buttons.MinimizeButton.State = ButtonState.Inactive;
6141 else if (form.MaximizeBox == false)
6142 buttons.MaximizeButton.State = ButtonState.Inactive;
6144 int bw = ManagedWindowBorderWidth (wm);
6145 Size btsize = ManagedWindowButtonSize (wm);
6146 int btw = btsize.Width;
6147 int bth = btsize.Height;
6149 int left = form.Width - bw - btw - ManagedWindowSpacingAfterLastTitleButton;
6151 if ((!wm.IsToolWindow || wm.IsMinimized) && wm.HasBorders) {
6152 buttons.CloseButton.Rectangle = new Rectangle (left, top, btw, bth);
6155 if (buttons.MaximizeButton.Visible) {
6156 buttons.MaximizeButton.Rectangle = new Rectangle (left, top, btw, bth);
6159 if (buttons.RestoreButton.Visible) {
6160 buttons.RestoreButton.Rectangle = new Rectangle (left, top, btw, bth);
6164 buttons.MinimizeButton.Rectangle = new Rectangle (left, top, btw, bth);
6166 } else if (wm.IsToolWindow) {
6167 buttons.CloseButton.Rectangle = new Rectangle (left, top, btw, bth);
6172 protected virtual Rectangle ManagedWindowDrawTitleBarAndBorders (Graphics dc, Rectangle clip, InternalWindowManager wm)
6174 Form form = wm.Form;
6175 int tbheight = ManagedWindowTitleBarHeight (wm);
6176 int bdwidth = ManagedWindowBorderWidth (wm);
6177 Color titlebar_color = Color.FromArgb (255, 10, 36, 106);
6178 Color titlebar_color2 = Color.FromArgb (255, 166, 202, 240);
6179 Color color = ThemeEngine.Current.ColorControlDark;
6180 Color color2 = Color.FromArgb (255, 192, 192, 192);
6182 Pen pen = ResPool.GetPen (ColorControl);
6183 Rectangle borders = new Rectangle (0, 0, form.Width, form.Height);
6184 ControlPaint.DrawBorder3D (dc, borders, Border3DStyle.Raised);
6185 // The 3d border is only 2 pixels wide, so we draw the innermost pixels ourselves
6186 borders = new Rectangle (2, 2, form.Width - 5, form.Height - 5);
6187 for (int i = 2; i < bdwidth; i++) {
6188 dc.DrawRectangle (pen, borders);
6189 borders.Inflate (-1, -1);
6193 bool draw_titlebar_enabled = false;
6194 if (wm.Form.Parent != null && wm.Form.Parent is Form) {
6195 draw_titlebar_enabled = false;
6196 } else if (wm.IsActive && !wm.IsMaximized) {
6197 draw_titlebar_enabled = true;
6199 if (draw_titlebar_enabled) {
6200 color = titlebar_color;
6201 color2 = titlebar_color2;
6204 Rectangle tb = new Rectangle (bdwidth, bdwidth, form.Width - (bdwidth * 2), tbheight - 1);
6206 // HACK: For now always draw the titlebar until we get updates better
6207 if (tb.Width > 0 && tb.Height > 0) {
6208 using (System.Drawing.Drawing2D.LinearGradientBrush gradient = new LinearGradientBrush (tb, color, color2, LinearGradientMode.Horizontal))
6210 dc.FillRectangle (gradient, tb);
6214 if (!wm.IsMinimized)
6215 // Draw the line just beneath the title bar
6216 dc.DrawLine (ResPool.GetPen (SystemColors.Control), bdwidth,
6217 tbheight + bdwidth - 1, form.Width - bdwidth - 1,
6218 tbheight + bdwidth - 1);
6222 public override void DrawManagedWindowDecorations (Graphics dc, Rectangle clip, InternalWindowManager wm)
6225 Console.WriteLine (DateTime.Now.ToLongTimeString () + " DrawManagedWindowDecorations");
6226 dc.FillRectangle (Brushes.Black, clip);
6228 Rectangle tb = ManagedWindowDrawTitleBarAndBorders (dc, clip, wm);
6230 Form form = wm.Form;
6232 Rectangle icon = ManagedWindowGetTitleBarIconArea (wm);
6233 if (icon.IntersectsWith (clip))
6234 dc.DrawIcon (form.Icon, icon);
6235 const int SpacingBetweenIconAndCaption = 2;
6236 tb.Width -= icon.Right + SpacingBetweenIconAndCaption - tb.X ;
6237 tb.X = icon.Right + SpacingBetweenIconAndCaption;
6240 foreach (TitleButton button in wm.TitleButtons.AllButtons) {
6241 tb.Width -= Math.Max (0, tb.Right - DrawTitleButton (dc, button, clip, form));
6243 const int SpacingBetweenCaptionAndLeftMostButton = 3;
6244 tb.Width -= SpacingBetweenCaptionAndLeftMostButton;
6246 string window_caption = form.Text;
6247 window_caption = window_caption.Replace (Environment.NewLine, string.Empty);
6249 if (window_caption != null && window_caption != string.Empty) {
6250 StringFormat format = new StringFormat ();
6251 format.FormatFlags = StringFormatFlags.NoWrap;
6252 format.Trimming = StringTrimming.EllipsisCharacter;
6253 format.LineAlignment = StringAlignment.Center;
6255 if (tb.IntersectsWith (clip))
6256 dc.DrawString (window_caption, WindowBorderFont,
6257 ThemeEngine.Current.ResPool.GetSolidBrush (Color.White),
6262 public override Size ManagedWindowButtonSize (InternalWindowManager wm)
6264 int height = ManagedWindowTitleBarHeight (wm);
6265 if (!wm.IsMaximized && !wm.IsMinimized) {
6266 if (wm.IsToolWindow)
6267 return new Size (SystemInformation.ToolWindowCaptionButtonSize.Width - 2,
6269 if (wm.Form.FormBorderStyle == FormBorderStyle.None)
6272 height = SystemInformation.CaptionHeight;
6274 return new Size (SystemInformation.CaptionButtonSize.Width - 2,
6278 private int DrawTitleButton (Graphics dc, TitleButton button, Rectangle clip, Form form)
6280 if (!button.Visible) {
6281 return int.MaxValue;
6284 if (button.Rectangle.IntersectsWith (clip)) {
6285 ManagedWindowDrawTitleButton (dc, button, clip, form);
6287 return button.Rectangle.Left;
6290 protected virtual void ManagedWindowDrawTitleButton (Graphics dc, TitleButton button, Rectangle clip, Form form)
6292 dc.FillRectangle (SystemBrushes.Control, button.Rectangle);
6294 ControlPaint.DrawCaptionButton (dc, button.Rectangle,
6295 button.Caption, button.State);
6298 public override Rectangle ManagedWindowGetTitleBarIconArea (InternalWindowManager wm)
6300 int bw = ManagedWindowBorderWidth (wm);
6301 return new Rectangle (bw + 3, bw + 2, wm.IconWidth, wm.IconWidth);
6304 public override Size ManagedWindowGetMenuButtonSize (InternalWindowManager wm)
6306 Size result = SystemInformation.MenuButtonSize;
6312 public override bool ManagedWindowTitleButtonHasHotElementStyle (TitleButton button, Form form)
6317 public override void ManagedWindowDrawMenuButton (Graphics dc, TitleButton button, Rectangle clip, InternalWindowManager wm)
6319 dc.FillRectangle (SystemBrushes.Control, button.Rectangle);
6320 ControlPaint.DrawCaptionButton (dc, button.Rectangle,
6321 button.Caption, button.State);
6324 public override void ManagedWindowOnSizeInitializedOrChanged (Form form)
6329 #region ControlPaint
6330 public override void CPDrawBorder (Graphics graphics, Rectangle bounds, Color leftColor, int leftWidth,
6331 ButtonBorderStyle leftStyle, Color topColor, int topWidth, ButtonBorderStyle topStyle,
6332 Color rightColor, int rightWidth, ButtonBorderStyle rightStyle, Color bottomColor,
6333 int bottomWidth, ButtonBorderStyle bottomStyle) {
6334 DrawBorderInternal(graphics, bounds.Left, bounds.Top, bounds.Left, bounds.Bottom-1, leftWidth, leftColor, leftStyle, Border3DSide.Left);
6335 DrawBorderInternal(graphics, bounds.Left, bounds.Top, bounds.Right-1, bounds.Top, topWidth, topColor, topStyle, Border3DSide.Top);
6336 DrawBorderInternal(graphics, bounds.Right-1, bounds.Top, bounds.Right-1, bounds.Bottom-1, rightWidth, rightColor, rightStyle, Border3DSide.Right);
6337 DrawBorderInternal(graphics, bounds.Left, bounds.Bottom-1, bounds.Right-1, bounds.Bottom-1, bottomWidth, bottomColor, bottomStyle, Border3DSide.Bottom);
6340 public override void CPDrawBorder (Graphics graphics, RectangleF bounds, Color leftColor, int leftWidth,
6341 ButtonBorderStyle leftStyle, Color topColor, int topWidth, ButtonBorderStyle topStyle,
6342 Color rightColor, int rightWidth, ButtonBorderStyle rightStyle, Color bottomColor,
6343 int bottomWidth, ButtonBorderStyle bottomStyle) {
6344 DrawBorderInternal(graphics, bounds.Left, bounds.Top, bounds.Left, bounds.Bottom-1, leftWidth, leftColor, leftStyle, Border3DSide.Left);
6345 DrawBorderInternal(graphics, bounds.Left, bounds.Top, bounds.Right-1, bounds.Top, topWidth, topColor, topStyle, Border3DSide.Top);
6346 DrawBorderInternal(graphics, bounds.Right-1, bounds.Top, bounds.Right-1, bounds.Bottom-1, rightWidth, rightColor, rightStyle, Border3DSide.Right);
6347 DrawBorderInternal(graphics, bounds.Left, bounds.Bottom-1, bounds.Right-1, bounds.Bottom-1, bottomWidth, bottomColor, bottomStyle, Border3DSide.Bottom);
6350 public override void CPDrawBorder3D (Graphics graphics, Rectangle rectangle, Border3DStyle style, Border3DSide sides) {
6351 CPDrawBorder3D(graphics, rectangle, style, sides, ColorControl);
6354 public override void CPDrawBorder3D (Graphics graphics, Rectangle rectangle, Border3DStyle style, Border3DSide sides, Color control_color)
6357 Pen penTopLeftInner;
6359 Pen penBottomRightInner;
6360 Rectangle rect= new Rectangle (rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
6361 bool is_ColorControl = control_color.ToArgb () == ColorControl.ToArgb () ? true : false;
6363 if ((style & Border3DStyle.Adjust) != 0) {
6370 penTopLeft = penTopLeftInner = penBottomRight = penBottomRightInner = is_ColorControl ? SystemPens.Control : ResPool.GetPen (control_color);
6372 CPColor cpcolor = CPColor.Empty;
6374 if (!is_ColorControl)
6375 cpcolor = ResPool.GetCPColor (control_color);
6378 case Border3DStyle.Raised:
6379 penTopLeftInner = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
6380 penBottomRight = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
6381 penBottomRightInner = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
6383 case Border3DStyle.Sunken:
6384 penTopLeft = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
6385 penTopLeftInner = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
6386 penBottomRight = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
6388 case Border3DStyle.Etched:
6389 penTopLeft = penBottomRightInner = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
6390 penTopLeftInner = penBottomRight = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
6392 case Border3DStyle.RaisedOuter:
6393 penBottomRight = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
6395 case Border3DStyle.SunkenOuter:
6396 penTopLeft = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
6397 penBottomRight = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
6399 case Border3DStyle.RaisedInner:
6400 penTopLeft = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
6401 penBottomRight = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
6403 case Border3DStyle.SunkenInner:
6404 penTopLeft = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
6406 case Border3DStyle.Flat:
6407 penTopLeft = penBottomRight = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
6409 case Border3DStyle.Bump:
6410 penTopLeftInner = penBottomRight = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
6416 bool inner = ((style != Border3DStyle.RaisedOuter) && (style != Border3DStyle.SunkenOuter));
6418 if ((sides & Border3DSide.Middle) != 0) {
6419 Brush brush = is_ColorControl ? SystemBrushes.Control : ResPool.GetSolidBrush (control_color);
6420 graphics.FillRectangle (brush, rect);
6423 if ((sides & Border3DSide.Left) != 0) {
6424 graphics.DrawLine (penTopLeft, rect.Left, rect.Bottom - 2, rect.Left, rect.Top);
6425 if ((rect.Width > 2) && inner)
6426 graphics.DrawLine (penTopLeftInner, rect.Left + 1, rect.Bottom - 2, rect.Left + 1, rect.Top);
6429 if ((sides & Border3DSide.Top) != 0) {
6430 graphics.DrawLine (penTopLeft, rect.Left, rect.Top, rect.Right - 2, rect.Top);
6431 if ((rect.Height > 2) && inner)
6432 graphics.DrawLine (penTopLeftInner, rect.Left + 1, rect.Top + 1, rect.Right - 3, rect.Top + 1);
6435 if ((sides & Border3DSide.Right) != 0) {
6436 graphics.DrawLine (penBottomRight, rect.Right - 1, rect.Top, rect.Right - 1, rect.Bottom - 1);
6437 if ((rect.Width > 3) && inner)
6438 graphics.DrawLine (penBottomRightInner, rect.Right - 2, rect.Top + 1, rect.Right - 2, rect.Bottom - 2);
6441 if ((sides & Border3DSide.Bottom) != 0) {
6442 graphics.DrawLine (penBottomRight, rect.Left, rect.Bottom - 1, rect.Right - 1, rect.Bottom - 1);
6443 if ((rect.Height > 3) && inner)
6444 graphics.DrawLine (penBottomRightInner, rect.Left + 1, rect.Bottom - 2, rect.Right - 2, rect.Bottom - 2);
6448 public override void CPDrawButton (Graphics dc, Rectangle rectangle, ButtonState state)
6450 CPDrawButtonInternal (dc, rectangle, state, SystemPens.ControlDarkDark, SystemPens.ControlDark, SystemPens.ControlLight);
6453 private void CPDrawButtonInternal (Graphics dc, Rectangle rectangle, ButtonState state, Pen DarkPen, Pen NormalPen, Pen LightPen)
6455 // sadly enough, the rectangle gets always filled with a hatchbrush
6456 dc.FillRectangle (ResPool.GetHatchBrush (HatchStyle.Percent50,
6457 Color.FromArgb (Clamp (ColorControl.R + 3, 0, 255),
6458 ColorControl.G, ColorControl.B),
6460 rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2);
6462 if ((state & ButtonState.All) == ButtonState.All || ((state & ButtonState.Checked) == ButtonState.Checked && (state & ButtonState.Flat) == ButtonState.Flat)) {
6463 dc.FillRectangle (ResPool.GetHatchBrush (HatchStyle.Percent50, ColorControlLight, ColorControl), rectangle.X + 2, rectangle.Y + 2, rectangle.Width - 4, rectangle.Height - 4);
6465 dc.DrawRectangle (SystemPens.ControlDark, rectangle.X, rectangle.Y, rectangle.Width - 1, rectangle.Height - 1);
6467 if ((state & ButtonState.Flat) == ButtonState.Flat) {
6468 dc.DrawRectangle (SystemPens.ControlDark, rectangle.X, rectangle.Y, rectangle.Width - 1, rectangle.Height - 1);
6470 if ((state & ButtonState.Checked) == ButtonState.Checked) {
6471 dc.FillRectangle (ResPool.GetHatchBrush (HatchStyle.Percent50, ColorControlLight, ColorControl), rectangle.X + 2, rectangle.Y + 2, rectangle.Width - 4, rectangle.Height - 4);
6474 dc.DrawLine (pen, rectangle.X, rectangle.Y, rectangle.X, rectangle.Bottom - 2);
6475 dc.DrawLine (pen, rectangle.X + 1, rectangle.Y, rectangle.Right - 2, rectangle.Y);
6478 dc.DrawLine (pen, rectangle.X + 1, rectangle.Y + 1, rectangle.X + 1, rectangle.Bottom - 3);
6479 dc.DrawLine (pen, rectangle.X + 2, rectangle.Y + 1, rectangle.Right - 3, rectangle.Y + 1);
6482 dc.DrawLine (pen, rectangle.X, rectangle.Bottom - 1, rectangle.Right - 2, rectangle.Bottom - 1);
6483 dc.DrawLine (pen, rectangle.Right - 1, rectangle.Y, rectangle.Right - 1, rectangle.Bottom - 1);
6485 if (((state & ButtonState.Pushed) == ButtonState.Pushed) && ((state & ButtonState.Normal) == ButtonState.Normal)) {
6487 dc.DrawLine (pen, rectangle.X, rectangle.Y, rectangle.X, rectangle.Bottom - 2);
6488 dc.DrawLine (pen, rectangle.X + 1, rectangle.Y, rectangle.Right - 2, rectangle.Y);
6491 dc.DrawLine (pen, rectangle.X + 1, rectangle.Y + 1, rectangle.X + 1, rectangle.Bottom - 3);
6492 dc.DrawLine (pen, rectangle.X + 2, rectangle.Y + 1, rectangle.Right - 3, rectangle.Y + 1);
6495 dc.DrawLine (pen, rectangle.X, rectangle.Bottom - 1, rectangle.Right - 2, rectangle.Bottom - 1);
6496 dc.DrawLine (pen, rectangle.Right - 1, rectangle.Y, rectangle.Right - 1, rectangle.Bottom - 1);
6498 if (((state & ButtonState.Inactive) == ButtonState.Inactive) || ((state & ButtonState.Normal) == ButtonState.Normal)) {
6500 dc.DrawLine (pen, rectangle.X, rectangle.Y, rectangle.Right - 2, rectangle.Y);
6501 dc.DrawLine (pen, rectangle.X, rectangle.Y, rectangle.X, rectangle.Bottom - 2);
6504 dc.DrawLine (pen, rectangle.X + 1, rectangle.Bottom - 2, rectangle.Right - 2, rectangle.Bottom - 2);
6505 dc.DrawLine (pen, rectangle.Right - 2, rectangle.Y + 1, rectangle.Right - 2, rectangle.Bottom - 3);
6508 dc.DrawLine (pen, rectangle.X, rectangle.Bottom - 1, rectangle.Right - 1, rectangle.Bottom - 1);
6509 dc.DrawLine (pen, rectangle.Right - 1, rectangle.Y, rectangle.Right - 1, rectangle.Bottom - 2);
6514 public override void CPDrawCaptionButton (Graphics graphics, Rectangle rectangle, CaptionButton button, ButtonState state) {
6515 Rectangle captionRect;
6518 CPDrawButtonInternal (graphics, rectangle, state, SystemPens.ControlDarkDark, SystemPens.ControlDark, SystemPens.ControlLightLight);
6520 if (rectangle.Width<rectangle.Height) {
6521 captionRect=new Rectangle(rectangle.X+1, rectangle.Y+rectangle.Height/2-rectangle.Width/2+1, rectangle.Width-4, rectangle.Width-4);
6523 captionRect=new Rectangle(rectangle.X+rectangle.Width/2-rectangle.Height/2+1, rectangle.Y+1, rectangle.Height-4, rectangle.Height-4);
6526 if ((state & ButtonState.Pushed)!=0) {
6527 captionRect=new Rectangle(rectangle.X+2, rectangle.Y+2, rectangle.Width-3, rectangle.Height-3);
6530 /* Make sure we've got at least a line width of 1 */
6531 lineWidth=Math.Max(1, captionRect.Width/7);
6534 case CaptionButton.Close: {
6537 if ((state & ButtonState.Inactive)!=0) {
6538 pen = ResPool.GetSizedPen (ColorControlLight, lineWidth);
6539 DrawCaptionHelper(graphics, ColorControlLight, pen, lineWidth, 1, captionRect, button);
6541 pen = ResPool.GetSizedPen (ColorControlDark, lineWidth);
6542 DrawCaptionHelper(graphics, ColorControlDark, pen, lineWidth, 0, captionRect, button);
6545 pen = ResPool.GetSizedPen (ColorControlText, lineWidth);
6546 DrawCaptionHelper(graphics, ColorControlText, pen, lineWidth, 0, captionRect, button);
6551 case CaptionButton.Help:
6552 case CaptionButton.Maximize:
6553 case CaptionButton.Minimize:
6554 case CaptionButton.Restore: {
6555 if ((state & ButtonState.Inactive)!=0) {
6556 DrawCaptionHelper(graphics, ColorControlLight, SystemPens.ControlLightLight, lineWidth, 1, captionRect, button);
6558 DrawCaptionHelper(graphics, ColorControlDark, SystemPens.ControlDark, lineWidth, 0, captionRect, button);
6561 DrawCaptionHelper(graphics, ColorControlText, SystemPens.ControlText, lineWidth, 0, captionRect, button);
6568 public override void CPDrawCheckBox (Graphics dc, Rectangle rectangle, ButtonState state)
6570 Pen check_pen = Pens.Black;
6572 Rectangle cb_rect = new Rectangle (rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
6574 if ((state & ButtonState.All) == ButtonState.All) {
6576 cb_rect.Height -= 2;
6578 dc.FillRectangle (SystemBrushes.Control, cb_rect.X, cb_rect.Y, cb_rect.Width - 1, cb_rect.Height - 1);
6579 dc.DrawRectangle (SystemPens.ControlDark, cb_rect.X, cb_rect.Y, cb_rect.Width - 1, cb_rect.Height - 1);
6581 check_pen = SystemPens.ControlDark;
6583 if ((state & ButtonState.Flat) == ButtonState.Flat) {
6585 cb_rect.Height -= 2;
6587 if ((state & ButtonState.Inactive) == ButtonState.Inactive)
6588 dc.FillRectangle (SystemBrushes.ControlLight, cb_rect.X, cb_rect.Y, cb_rect.Width - 1, cb_rect.Height - 1);
6590 dc.FillRectangle (Brushes.White, cb_rect.X, cb_rect.Y, cb_rect.Width - 1, cb_rect.Height - 1);
6591 dc.DrawRectangle (SystemPens.ControlDark, cb_rect.X, cb_rect.Y, cb_rect.Width - 1, cb_rect.Height - 1);
6594 cb_rect.Height -= 1;
6596 int check_box_visible_size = (cb_rect.Height > cb_rect.Width) ? cb_rect.Width : cb_rect.Height;
6598 int x_pos = Math.Max (0, cb_rect.X + (cb_rect.Width / 2) - check_box_visible_size / 2);
6599 int y_pos = Math.Max (0, cb_rect.Y + (cb_rect.Height / 2) - check_box_visible_size / 2);
6601 Rectangle rect = new Rectangle (x_pos, y_pos, check_box_visible_size, check_box_visible_size);
6603 if (((state & ButtonState.Pushed) == ButtonState.Pushed) || ((state & ButtonState.Inactive) == ButtonState.Inactive)) {
6604 dc.FillRectangle (ResPool.GetHatchBrush (HatchStyle.Percent50,
6605 Color.FromArgb (Clamp (ColorControl.R + 3, 0, 255),
6606 ColorControl.G, ColorControl.B),
6607 ColorControl), rect.X + 2, rect.Y + 2, rect.Width - 3, rect.Height - 3);
6609 dc.FillRectangle (SystemBrushes.ControlLightLight, rect.X + 2, rect.Y + 2, rect.Width - 3, rect.Height - 3);
6611 Pen pen = SystemPens.ControlDark;
6612 dc.DrawLine (pen, rect.X, rect.Y, rect.X, rect.Bottom - 1);
6613 dc.DrawLine (pen, rect.X + 1, rect.Y, rect.Right - 1, rect.Y);
6615 pen = SystemPens.ControlDarkDark;
6616 dc.DrawLine (pen, rect.X + 1, rect.Y + 1, rect.X + 1, rect.Bottom - 2);
6617 dc.DrawLine (pen, rect.X + 2, rect.Y + 1, rect.Right - 2, rect.Y + 1);
6619 pen = SystemPens.ControlLightLight;
6620 dc.DrawLine (pen, rect.Right, rect.Y, rect.Right, rect.Bottom);
6621 dc.DrawLine (pen, rect.X, rect.Bottom, rect.Right, rect.Bottom);
6623 // oh boy, matching ms is like fighting against windmills
6624 using (Pen h_pen = new Pen (ResPool.GetHatchBrush (HatchStyle.Percent50,
6625 Color.FromArgb (Clamp (ColorControl.R + 3, 0, 255),
6626 ColorControl.G, ColorControl.B), ColorControl))) {
6627 dc.DrawLine (h_pen, rect.X + 1, rect.Bottom - 1, rect.Right - 1, rect.Bottom - 1);
6628 dc.DrawLine (h_pen, rect.Right - 1, rect.Y + 1, rect.Right - 1, rect.Bottom - 1);
6631 if ((state & ButtonState.Inactive) == ButtonState.Inactive)
6632 check_pen = SystemPens.ControlDark;
6635 if ((state & ButtonState.Checked) == ButtonState.Checked) {
6636 int check_size = (cb_rect.Height > cb_rect.Width) ? cb_rect.Width / 2: cb_rect.Height / 2;
6638 if (check_size < 7) {
6639 int lineWidth = Math.Max (3, check_size / 3);
6640 int Scale = Math.Max (1, check_size / 9);
6642 Rectangle rect = new Rectangle (cb_rect.X + (cb_rect.Width / 2) - (int)Math.Ceiling ((float)check_size / 2) - 1, cb_rect.Y + (cb_rect.Height / 2) - (check_size / 2) - 1,
6643 check_size, check_size);
6645 for (int i = 0; i < lineWidth; i++) {
6646 dc.DrawLine (check_pen, rect.Left + lineWidth / 2, rect.Top + lineWidth + i, rect.Left + lineWidth / 2 + 2 * Scale, rect.Top + lineWidth + 2 * Scale + i);
6647 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);
6650 int lineWidth = Math.Max (3, check_size / 3) + 1;
6652 int x_half = cb_rect.Width / 2;
6653 int y_half = cb_rect.Height / 2;
6655 Rectangle rect = new Rectangle (cb_rect.X + x_half - (check_size / 2) - 1, cb_rect.Y + y_half - (check_size / 2),
6656 check_size, check_size);
6658 int gradient_left = check_size / 3;
6659 int gradient_right = check_size - gradient_left - 1;
6662 for (int i = 0; i < lineWidth; i++) {
6663 dc.DrawLine (check_pen, rect.X, rect.Bottom - 1 - gradient_left - i, rect.X + gradient_left, rect.Bottom - 1 - i);
6664 dc.DrawLine (check_pen, rect.X + gradient_left, rect.Bottom - 1 - i, rect.Right - 1, rect.Bottom - i - 1 - gradient_right);
6670 public override void CPDrawComboButton (Graphics graphics, Rectangle rectangle, ButtonState state) {
6671 Point[] arrow = new Point[3];
6681 if ((state & ButtonState.Checked)!=0) {
6682 graphics.FillRectangle(ResPool.GetHatchBrush (HatchStyle.Percent50, ColorControlLightLight, ColorControlLight),rectangle);
6685 if ((state & ButtonState.Flat)!=0) {
6686 ControlPaint.DrawBorder(graphics, rectangle, ColorControlDark, ButtonBorderStyle.Solid);
6688 if ((state & (ButtonState.Pushed | ButtonState.Checked))!=0) {
6689 // this needs to render like a pushed button - jba
6690 // CPDrawBorder3D(graphics, rectangle, Border3DStyle.Sunken, Border3DSide.Left | Border3DSide.Top | Border3DSide.Right | Border3DSide.Bottom, ColorControl);
6691 Rectangle trace_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max (rectangle.Width-1, 0), Math.Max (rectangle.Height-1, 0));
6692 graphics.DrawRectangle (SystemPens.ControlDark, trace_rectangle);
6694 CPDrawBorder3D(graphics, rectangle, Border3DStyle.Raised, Border3DSide.Left | Border3DSide.Top | Border3DSide.Right | Border3DSide.Bottom, ColorControl);
6698 rect=new Rectangle(rectangle.X+rectangle.Width/4, rectangle.Y+rectangle.Height/4, rectangle.Width/2, rectangle.Height/2);
6699 centerX=rect.Left+rect.Width/2;
6700 centerY=rect.Top+rect.Height/2;
6701 shiftX=Math.Max(1, rect.Width/8);
6702 shiftY=Math.Max(1, rect.Height/8);
6704 if ((state & ButtonState.Pushed)!=0) {
6711 P1=new Point(rect.Left, centerY);
6712 P2=new Point(rect.Right, centerY);
6713 P3=new Point(centerX, rect.Bottom);
6719 /* Draw the arrow */
6720 if ((state & ButtonState.Inactive)!=0) {
6721 /* Move away from the shadow */
6722 arrow[0].X += 1; arrow[0].Y += 1;
6723 arrow[1].X += 1; arrow[1].Y += 1;
6724 arrow[2].X += 1; arrow[2].Y += 1;
6726 graphics.FillPolygon(SystemBrushes.ControlLightLight, arrow, FillMode.Winding);
6732 graphics.FillPolygon(SystemBrushes.ControlDark, arrow, FillMode.Winding);
6734 graphics.FillPolygon(SystemBrushes.ControlText, arrow, FillMode.Winding);
6739 public override void CPDrawContainerGrabHandle (Graphics graphics, Rectangle bounds)
6741 Pen pen = Pens.Black;
6742 Rectangle rect = new Rectangle (bounds.X, bounds.Y, bounds.Width - 1, bounds.Height - 1); // Dunno why, but MS does it that way, too
6746 graphics.FillRectangle (SystemBrushes.ControlLightLight, rect);
6747 graphics.DrawRectangle (pen, rect);
6749 X = rect.X + rect.Width / 2;
6750 Y = rect.Y + rect.Height / 2;
6752 /* Draw the cross */
6753 graphics.DrawLine (pen, X, rect.Y + 2, X, rect.Bottom - 2);
6754 graphics.DrawLine (pen, rect.X + 2, Y, rect.Right - 2, Y);
6756 /* Draw 'arrows' for vertical lines */
6757 graphics.DrawLine (pen, X - 1, rect.Y + 3, X + 1, rect.Y + 3);
6758 graphics.DrawLine (pen, X - 1, rect.Bottom - 3, X + 1, rect.Bottom - 3);
6760 /* Draw 'arrows' for horizontal lines */
6761 graphics.DrawLine (pen, rect.X + 3, Y - 1, rect.X + 3, Y + 1);
6762 graphics.DrawLine (pen, rect.Right - 3, Y - 1, rect.Right - 3, Y + 1);
6765 public virtual void DrawFlatStyleFocusRectangle (Graphics graphics, Rectangle rectangle, ButtonBase button, Color foreColor, Color backColor) {
6766 // make a rectange to trace around border of the button
6767 Rectangle trace_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max (rectangle.Width-1, 0), Math.Max (rectangle.Height-1, 0));
6769 Color outerColor = foreColor;
6770 // adjust focus color according to the flatstyle
6771 if (button.FlatStyle == FlatStyle.Popup && !button.is_pressed) {
6772 outerColor = (backColor.ToArgb () == ColorControl.ToArgb ()) ? ControlPaint.Dark(ColorControl) : ColorControlText;
6775 // draw the outer rectangle
6776 graphics.DrawRectangle (ResPool.GetPen (outerColor), trace_rectangle);
6778 // draw the inner rectangle
6779 if (button.FlatStyle == FlatStyle.Popup) {
6780 DrawInnerFocusRectangle (graphics, Rectangle.Inflate (rectangle, -4, -4), backColor);
6782 // draw a flat inner rectangle
6783 Pen pen = ResPool.GetPen (ControlPaint.LightLight (backColor));
6784 graphics.DrawRectangle(pen, Rectangle.Inflate (trace_rectangle, -4, -4));
6788 public virtual void DrawInnerFocusRectangle(Graphics graphics, Rectangle rectangle, Color backColor)
6790 // make a rectange to trace around border of the button
6791 Rectangle trace_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max (rectangle.Width-1, 0), Math.Max (rectangle.Height-1, 0));
6793 #if NotUntilCairoIsFixed
6794 Color colorBackInverted = Color.FromArgb (Math.Abs (backColor.R-255), Math.Abs (backColor.G-255), Math.Abs (backColor.B-255));
6795 DashStyle oldStyle; // used for caching old penstyle
6796 Pen pen = ResPool.GetPen (colorBackInverted);
6798 oldStyle = pen.DashStyle;
6799 pen.DashStyle = DashStyle.Dot;
6801 graphics.DrawRectangle (pen, trace_rectangle);
6802 pen.DashStyle = oldStyle;
6804 CPDrawFocusRectangle(graphics, trace_rectangle, Color.Wheat, backColor);
6809 public override void CPDrawFocusRectangle (Graphics graphics, Rectangle rectangle, Color foreColor, Color backColor)
6811 Rectangle rect = rectangle;
6815 if (backColor.GetBrightness () >= 0.5) {
6816 foreColor = Color.Transparent;
6817 backColor = Color.Black;
6820 backColor = Color.FromArgb (Math.Abs (backColor.R-255), Math.Abs (backColor.G-255), Math.Abs (backColor.B-255));
6821 foreColor = Color.Black;
6824 brush = ResPool.GetHatchBrush (HatchStyle.Percent50, backColor, foreColor);
6825 pen = new Pen (brush, 1);
6830 graphics.DrawRectangle (pen, rect);
6834 public override void CPDrawGrabHandle (Graphics graphics, Rectangle rectangle, bool primary, bool enabled)
6839 if (primary == true) {
6841 if (enabled == true) {
6844 sb = SystemBrushes.Control;
6848 if (enabled == true) {
6851 sb = SystemBrushes.Control;
6854 graphics.FillRectangle (sb, rectangle);
6855 graphics.DrawRectangle (pen, rectangle);
6859 public override void CPDrawGrid (Graphics graphics, Rectangle area, Size pixelsBetweenDots, Color backColor) {
6865 ControlPaint.Color2HBS(backColor, out h, out b, out s);
6868 foreColor=Color.Black;
6870 foreColor=Color.White;
6873 // still not perfect. it seems that ms calculates the position of the first dot or line
6875 using (Pen pen = new Pen (foreColor)) {
6876 pen.DashPattern = new float [] {1.0f, pixelsBetweenDots.Width - 1};
6878 for (int y = area.Top; y < area.Bottom; y += pixelsBetweenDots.Height)
6879 graphics.DrawLine (pen, area.X, y, area.Right - 1, y);
6883 public override void CPDrawImageDisabled (Graphics graphics, Image image, int x, int y, Color background) {
6885 Microsoft seems to ignore the background and simply make
6886 the image grayscale. At least when having > 256 colors on
6890 if (imagedisabled_attributes == null) {
6891 imagedisabled_attributes = new ImageAttributes ();
6892 ColorMatrix colorMatrix=new ColorMatrix(new float[][] {
6893 // This table would create a perfect grayscale image, based on luminance
6894 // new float[]{0.3f,0.3f,0.3f,0,0},
6895 // new float[]{0.59f,0.59f,0.59f,0,0},
6896 // new float[]{0.11f,0.11f,0.11f,0,0},
6897 // new float[]{0,0,0,1,0,0},
6898 // new float[]{0,0,0,0,1,0},
6899 // new float[]{0,0,0,0,0,1}
6901 // This table generates a image that is grayscaled and then
6902 // brightened up. Seems to match MS close enough.
6903 new float[]{0.2f,0.2f,0.2f,0,0},
6904 new float[]{0.41f,0.41f,0.41f,0,0},
6905 new float[]{0.11f,0.11f,0.11f,0,0},
6906 new float[]{0.15f,0.15f,0.15f,1,0,0},
6907 new float[]{0.15f,0.15f,0.15f,0,1,0},
6908 new float[]{0.15f,0.15f,0.15f,0,0,1}
6911 imagedisabled_attributes.SetColorMatrix (colorMatrix);
6914 graphics.DrawImage(image, new Rectangle(x, y, image.Width, image.Height), 0, 0, image.Width, image.Height, GraphicsUnit.Pixel, imagedisabled_attributes);
6919 public override void CPDrawLockedFrame (Graphics graphics, Rectangle rectangle, bool primary) {
6924 penBorder = ResPool.GetSizedPen (Color.White, 2);
6925 penInside = ResPool.GetPen (Color.Black);
6927 penBorder = ResPool.GetSizedPen (Color.Black, 2);
6928 penInside = ResPool.GetPen (Color.White);
6930 penBorder.Alignment=PenAlignment.Inset;
6931 penInside.Alignment=PenAlignment.Inset;
6933 graphics.DrawRectangle(penBorder, rectangle);
6934 graphics.DrawRectangle(penInside, rectangle.X+2, rectangle.Y+2, rectangle.Width-5, rectangle.Height-5);
6938 public override void CPDrawMenuGlyph (Graphics graphics, Rectangle rectangle, MenuGlyph glyph, Color color, Color backColor) {
6942 if (backColor != Color.Empty)
6943 graphics.FillRectangle (ResPool.GetSolidBrush (backColor), rectangle);
6945 Brush brush = ResPool.GetSolidBrush (color);
6948 case MenuGlyph.Arrow: {
6949 float height = rectangle.Height * 0.7f;
6950 float width = height / 2.0f;
6952 PointF ddCenter = new PointF (rectangle.X + ((rectangle.Width-width) / 2.0f), rectangle.Y + (rectangle.Height / 2.0f));
6954 PointF [] vertices = new PointF [3];
6955 vertices [0].X = ddCenter.X;
6956 vertices [0].Y = ddCenter.Y - (height / 2.0f);
6957 vertices [1].X = ddCenter.X;
6958 vertices [1].Y = ddCenter.Y + (height / 2.0f);
6959 vertices [2].X = ddCenter.X + width + 0.1f;
6960 vertices [2].Y = ddCenter.Y;
6962 graphics.FillPolygon (brush, vertices);
6967 case MenuGlyph.Bullet: {
6969 lineWidth=Math.Max(2, rectangle.Width/3);
6970 rect=new Rectangle(rectangle.X+lineWidth, rectangle.Y+lineWidth, rectangle.Width-lineWidth*2, rectangle.Height-lineWidth*2);
6972 graphics.FillEllipse(brush, rect);
6977 case MenuGlyph.Checkmark: {
6979 Pen pen = ResPool.GetPen (color);
6980 lineWidth = Math.Max (2, rectangle.Width / 6);
6981 rect = new Rectangle(rectangle.X + lineWidth, rectangle.Y + lineWidth, rectangle.Width - lineWidth * 2, rectangle.Height- lineWidth * 2);
6983 int Scale = Math.Max (1, rectangle.Width / 12);
6984 int top = (rect.Y + lineWidth + ((rect.Height - ((2 * Scale) + lineWidth)) / 2));
6986 for (int i=0; i<lineWidth; i++) {
6987 graphics.DrawLine (pen, rect.Left+lineWidth/2, top+i, rect.Left+lineWidth/2+2*Scale, top+2*Scale+i);
6988 graphics.DrawLine (pen, rect.Left+lineWidth/2+2*Scale, top+2*Scale+i, rect.Left+lineWidth/2+6*Scale, top-2*Scale+i);
6997 public override void CPDrawMixedCheckBox (Graphics graphics, Rectangle rectangle, ButtonState state)
6999 CPDrawCheckBox (graphics, rectangle, state);
7002 public override void CPDrawRadioButton (Graphics dc, Rectangle rectangle, ButtonState state)
7004 CPColor cpcolor = ResPool.GetCPColor (ColorControl);
7006 Color dot_color = Color.Black;
7008 Color top_left_outer = Color.Black;
7009 Color top_left_inner = Color.Black;
7010 Color bottom_right_outer = Color.Black;
7011 Color bottom_right_inner = Color.Black;
7013 int ellipse_diameter = (rectangle.Width > rectangle.Height) ? (int)(rectangle.Height * 0.9f) : (int)(rectangle.Width * 0.9f);
7014 int radius = ellipse_diameter / 2;
7016 Rectangle rb_rect = new Rectangle (rectangle.X + (rectangle.Width / 2) - radius, rectangle.Y + (rectangle.Height / 2) - radius, ellipse_diameter, ellipse_diameter);
7020 if ((state & ButtonState.All) == ButtonState.All) {
7021 brush = ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (Clamp (ColorControl.R + 3, 0, 255),
7022 ColorControl.G, ColorControl.B), ColorControl);
7023 dot_color = cpcolor.Dark;
7025 if ((state & ButtonState.Flat) == ButtonState.Flat) {
7026 if (((state & ButtonState.Inactive) == ButtonState.Inactive) || ((state & ButtonState.Pushed) == ButtonState.Pushed))
7027 brush = ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (Clamp (ColorControl.R + 3, 0, 255), ColorControl.G, ColorControl.B), ColorControl);
7029 brush = SystemBrushes.ControlLightLight;
7031 if (((state & ButtonState.Inactive) == ButtonState.Inactive) || ((state & ButtonState.Pushed) == ButtonState.Pushed))
7032 brush = ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (Clamp (ColorControl.R + 3, 0, 255), ColorControl.G, ColorControl.B), ColorControl);
7034 brush = SystemBrushes.ControlLightLight;
7036 top_left_outer = cpcolor.Dark;
7037 top_left_inner = cpcolor.DarkDark;
7038 bottom_right_outer = cpcolor.Light;
7039 bottom_right_inner = Color.Transparent;
7041 if ((state & ButtonState.Inactive) == ButtonState.Inactive)
7042 dot_color = cpcolor.Dark;
7045 dc.FillEllipse (brush, rb_rect.X + 1, rb_rect.Y + 1, ellipse_diameter - 1, ellipse_diameter - 1);
7047 int line_width = Math.Max (1, (int)(ellipse_diameter * 0.08f));
7049 dc.DrawArc (ResPool.GetSizedPen (top_left_outer, line_width), rb_rect, 135.0f, 180.0f);
7050 dc.DrawArc (ResPool.GetSizedPen (top_left_inner, line_width), Rectangle.Inflate (rb_rect, -line_width, -line_width), 135.0f, 180.0f);
7051 dc.DrawArc (ResPool.GetSizedPen (bottom_right_outer, line_width), rb_rect, 315.0f, 180.0f);
7053 if (bottom_right_inner != Color.Transparent)
7054 dc.DrawArc (ResPool.GetSizedPen (bottom_right_inner, line_width), Rectangle.Inflate (rb_rect, -line_width, -line_width), 315.0f, 180.0f);
7056 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)) {
7057 dc.DrawArc (h_pen, Rectangle.Inflate (rb_rect, -line_width, -line_width), 315.0f, 180.0f);
7060 if ((state & ButtonState.Checked) == ButtonState.Checked) {
7061 int inflate = line_width * 4;
7062 Rectangle tmp = Rectangle.Inflate (rb_rect, -inflate, -inflate);
7063 if (rectangle.Height > 13) {
7067 dc.FillEllipse (ResPool.GetSolidBrush (dot_color), tmp);
7069 Pen pen = ResPool.GetPen (dot_color);
7070 dc.DrawLine (pen, tmp.X, tmp.Y + (tmp.Height / 2), tmp.Right, tmp.Y + (tmp.Height / 2));
7071 dc.DrawLine (pen, tmp.X, tmp.Y + (tmp.Height / 2) + 1, tmp.Right, tmp.Y + (tmp.Height / 2) + 1);
7073 dc.DrawLine (pen, tmp.X + (tmp.Width / 2), tmp.Y, tmp.X + (tmp.Width / 2), tmp.Bottom);
7074 dc.DrawLine (pen, tmp.X + (tmp.Width / 2) + 1, tmp.Y, tmp.X + (tmp.Width / 2) + 1, tmp.Bottom);
7079 public override void CPDrawReversibleFrame (Rectangle rectangle, Color backColor, FrameStyle style) {
7084 public override void CPDrawReversibleLine (Point start, Point end, Color backColor) {
7089 /* Scroll button: regular button + direction arrow */
7090 public override void CPDrawScrollButton (Graphics dc, Rectangle area, ScrollButton type, ButtonState state)
7092 DrawScrollButtonPrimitive (dc, area, state);
7094 bool fill_rect = true;
7097 if ((state & ButtonState.Pushed) != 0)
7101 Rectangle rect = new Rectangle (area.X + 2 + offset, area.Y + 2 + offset, area.Width - 4, area.Height - 4);
7103 Point [] arrow = new Point [3];
7104 for (int i = 0; i < 3; i++)
7105 arrow [i] = new Point ();
7107 Pen pen = SystemPens.ControlText;
7109 if ((state & ButtonState.Inactive) != 0) {
7110 pen = SystemPens.ControlDark;
7115 case ScrollButton.Down:
7116 int x_middle = (int)Math.Round (rect.Width / 2.0f) - 1;
7117 int y_middle = (int)Math.Round (rect.Height / 2.0f) - 1;
7121 int triangle_height;
7123 if (rect.Height < 8) {
7124 triangle_height = 2;
7126 } else if (rect.Height == 11) {
7127 triangle_height = 3;
7129 triangle_height = (int)Math.Round (rect.Height / 3.0f);
7132 arrow [0].X = rect.X + x_middle;
7133 arrow [0].Y = rect.Y + y_middle + triangle_height / 2;
7135 arrow [1].X = arrow [0].X + triangle_height - 1;
7136 arrow [1].Y = arrow [0].Y - triangle_height + 1;
7137 arrow [2].X = arrow [0].X - triangle_height + 1;
7138 arrow [2].Y = arrow [1].Y;
7140 dc.DrawPolygon (pen, arrow);
7142 if ((state & ButtonState.Inactive) != 0) {
7143 dc.DrawLine (SystemPens.ControlLightLight, arrow [1].X + 1, arrow [1].Y + 1, arrow [0].X + 1, arrow [0].Y + 1);
7144 dc.DrawLine (SystemPens.ControlLightLight, arrow [1].X, arrow [1].Y + 1, arrow [0].X + 1, arrow [0].Y);
7148 for (int i = 0; i < arrow [0].Y - arrow [1].Y; i++) {
7149 dc.DrawLine (pen, arrow [1].X, arrow [1].Y + i, arrow [2].X, arrow [1].Y + i);
7156 case ScrollButton.Up:
7157 x_middle = (int)Math.Round (rect.Width / 2.0f) - 1;
7158 y_middle = (int)Math.Round (rect.Height / 2.0f);
7165 if (rect.Height < 8) {
7166 triangle_height = 2;
7168 } else if (rect.Height == 11) {
7169 triangle_height = 3;
7171 triangle_height = (int)Math.Round (rect.Height / 3.0f);
7174 arrow [0].X = rect.X + x_middle;
7175 arrow [0].Y = rect.Y + y_middle - triangle_height / 2;
7177 arrow [1].X = arrow [0].X + triangle_height - 1;
7178 arrow [1].Y = arrow [0].Y + triangle_height - 1;
7179 arrow [2].X = arrow [0].X - triangle_height + 1;
7180 arrow [2].Y = arrow [1].Y;
7182 dc.DrawPolygon (pen, arrow);
7184 if ((state & ButtonState.Inactive) != 0) {
7185 dc.DrawLine (SystemPens.ControlLightLight, arrow [1].X + 1, arrow [1].Y + 1, arrow [2].X + 1, arrow [1].Y + 1);
7189 for (int i = 0; i < arrow [1].Y - arrow [0].Y; i++) {
7190 dc.DrawLine (pen, arrow [2].X, arrow [1].Y - i, arrow [1].X, arrow [1].Y - i);
7197 case ScrollButton.Left:
7198 y_middle = (int)Math.Round (rect.Height / 2.0f) - 1;
7204 if (rect.Width < 8) {
7207 } else if (rect.Width == 11) {
7210 triangle_width = (int)Math.Round (rect.Width / 3.0f);
7213 arrow [0].X = rect.Left + triangle_width - 1;
7214 arrow [0].Y = rect.Y + y_middle;
7216 if (arrow [0].X - 1 == rect.X)
7219 arrow [1].X = arrow [0].X + triangle_width - 1;
7220 arrow [1].Y = arrow [0].Y - triangle_width + 1;
7221 arrow [2].X = arrow [1].X;
7222 arrow [2].Y = arrow [0].Y + triangle_width - 1;
7224 dc.DrawPolygon (pen, arrow);
7226 if ((state & ButtonState.Inactive) != 0) {
7227 dc.DrawLine (SystemPens.ControlLightLight, arrow [1].X + 1, arrow [1].Y + 1, arrow [2].X + 1, arrow [2].Y + 1);
7231 for (int i = 0; i < arrow [2].X - arrow [0].X; i++) {
7232 dc.DrawLine (pen, arrow [2].X - i, arrow [1].Y, arrow [2].X - i, arrow [2].Y);
7239 case ScrollButton.Right:
7240 y_middle = (int)Math.Round (rect.Height / 2.0f) - 1;
7244 if (rect.Width < 8) {
7247 } else if (rect.Width == 11) {
7250 triangle_width = (int)Math.Round (rect.Width / 3.0f);
7253 arrow [0].X = rect.Right - triangle_width - 1;
7254 arrow [0].Y = rect.Y + y_middle;
7256 if (arrow [0].X - 1 == rect.X)
7259 arrow [1].X = arrow [0].X - triangle_width + 1;
7260 arrow [1].Y = arrow [0].Y - triangle_width + 1;
7261 arrow [2].X = arrow [1].X;
7262 arrow [2].Y = arrow [0].Y + triangle_width - 1;
7264 dc.DrawPolygon (pen, arrow);
7266 if ((state & ButtonState.Inactive) != 0) {
7267 dc.DrawLine (SystemPens.ControlLightLight, arrow [0].X + 1, arrow [0].Y + 1, arrow [2].X + 1, arrow [2].Y + 1);
7268 dc.DrawLine (SystemPens.ControlLightLight, arrow [0].X, arrow [0].Y + 1, arrow [2].X + 1, arrow [2].Y);
7272 for (int i = 0; i < arrow [0].X - arrow [1].X; i++) {
7273 dc.DrawLine (pen, arrow [2].X + i, arrow [1].Y, arrow [2].X + i, arrow [2].Y);
7282 public override void CPDrawSelectionFrame (Graphics graphics, bool active, Rectangle outsideRect, Rectangle insideRect,
7288 public override void CPDrawSizeGrip (Graphics dc, Color backColor, Rectangle bounds)
7290 Pen pen_dark = ResPool.GetPen(ControlPaint.Dark(backColor));
7291 Pen pen_light_light = ResPool.GetPen(ControlPaint.LightLight(backColor));
7293 for (int i = 2; i < bounds.Width - 2; i += 4) {
7294 dc.DrawLine (pen_light_light, bounds.X + i, bounds.Bottom - 2, bounds.Right - 1, bounds.Y + i - 1);
7295 dc.DrawLine (pen_dark, bounds.X + i + 1, bounds.Bottom - 2, bounds.Right - 1, bounds.Y + i);
7296 dc.DrawLine (pen_dark, bounds.X + i + 2, bounds.Bottom - 2, bounds.Right - 1, bounds.Y + i + 1);
7300 private void DrawStringDisabled20 (Graphics g, string s, Font font, Rectangle layoutRectangle, Color color, TextFormatFlags flags, bool useDrawString)
7302 CPColor cpcolor = ResPool.GetCPColor (color);
7304 layoutRectangle.Offset (1, 1);
7305 TextRenderer.DrawTextInternal (g, s, font, layoutRectangle, cpcolor.LightLight, flags, useDrawString);
7307 layoutRectangle.Offset (-1, -1);
7308 TextRenderer.DrawTextInternal (g, s, font, layoutRectangle, cpcolor.Dark, flags, useDrawString);
7311 public override void CPDrawStringDisabled (Graphics dc, string s, Font font, Color color, RectangleF layoutRectangle, StringFormat format)
7313 CPColor cpcolor = ResPool.GetCPColor (color);
7315 dc.DrawString (s, font, ResPool.GetSolidBrush(cpcolor.LightLight),
7316 new RectangleF(layoutRectangle.X + 1, layoutRectangle.Y + 1, layoutRectangle.Width, layoutRectangle.Height),
7318 dc.DrawString (s, font, ResPool.GetSolidBrush (cpcolor.Dark), layoutRectangle, format);
7322 public override void CPDrawStringDisabled (IDeviceContext dc, string s, Font font, Color color, Rectangle layoutRectangle, TextFormatFlags format)
7324 CPColor cpcolor = ResPool.GetCPColor (color);
7326 layoutRectangle.Offset (1, 1);
7327 TextRenderer.DrawText (dc, s, font, layoutRectangle, cpcolor.LightLight, format);
7329 layoutRectangle.Offset (-1, -1);
7330 TextRenderer.DrawText (dc, s, font, layoutRectangle, cpcolor.Dark, format);
7333 public override void CPDrawVisualStyleBorder (Graphics graphics, Rectangle bounds)
7335 graphics.DrawRectangle (SystemPens.ControlDarkDark, bounds);
7339 private static void DrawBorderInternal (Graphics graphics, int startX, int startY, int endX, int endY,
7340 int width, Color color, ButtonBorderStyle style, Border3DSide side)
7342 DrawBorderInternal (graphics, (float) startX, (float) startY, (float) endX, (float) endY,
7343 width, color, style, side);
7346 private static void DrawBorderInternal (Graphics graphics, float startX, float startY, float endX, float endY,
7347 int width, Color color, ButtonBorderStyle style, Border3DSide side) {
7352 case ButtonBorderStyle.Solid:
7353 case ButtonBorderStyle.Inset:
7354 case ButtonBorderStyle.Outset:
7355 pen = ThemeEngine.Current.ResPool.GetDashPen (color, DashStyle.Solid);
7357 case ButtonBorderStyle.Dashed:
7358 pen = ThemeEngine.Current.ResPool.GetDashPen (color, DashStyle.Dash);
7360 case ButtonBorderStyle.Dotted:
7361 pen = ThemeEngine.Current.ResPool.GetDashPen (color, DashStyle.Dot);
7364 case ButtonBorderStyle.None:
7369 case ButtonBorderStyle.Outset: {
7371 int hue, brightness, saturation;
7372 int brightnessSteps;
7373 int brightnessDownSteps;
7375 ControlPaint.Color2HBS(color, out hue, out brightness, out saturation);
7377 brightnessDownSteps=brightness/width;
7378 if (brightness>127) {
7379 brightnessSteps=Math.Max(6, (160-brightness)/width);
7381 brightnessSteps=(127-brightness)/width;
7384 for (int i=0; i<width; i++) {
7386 case Border3DSide.Left: {
7387 colorGrade=ControlPaint.HBS2Color(hue, Math.Min(255, brightness+brightnessSteps*(width-i)), saturation);
7388 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
7389 graphics.DrawLine(pen, startX+i, startY+i, endX+i, endY-i);
7393 case Border3DSide.Right: {
7394 colorGrade=ControlPaint.HBS2Color(hue, Math.Max(0, brightness-brightnessDownSteps*(width-i)), saturation);
7395 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
7396 graphics.DrawLine(pen, startX-i, startY+i, endX-i, endY-i);
7400 case Border3DSide.Top: {
7401 colorGrade=ControlPaint.HBS2Color(hue, Math.Min(255, brightness+brightnessSteps*(width-i)), saturation);
7402 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
7403 graphics.DrawLine(pen, startX+i, startY+i, endX-i, endY+i);
7407 case Border3DSide.Bottom: {
7408 colorGrade=ControlPaint.HBS2Color(hue, Math.Max(0, brightness-brightnessDownSteps*(width-i)), saturation);
7409 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
7410 graphics.DrawLine(pen, startX+i, startY-i, endX-i, endY-i);
7418 case ButtonBorderStyle.Inset: {
7420 int hue, brightness, saturation;
7421 int brightnessSteps;
7422 int brightnessDownSteps;
7424 ControlPaint.Color2HBS(color, out hue, out brightness, out saturation);
7426 brightnessDownSteps=brightness/width;
7427 if (brightness>127) {
7428 brightnessSteps=Math.Max(6, (160-brightness)/width);
7430 brightnessSteps=(127-brightness)/width;
7433 for (int i=0; i<width; i++) {
7435 case Border3DSide.Left: {
7436 colorGrade=ControlPaint.HBS2Color(hue, Math.Max(0, brightness-brightnessDownSteps*(width-i)), saturation);
7437 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
7438 graphics.DrawLine(pen, startX+i, startY+i, endX+i, endY-i);
7442 case Border3DSide.Right: {
7443 colorGrade=ControlPaint.HBS2Color(hue, Math.Min(255, brightness+brightnessSteps*(width-i)), saturation);
7444 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
7445 graphics.DrawLine(pen, startX-i, startY+i, endX-i, endY-i);
7449 case Border3DSide.Top: {
7450 colorGrade=ControlPaint.HBS2Color(hue, Math.Max(0, brightness-brightnessDownSteps*(width-i)), saturation);
7451 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
7452 graphics.DrawLine(pen, startX+i, startY+i, endX-i, endY+i);
7456 case Border3DSide.Bottom: {
7457 colorGrade=ControlPaint.HBS2Color(hue, Math.Min(255, brightness+brightnessSteps*(width-i)), saturation);
7458 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
7459 graphics.DrawLine(pen, startX+i, startY-i, endX-i, endY-i);
7468 I decided to have the for-loop duplicated for speed reasons;
7469 that way we only have to switch once (as opposed to have the
7470 for-loop around the switch)
7474 case Border3DSide.Left: {
7475 for (int i=0; i<width; i++) {
7476 graphics.DrawLine(pen, startX+i, startY+i, endX+i, endY-i);
7481 case Border3DSide.Right: {
7482 for (int i=0; i<width; i++) {
7483 graphics.DrawLine(pen, startX-i, startY+i, endX-i, endY-i);
7488 case Border3DSide.Top: {
7489 for (int i=0; i<width; i++) {
7490 graphics.DrawLine(pen, startX+i, startY+i, endX-i, endY+i);
7495 case Border3DSide.Bottom: {
7496 for (int i=0; i<width; i++) {
7497 graphics.DrawLine(pen, startX+i, startY-i, endX-i, endY-i);
7508 This function actually draws the various caption elements.
7509 This way we can scale them nicely, no matter what size, and they
7510 still look like MS's scaled caption buttons. (as opposed to scaling a bitmap)
7513 private void DrawCaptionHelper(Graphics graphics, Color color, Pen pen, int lineWidth, int shift, Rectangle captionRect, CaptionButton button) {
7515 case CaptionButton.Close: {
7517 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);
7518 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);
7521 graphics.DrawLine(pen, captionRect.Left+2*lineWidth+shift, captionRect.Top+2*lineWidth+shift, captionRect.Right-2*lineWidth+shift, captionRect.Bottom-2*lineWidth+shift);
7522 graphics.DrawLine(pen, captionRect.Right-2*lineWidth+shift, captionRect.Top+2*lineWidth+shift, captionRect.Left+2*lineWidth+shift, captionRect.Bottom-2*lineWidth+shift);
7526 case CaptionButton.Help: {
7527 StringFormat sf = new StringFormat();
7528 Font font = new Font("Microsoft Sans Serif", captionRect.Height, FontStyle.Bold, GraphicsUnit.Pixel);
7530 sf.Alignment=StringAlignment.Center;
7531 sf.LineAlignment=StringAlignment.Center;
7534 graphics.DrawString("?", font, ResPool.GetSolidBrush (color), captionRect.X+captionRect.Width/2+shift, captionRect.Y+captionRect.Height/2+shift+lineWidth/2, sf);
7542 case CaptionButton.Maximize: {
7543 /* Top 'caption bar' line */
7544 for (int i=0; i<Math.Max(2, lineWidth); i++) {
7545 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);
7548 /* Left side line */
7549 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
7550 graphics.DrawLine(pen, captionRect.Left+lineWidth+shift+i, captionRect.Top+2*lineWidth+shift, captionRect.Left+lineWidth+shift+i, captionRect.Bottom-lineWidth+shift);
7553 /* Right side line */
7554 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
7555 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);
7559 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
7560 graphics.DrawLine(pen, captionRect.Left+lineWidth+shift, captionRect.Bottom-lineWidth+shift-i, captionRect.Right-lineWidth-lineWidth/2+shift, captionRect.Bottom-lineWidth+shift-i);
7565 case CaptionButton.Minimize: {
7567 for (int i=0; i<Math.Max(2, lineWidth); i++) {
7568 graphics.DrawLine(pen, captionRect.Left+lineWidth+shift, captionRect.Bottom-lineWidth+shift-i, captionRect.Right-3*lineWidth+shift, captionRect.Bottom-lineWidth+shift-i);
7573 case CaptionButton.Restore: {
7574 /** First 'window' **/
7575 /* Top 'caption bar' line */
7576 for (int i=0; i<Math.Max(2, lineWidth); i++) {
7577 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);
7580 /* Left side line */
7581 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
7582 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);
7585 /* Right side line */
7586 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
7587 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);
7591 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
7592 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);
7595 /** Second 'window' **/
7596 /* Top 'caption bar' line */
7597 for (int i=0; i<Math.Max(2, lineWidth); i++) {
7598 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);
7601 /* Left side line */
7602 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
7603 graphics.DrawLine(pen, captionRect.Left+lineWidth+shift+i, captionRect.Top+4*lineWidth+shift+1, captionRect.Left+lineWidth+shift+i, captionRect.Bottom-lineWidth+shift);
7606 /* Right side line */
7607 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
7608 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);
7612 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
7613 graphics.DrawLine(pen, captionRect.Left+lineWidth+shift, captionRect.Bottom-lineWidth+shift-i, captionRect.Right-3*lineWidth-lineWidth/2+shift, captionRect.Bottom-lineWidth+shift-i);
7622 /* Generic scroll button */
7623 public void DrawScrollButtonPrimitive (Graphics dc, Rectangle area, ButtonState state) {
7624 if ((state & ButtonState.Pushed) == ButtonState.Pushed) {
7625 dc.FillRectangle (SystemBrushes.Control, area.X + 1,
7626 area.Y + 1, area.Width - 2 , area.Height - 2);
7628 dc.DrawRectangle (SystemPens.ControlDark, area.X,
7629 area.Y, area.Width, area.Height);
7634 Brush sb_control = SystemBrushes.Control;
7635 Brush sb_lightlight = SystemBrushes.ControlLightLight;
7636 Brush sb_dark = SystemBrushes.ControlDark;
7637 Brush sb_darkdark = SystemBrushes.ControlDarkDark;
7639 dc.FillRectangle (sb_control, area.X, area.Y, area.Width, 1);
7640 dc.FillRectangle (sb_control, area.X, area.Y, 1, area.Height);
7642 dc.FillRectangle (sb_lightlight, area.X + 1, area.Y + 1, area.Width - 1, 1);
7643 dc.FillRectangle (sb_lightlight, area.X + 1, area.Y + 2, 1,
7646 dc.FillRectangle (sb_dark, area.X + 1, area.Y + area.Height - 2,
7649 dc.FillRectangle (sb_darkdark, area.X, area.Y + area.Height -1,
7652 dc.FillRectangle (sb_dark, area.X + area.Width - 2,
7653 area.Y + 1, 1, area.Height -3);
7655 dc.FillRectangle (sb_darkdark, area.X + area.Width -1,
7656 area.Y, 1, area.Height - 1);
7658 dc.FillRectangle (sb_control, area.X + 2,
7659 area.Y + 2, area.Width - 4, area.Height - 4);
7663 public override void CPDrawBorderStyle (Graphics dc, Rectangle area, BorderStyle border_style) {
7664 switch (border_style){
7665 case BorderStyle.Fixed3D:
7666 dc.DrawLine (ResPool.GetPen (ColorControlDark), area.X, area.Y, area.X +area.Width, area.Y);
7667 dc.DrawLine (ResPool.GetPen (ColorControlDark), area.X, area.Y, area.X, area.Y + area.Height);
7668 dc.DrawLine (ResPool.GetPen (ColorControlLight), area.X , area.Y + area.Height - 1, area.X + area.Width ,
7669 area.Y + area.Height - 1);
7670 dc.DrawLine (ResPool.GetPen (ColorControlLight), area.X + area.Width -1 , area.Y, area.X + area.Width -1,
7671 area.Y + area.Height);
7673 dc.DrawLine (ResPool.GetPen (ColorActiveBorder), area.X + 1, area.Bottom - 2, area.Right - 2, area.Bottom - 2);
7674 dc.DrawLine (ResPool.GetPen (ColorActiveBorder), area.Right - 2, area.Top + 1, area.Right - 2, area.Bottom - 2);
7675 dc.DrawLine (ResPool.GetPen (ColorControlDarkDark), area.X + 1, area.Top + 1, area.X + 1, area.Bottom - 3);
7676 dc.DrawLine (ResPool.GetPen (ColorControlDarkDark), area.X + 1, area.Top + 1, area.Right - 3, area.Top + 1);
7678 case BorderStyle.FixedSingle:
7679 dc.DrawRectangle (ResPool.GetPen (ColorWindowFrame), area.X, area.Y, area.Width - 1, area.Height - 1);
7681 case BorderStyle.None:
7687 #endregion // ControlPaint