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;
32 using System.Drawing.Drawing2D;
33 using System.Drawing.Imaging;
34 using System.Drawing.Printing;
35 using System.Drawing.Text;
38 namespace System.Windows.Forms
41 internal class ThemeWin32Classic : Theme
43 public override Version Version {
45 return new Version(0, 1, 0, 0);
49 /* Hardcoded colour values not exposed in the API constants in all configurations */
50 protected static readonly Color arrow_color = Color.Black;
51 protected static readonly Color pen_ticks_color = Color.Black;
52 protected static readonly Color progressbarblock_color = Color.FromArgb (255, 0, 0, 128);
53 protected static StringFormat string_format_menu_text;
54 protected static StringFormat string_format_menu_shortcut;
55 protected static StringFormat string_format_menu_menubar_text;
56 static ImageAttributes imagedisabled_attributes = null;
57 const int SEPARATOR_HEIGHT = 5;
58 const int SM_CXBORDER = 1;
59 const int SM_CYBORDER = 1;
60 const int MENU_TAB_SPACE = 8; // Pixels added to the width of an item because of a tab
61 const int MENU_BAR_ITEMS_SPACE = 8; // Space between menu bar items
63 #region Principal Theme Methods
64 public ThemeWin32Classic ()
66 defaultWindowBackColor = this.ColorWindow;
67 defaultWindowForeColor = this.ColorControlText;
68 default_font = new Font (FontFamily.GenericSansSerif, 8f);
70 /* Menu string formats */
71 string_format_menu_text = new StringFormat ();
72 string_format_menu_text.LineAlignment = StringAlignment.Center;
73 string_format_menu_text.Alignment = StringAlignment.Near;
74 string_format_menu_text.HotkeyPrefix = HotkeyPrefix.Show;
76 string_format_menu_shortcut = new StringFormat ();
77 string_format_menu_shortcut.LineAlignment = StringAlignment.Center;
78 string_format_menu_shortcut.Alignment = StringAlignment.Far;
80 string_format_menu_menubar_text = new StringFormat ();
81 string_format_menu_menubar_text.LineAlignment = StringAlignment.Center;
82 string_format_menu_menubar_text.Alignment = StringAlignment.Center;
83 string_format_menu_menubar_text.HotkeyPrefix = HotkeyPrefix.Show;
84 always_draw_hotkeys = false;
87 public override void ResetDefaults() {
88 Console.WriteLine("NOT IMPLEMENTED: ResetDefault()");
89 //throw new NotImplementedException("Need to implement ResetDefaults() for Win32 theme");
92 public override bool DoubleBufferingSupported {
96 public override int HorizontalScrollBarHeight {
98 return XplatUI.HorizontalScrollBarHeight;
102 public override int VerticalScrollBarWidth {
104 return XplatUI.VerticalScrollBarWidth;
108 #endregion // Principal Theme Methods
110 #region Internal Methods
111 protected Brush GetControlBackBrush (Color c) {
112 if (c.ToArgb () == DefaultControlBackColor.ToArgb ())
113 return SystemBrushes.Control;
114 return ResPool.GetSolidBrush (c);
117 protected Brush GetControlForeBrush (Color c) {
118 if (c.ToArgb () == DefaultControlForeColor.ToArgb ())
119 return SystemBrushes.ControlText;
120 return ResPool.GetSolidBrush (c);
122 #endregion // Internal Methods
124 #region OwnerDraw Support
125 public override void DrawOwnerDrawBackground (DrawItemEventArgs e)
127 if ((e.State & DrawItemState.Selected) == DrawItemState.Selected) {
128 e.Graphics.FillRectangle (SystemBrushes.Highlight, e.Bounds);
132 e.Graphics.FillRectangle (ResPool.GetSolidBrush(e.BackColor), e.Bounds);
135 public override void DrawOwnerDrawFocusRectangle (DrawItemEventArgs e)
137 if (e.State == DrawItemState.Focus)
138 CPDrawFocusRectangle (e.Graphics, e.Bounds, e.ForeColor, e.BackColor);
140 #endregion // OwnerDraw Support
143 public override void DrawButtonBase(Graphics dc, Rectangle clip_area, ButtonBase button) {
145 // Fill the button with the correct color
146 bool is_ColorControl = button.BackColor.ToArgb () == ColorControl.ToArgb () ? true : false;
147 dc.FillRectangle (is_ColorControl ? SystemBrushes.Control : ResPool.GetSolidBrush (button.BackColor), button.ClientRectangle);
149 // First, draw the image
150 if ((button.image != null) || (button.image_list != null))
151 ButtonBase_DrawImage(button, dc);
153 // Draw the button: Draw border, etc.
154 ButtonBase_DrawButton(button, dc);
156 // Draw the focus rectangle
157 if ((button.Focused || button.paint_as_acceptbutton) && button.Enabled)
158 ButtonBase_DrawFocus(button, dc);
161 if (button.text != null && button.text != String.Empty)
162 ButtonBase_DrawText(button, dc);
165 protected virtual void ButtonBase_DrawButton (ButtonBase button, Graphics dc)
167 Rectangle borderRectangle;
168 bool check_or_radio = false;
169 bool check_or_radio_checked = false;
171 bool is_ColorControl = button.BackColor.ToArgb () == ColorControl.ToArgb () ? true : false;
173 CPColor cpcolor = is_ColorControl ? CPColor.Empty : ResPool.GetCPColor (button.BackColor);
175 if (button is CheckBox) {
176 check_or_radio = true;
177 check_or_radio_checked = ((CheckBox)button).Checked;
178 } else if (button is RadioButton) {
179 check_or_radio = true;
180 check_or_radio_checked = ((RadioButton)button).Checked;
183 if ((button.Focused || button.paint_as_acceptbutton) && button.Enabled && !check_or_radio) {
184 // shrink the rectangle for the normal button drawing inside the focus rectangle
185 borderRectangle = Rectangle.Inflate (button.ClientRectangle, -1, -1);
187 borderRectangle = button.ClientRectangle;
190 if (button.FlatStyle == FlatStyle.Popup) {
191 if (!button.is_pressed && !button.is_entered && !check_or_radio_checked)
192 Internal_DrawButton (dc, borderRectangle, 1, cpcolor, is_ColorControl, button.BackColor);
193 else if (!button.is_pressed && button.is_entered &&!check_or_radio_checked)
194 Internal_DrawButton (dc, borderRectangle, 2, cpcolor, is_ColorControl, button.BackColor);
195 else if (button.is_pressed || check_or_radio_checked)
196 Internal_DrawButton (dc, borderRectangle, 1, cpcolor, is_ColorControl, button.BackColor);
197 } else if (button.FlatStyle == FlatStyle.Flat) {
198 if (button.is_entered && !button.is_pressed && !check_or_radio_checked) {
199 if ((button.image == null) && (button.image_list == null)) {
200 Brush brush = is_ColorControl ? SystemBrushes.ControlDark : ResPool.GetSolidBrush (cpcolor.Dark);
201 dc.FillRectangle (brush, borderRectangle);
203 } else if (button.is_pressed || check_or_radio_checked) {
204 if ((button.image == null) && (button.image_list == null)) {
205 Brush brush = is_ColorControl ? SystemBrushes.ControlLightLight : ResPool.GetSolidBrush (cpcolor.LightLight);
206 dc.FillRectangle (brush, borderRectangle);
209 Pen pen = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
210 dc.DrawRectangle (pen, borderRectangle.X + 4, borderRectangle.Y + 4,
211 borderRectangle.Width - 9, borderRectangle.Height - 9);
214 Internal_DrawButton (dc, borderRectangle, 3, cpcolor, is_ColorControl, button.BackColor);
216 if ((!button.is_pressed || !button.Enabled) && !check_or_radio_checked)
217 Internal_DrawButton (dc, borderRectangle, 0, cpcolor, is_ColorControl, button.BackColor);
219 Internal_DrawButton (dc, borderRectangle, 1, cpcolor, is_ColorControl, button.BackColor);
223 private void Internal_DrawButton (Graphics dc, Rectangle rect, int state, CPColor cpcolor, bool is_ColorControl, Color backcolor)
226 case 0: // normal or normal disabled button
227 Pen pen = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
228 dc.DrawLine (pen, rect.X, rect.Y, rect.X, rect.Bottom - 2);
229 dc.DrawLine (pen, rect.X + 1, rect.Y, rect.Right - 2, rect.Y);
231 pen = is_ColorControl ? SystemPens.Control : ResPool.GetPen (backcolor);
232 dc.DrawLine (pen, rect.X + 1, rect.Y + 1, rect.X + 1, rect.Bottom - 3);
233 dc.DrawLine (pen, rect.X + 2, rect.Y + 1, rect.Right - 3, rect.Y + 1);
235 pen = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
236 dc.DrawLine (pen, rect.X + 1, rect.Bottom - 2, rect.Right - 2, rect.Bottom - 2);
237 dc.DrawLine (pen, rect.Right - 2, rect.Y + 1, rect.Right - 2, rect.Bottom - 3);
239 pen = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
240 dc.DrawLine (pen, rect.X, rect.Bottom - 1, rect.Right - 1, rect.Bottom - 1);
241 dc.DrawLine (pen, rect.Right - 1, rect.Y, rect.Right - 1, rect.Bottom - 2);
243 case 1: // popup button normal (or pressed normal or popup button)
244 pen = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
245 dc.DrawRectangle (pen, rect.X, rect.Y, rect.Width - 1, rect.Height - 1);
247 case 2: // popup button poped up
248 pen = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
249 dc.DrawLine (pen, rect.X, rect.Y, rect.X, rect.Bottom - 2);
250 dc.DrawLine (pen, rect.X + 1, rect.Y, rect.Right - 2, rect.Y);
252 pen = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
253 dc.DrawLine (pen, rect.X, rect.Bottom - 1, rect.Right - 1, rect.Bottom - 1);
254 dc.DrawLine (pen, rect.Right - 1, rect.Y, rect.Right - 1, rect.Bottom - 2);
256 case 3: // flat button not entered
257 pen = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
258 dc.DrawRectangle (pen, rect.X, rect.Y, rect.Width - 1, rect.Height - 1);
265 protected virtual void ButtonBase_DrawImage(ButtonBase button, Graphics dc)
267 // Need to draw a picture
274 int width = button.ClientSize.Width;
275 int height = button.ClientSize.Height;
277 if (button.ImageIndex != -1) { // We use ImageIndex instead of image_index since it will return -1 if image_list is null
278 i = button.image_list.Images[button.image_index];
283 image_width = i.Width;
284 image_height = i.Height;
286 switch (button.image_alignment) {
287 case ContentAlignment.TopLeft: {
293 case ContentAlignment.TopCenter: {
294 image_x = (width - image_width) / 2;
299 case ContentAlignment.TopRight: {
300 image_x = width - image_width - 5;
305 case ContentAlignment.MiddleLeft: {
307 image_y = (height - image_height) / 2;
311 case ContentAlignment.MiddleCenter: {
312 image_x = (width - image_width) / 2;
313 image_y = (height - image_height) / 2;
317 case ContentAlignment.MiddleRight: {
318 image_x = width - image_width - 4;
319 image_y = (height - image_height) / 2;
323 case ContentAlignment.BottomLeft: {
325 image_y = height - image_height - 4;
329 case ContentAlignment.BottomCenter: {
330 image_x = (width - image_width) / 2;
331 image_y = height - image_height - 4;
335 case ContentAlignment.BottomRight: {
336 image_x = width - image_width - 4;
337 image_y = height - image_height - 4;
348 if (button.Enabled) {
349 dc.DrawImage(i, image_x, image_y);
352 CPDrawImageDisabled(dc, i, image_x, image_y, ColorControl);
356 protected virtual void ButtonBase_DrawFocus(ButtonBase button, Graphics dc)
358 Color focus_color = button.ForeColor;
360 int inflate_value = -3;
362 if (!(button is CheckBox) && !(button is RadioButton)) {
365 if (button.FlatStyle == FlatStyle.Popup && !button.is_pressed)
366 focus_color = ControlPaint.Dark(button.BackColor);
368 dc.DrawRectangle (ResPool.GetPen (focus_color), button.ClientRectangle.X, button.ClientRectangle.Y,
369 button.ClientRectangle.Width - 1, button.ClientRectangle.Height - 1);
372 if (button.Focused) {
373 Rectangle rect = Rectangle.Inflate (button.ClientRectangle, inflate_value, inflate_value);
374 ControlPaint.DrawFocusRectangle (dc, rect);
378 protected virtual void ButtonBase_DrawText(ButtonBase button, Graphics dc)
380 Rectangle buttonRectangle = button.ClientRectangle;
381 Rectangle text_rect = Rectangle.Inflate(buttonRectangle, -4, -4);
383 if (button.is_pressed) {
388 if (button.Enabled) {
389 dc.DrawString(button.text, button.Font, ResPool.GetSolidBrush (button.ForeColor), text_rect, button.text_format);
391 if (button.FlatStyle == FlatStyle.Flat || button.FlatStyle == FlatStyle.Popup) {
392 dc.DrawString(button.text, button.Font, ResPool.GetSolidBrush (ColorGrayText), text_rect, button.text_format);
394 CPDrawStringDisabled (dc, button.text, button.Font, button.BackColor, text_rect, button.text_format);
399 public override Size ButtonBaseDefaultSize {
401 return new Size (75, 23);
404 #endregion // ButtonBase
407 public override void DrawCheckBox(Graphics dc, Rectangle clip_area, CheckBox checkbox) {
408 StringFormat text_format;
409 Rectangle client_rectangle;
410 Rectangle text_rectangle;
411 Rectangle checkbox_rectangle;
412 int checkmark_size=13;
413 int checkmark_space = 4;
415 client_rectangle = checkbox.ClientRectangle;
416 text_rectangle = client_rectangle;
417 checkbox_rectangle = new Rectangle(text_rectangle.X, text_rectangle.Y, checkmark_size, checkmark_size);
419 text_format = new StringFormat();
420 text_format.Alignment=StringAlignment.Near;
421 text_format.LineAlignment=StringAlignment.Center;
422 text_format.HotkeyPrefix = HotkeyPrefix.Show;
424 /* Calculate the position of text and checkbox rectangle */
425 if (checkbox.appearance!=Appearance.Button) {
426 switch(checkbox.check_alignment) {
427 case ContentAlignment.BottomCenter: {
428 checkbox_rectangle.X=(client_rectangle.Right-client_rectangle.Left)/2-checkmark_size/2;
429 checkbox_rectangle.Y=client_rectangle.Bottom-checkmark_size;
430 text_rectangle.X=client_rectangle.X;
431 text_rectangle.Width=client_rectangle.Width;
432 text_rectangle.Height=client_rectangle.Height-checkbox_rectangle.Y-checkmark_space;
436 case ContentAlignment.BottomLeft: {
437 checkbox_rectangle.X=client_rectangle.Left;
438 checkbox_rectangle.Y=client_rectangle.Bottom-checkmark_size;
439 text_rectangle.X=client_rectangle.X+checkmark_size+checkmark_space;
440 text_rectangle.Width=client_rectangle.Width-checkmark_size-checkmark_space;
444 case ContentAlignment.BottomRight: {
445 checkbox_rectangle.X=client_rectangle.Right-checkmark_size;
446 checkbox_rectangle.Y=client_rectangle.Bottom-checkmark_size;
447 text_rectangle.X=client_rectangle.X;
448 text_rectangle.Width=client_rectangle.Width-checkmark_size-checkmark_space;
452 case ContentAlignment.MiddleCenter: {
453 checkbox_rectangle.X=(client_rectangle.Right-client_rectangle.Left)/2-checkmark_size/2;
454 checkbox_rectangle.Y=(client_rectangle.Bottom-client_rectangle.Top)/2-checkmark_size/2;
455 text_rectangle.X=client_rectangle.X;
456 text_rectangle.Width=client_rectangle.Width;
461 case ContentAlignment.MiddleLeft: {
462 checkbox_rectangle.X=client_rectangle.Left;
463 checkbox_rectangle.Y=(client_rectangle.Bottom-client_rectangle.Top)/2-checkmark_size/2;
464 text_rectangle.X=client_rectangle.X+checkmark_size+checkmark_space;
465 text_rectangle.Width=client_rectangle.Width-checkmark_size-checkmark_space;
469 case ContentAlignment.MiddleRight: {
470 checkbox_rectangle.X=client_rectangle.Right-checkmark_size;
471 checkbox_rectangle.Y=(client_rectangle.Bottom-client_rectangle.Top)/2-checkmark_size/2;
472 text_rectangle.X=client_rectangle.X;
473 text_rectangle.Width=client_rectangle.Width-checkmark_size-checkmark_space;
477 case ContentAlignment.TopCenter: {
478 checkbox_rectangle.X=(client_rectangle.Right-client_rectangle.Left)/2-checkmark_size/2;
479 checkbox_rectangle.Y=client_rectangle.Top;
480 text_rectangle.X=client_rectangle.X;
481 text_rectangle.Width=client_rectangle.Width;
482 text_rectangle.Y=checkmark_size+checkmark_space;
483 text_rectangle.Height=client_rectangle.Height-checkmark_size-checkmark_space;
487 case ContentAlignment.TopLeft: {
488 checkbox_rectangle.X=client_rectangle.Left;
489 text_rectangle.X=client_rectangle.X+checkmark_size+checkmark_space;
490 text_rectangle.Width=client_rectangle.Width-checkmark_size-checkmark_space;
494 case ContentAlignment.TopRight: {
495 checkbox_rectangle.X=client_rectangle.Right-checkmark_size;
496 text_rectangle.X=client_rectangle.X;
497 text_rectangle.Width=client_rectangle.Width-checkmark_size-checkmark_space;
502 text_rectangle.X=client_rectangle.X;
503 text_rectangle.Width=client_rectangle.Width;
506 /* Set the horizontal alignment of our text */
507 switch(checkbox.text_alignment) {
508 case ContentAlignment.BottomLeft:
509 case ContentAlignment.MiddleLeft:
510 case ContentAlignment.TopLeft: {
511 text_format.Alignment=StringAlignment.Near;
515 case ContentAlignment.BottomCenter:
516 case ContentAlignment.MiddleCenter:
517 case ContentAlignment.TopCenter: {
518 text_format.Alignment=StringAlignment.Center;
522 case ContentAlignment.BottomRight:
523 case ContentAlignment.MiddleRight:
524 case ContentAlignment.TopRight: {
525 text_format.Alignment=StringAlignment.Far;
530 /* Set the vertical alignment of our text */
531 switch(checkbox.text_alignment) {
532 case ContentAlignment.TopLeft:
533 case ContentAlignment.TopCenter:
534 case ContentAlignment.TopRight: {
535 text_format.LineAlignment=StringAlignment.Near;
539 case ContentAlignment.BottomLeft:
540 case ContentAlignment.BottomCenter:
541 case ContentAlignment.BottomRight: {
542 text_format.LineAlignment=StringAlignment.Far;
546 case ContentAlignment.MiddleLeft:
547 case ContentAlignment.MiddleCenter:
548 case ContentAlignment.MiddleRight: {
549 text_format.LineAlignment=StringAlignment.Center;
554 ButtonState state = ButtonState.Normal;
555 if (checkbox.FlatStyle == FlatStyle.Flat) {
556 state |= ButtonState.Flat;
559 if (checkbox.Checked) {
560 state |= ButtonState.Checked;
563 if (checkbox.ThreeState && (checkbox.CheckState == CheckState.Indeterminate)) {
564 state |= ButtonState.Checked;
565 state |= ButtonState.Pushed;
568 // finally make sure the pushed and inavtive states are rendered
569 if (!checkbox.Enabled) {
570 state |= ButtonState.Inactive;
572 else if (checkbox.is_pressed) {
573 state |= ButtonState.Pushed;
578 CheckBox_DrawCheckBox(dc, checkbox, state, checkbox_rectangle);
580 if ((checkbox.image != null) || (checkbox.image_list != null))
581 ButtonBase_DrawImage(checkbox, dc);
583 CheckBox_DrawText(checkbox, text_rectangle, dc, text_format);
585 CheckBox_DrawFocus(checkbox, dc, text_rectangle);
587 text_format.Dispose ();
590 protected virtual void CheckBox_DrawCheckBox( Graphics dc, CheckBox checkbox, ButtonState state, Rectangle checkbox_rectangle )
592 Brush brush = checkbox.BackColor.ToArgb () == ColorControl.ToArgb () ? SystemBrushes.Control : ResPool.GetSolidBrush (checkbox.BackColor);
593 dc.FillRectangle (brush, checkbox.ClientRectangle);
594 // render as per normal button
595 if (checkbox.appearance==Appearance.Button) {
596 ButtonBase_DrawButton (checkbox, dc);
598 if ((checkbox.Focused) && checkbox.Enabled)
599 ButtonBase_DrawFocus(checkbox, dc);
601 // establish if we are rendering a flat style of some sort
602 if (checkbox.FlatStyle == FlatStyle.Flat || checkbox.FlatStyle == FlatStyle.Popup) {
603 DrawFlatStyleCheckBox (dc, checkbox_rectangle, checkbox);
605 CPDrawCheckBox (dc, checkbox_rectangle, state);
610 protected virtual void CheckBox_DrawText( CheckBox checkbox, Rectangle text_rectangle, Graphics dc, StringFormat text_format )
612 DrawCheckBox_and_RadioButtonText (checkbox, text_rectangle, dc,
613 text_format, checkbox.Appearance, checkbox.Checked);
616 protected virtual void CheckBox_DrawFocus( CheckBox checkbox, Graphics dc, Rectangle text_rectangle )
618 if ( checkbox.Focused && checkbox.appearance != Appearance.Button && checkbox.Enabled )
619 DrawInnerFocusRectangle( dc, text_rectangle, checkbox.BackColor );
622 // renders a checkBox with the Flat and Popup FlatStyle
623 protected virtual void DrawFlatStyleCheckBox (Graphics graphics, Rectangle rectangle, CheckBox checkbox)
627 Rectangle checkbox_rectangle;
628 Rectangle fill_rectangle;
632 // set up our rectangles first
633 if (checkbox.FlatStyle == FlatStyle.Popup && checkbox.is_entered) {
634 // clip one pixel from bottom right for non popup rendered checkboxes
635 checkbox_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max(rectangle.Width-1, 0), Math.Max(rectangle.Height-1,0));
636 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));
638 // clip two pixels from bottom right for non popup rendered checkboxes
639 checkbox_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max(rectangle.Width-2, 0), Math.Max(rectangle.Height-2,0));
640 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));
644 // if disabled render in disabled state
645 if (checkbox.Enabled) {
646 // process the state of the checkbox
647 if (checkbox.is_entered || checkbox.Capture) {
648 // decide on which background color to use
649 if (checkbox.FlatStyle == FlatStyle.Popup && checkbox.is_entered && checkbox.Capture) {
650 graphics.FillRectangle(ResPool.GetSolidBrush (checkbox.BackColor), fill_rectangle);
651 } else if (checkbox.FlatStyle == FlatStyle.Flat) {
652 if (!checkbox.is_pressed) {
653 graphics.FillRectangle(ResPool.GetSolidBrush (checkbox.BackColor), fill_rectangle);
655 graphics.FillRectangle(ResPool.GetSolidBrush (ControlPaint.LightLight (checkbox.BackColor)), fill_rectangle);
657 // use regular window background color
658 graphics.FillRectangle(ResPool.GetSolidBrush (ControlPaint.LightLight (checkbox.BackColor)), fill_rectangle);
661 // render the outer border
662 if (checkbox.FlatStyle == FlatStyle.Flat) {
663 ControlPaint.DrawBorder(graphics, checkbox_rectangle, checkbox.ForeColor, ButtonBorderStyle.Solid);
665 // draw sunken effect
666 CPDrawBorder3D (graphics, checkbox_rectangle, Border3DStyle.SunkenInner, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, checkbox.BackColor);
669 graphics.FillRectangle(ResPool.GetSolidBrush (ControlPaint.LightLight (checkbox.BackColor)), fill_rectangle);
671 if (checkbox.FlatStyle == FlatStyle.Flat) {
672 ControlPaint.DrawBorder(graphics, checkbox_rectangle, checkbox.ForeColor, ButtonBorderStyle.Solid);
674 // draw the outer border
675 ControlPaint.DrawBorder(graphics, checkbox_rectangle, ControlPaint.DarkDark (checkbox.BackColor), ButtonBorderStyle.Solid);
679 if (checkbox.FlatStyle == FlatStyle.Popup) {
680 graphics.FillRectangle(SystemBrushes.Control, fill_rectangle);
683 // draw disabled state,
684 ControlPaint.DrawBorder(graphics, checkbox_rectangle, ColorControlDark, ButtonBorderStyle.Solid);
687 if (checkbox.Checked) {
688 /* Need to draw a check-mark */
690 /* Make sure we've got at least a line width of 1 */
691 lineWidth = Math.Max(3, fill_rectangle.Width/3);
692 Scale=Math.Max(1, fill_rectangle.Width/9);
694 // flat style check box is rendered inside a rectangle shifted down by one
695 rect=new Rectangle(fill_rectangle.X, fill_rectangle.Y+1, fill_rectangle.Width, fill_rectangle.Height);
696 if (checkbox.Enabled) {
697 pen=ResPool.GetPen(checkbox.ForeColor);
699 pen=SystemPens.ControlDark;
702 for (int i=0; i<lineWidth; i++) {
703 graphics.DrawLine(pen, rect.Left+lineWidth/2, rect.Top+lineWidth+i, rect.Left+lineWidth/2+2*Scale, rect.Top+lineWidth+2*Scale+i);
704 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);
709 private void DrawCheckBox_and_RadioButtonText (ButtonBase button_base, Rectangle text_rectangle, Graphics dc,
710 StringFormat text_format, Appearance appearance, bool ischecked)
712 // offset the text if it's pressed and a button
713 if (appearance == Appearance.Button) {
714 if (ischecked || (button_base.Capture && button_base.FlatStyle != FlatStyle.Flat)) {
719 text_rectangle.Inflate (-4, -4);
722 /* Place the text; to be compatible with Windows place it after the checkbox has been drawn */
724 // Windows seems to not wrap text in certain situations, this matches as close as I could get it
725 if ((float)(button_base.Font.Height * 1.5f) > text_rectangle.Height) {
726 text_format.FormatFlags |= StringFormatFlags.NoWrap;
728 if (button_base.Enabled) {
729 dc.DrawString (button_base.Text, button_base.Font, ResPool.GetSolidBrush (button_base.ForeColor), text_rectangle, text_format);
730 } else if (button_base.FlatStyle == FlatStyle.Flat || button_base.FlatStyle == FlatStyle.Popup) {
731 dc.DrawString (button_base.Text, button_base.Font, SystemBrushes.ControlDarkDark, text_rectangle, text_format);
733 CPDrawStringDisabled (dc, button_base.Text, button_base.Font, button_base.BackColor, text_rectangle, text_format);
736 #endregion // CheckBox
738 #region CheckedListBox
740 public override void DrawCheckedListBoxItem (CheckedListBox ctrl, DrawItemEventArgs e)
742 Color back_color, fore_color;
743 Rectangle item_rect = e.Bounds;
748 if ((e.State & DrawItemState.Checked) == DrawItemState.Checked) {
749 state = ButtonState.Checked;
750 if ((e.State & DrawItemState.Inactive) == DrawItemState.Inactive)
751 state |= ButtonState.Inactive;
753 state = ButtonState.Normal;
755 if (ctrl.ThreeDCheckBoxes == false)
756 state |= ButtonState.Flat;
758 Rectangle checkbox_rect = new Rectangle (2, (item_rect.Height - 11) / 2, 11, 11);
759 ControlPaint.DrawCheckBox (e.Graphics,
760 item_rect.X + checkbox_rect.X, item_rect.Y + checkbox_rect.Y,
761 checkbox_rect.Width, checkbox_rect.Height,
764 item_rect.X += checkbox_rect.Width + checkbox_rect.X * 2;
765 item_rect.Width -= checkbox_rect.Width + checkbox_rect.X * 2;
768 if ((e.State & DrawItemState.Selected) == DrawItemState.Selected) {
769 back_color = ColorHighlight;
770 fore_color = ColorHighlightText;
773 back_color = e.BackColor;
774 fore_color = e.ForeColor;
777 e.Graphics.FillRectangle (ResPool.GetSolidBrush
778 (back_color), item_rect);
780 e.Graphics.DrawString (ctrl.GetItemText (ctrl.Items[e.Index]), e.Font,
781 ResPool.GetSolidBrush (fore_color),
782 item_rect, ctrl.StringFormat);
784 if ((e.State & DrawItemState.Focus) == DrawItemState.Focus) {
785 CPDrawFocusRectangle (e.Graphics, item_rect,
786 fore_color, back_color);
790 #endregion // CheckedListBox
793 public override void DrawComboBoxItem (ComboBox ctrl, DrawItemEventArgs e)
795 Color back_color, fore_color;
796 Rectangle text_draw = e.Bounds;
797 StringFormat string_format = new StringFormat ();
798 string_format.FormatFlags = StringFormatFlags.LineLimit;
800 if ((e.State & DrawItemState.Selected) == DrawItemState.Selected) {
801 back_color = ColorHighlight;
802 fore_color = ColorHighlightText;
805 back_color = e.BackColor;
806 fore_color = e.ForeColor;
810 fore_color = ColorInactiveCaptionText;
812 e.Graphics.FillRectangle (ResPool.GetSolidBrush (back_color), e.Bounds);
815 e.Graphics.DrawString (ctrl.GetItemText (ctrl.Items[e.Index]), e.Font,
816 ResPool.GetSolidBrush (fore_color),
817 text_draw, string_format);
820 if ((e.State & DrawItemState.Focus) == DrawItemState.Focus) {
821 CPDrawFocusRectangle (e.Graphics, e.Bounds, fore_color, back_color);
824 string_format.Dispose ();
829 public override int DataGridPreferredColumnWidth { get { return 75;} }
830 public override int DataGridMinimumColumnCheckBoxHeight { get { return 16;} }
831 public override int DataGridMinimumColumnCheckBoxWidth { get { return 16;} }
832 public override Color DataGridAlternatingBackColor { get { return ColorWindow;} }
833 public override Color DataGridBackColor { get { return ColorWindow;} }
834 public override Color DataGridBackgroundColor { get { return ColorAppWorkspace;} }
835 public override Color DataGridCaptionBackColor { get { return ColorActiveCaption;} }
836 public override Color DataGridCaptionForeColor { get { return ColorActiveCaptionText;} }
837 public override Color DataGridGridLineColor { get { return ColorControl;} }
838 public override Color DataGridHeaderBackColor { get { return ColorControl;} }
839 public override Color DataGridHeaderForeColor { get { return ColorControlText;} }
840 public override Color DataGridLinkColor { get { return ColorHotTrack;} }
841 public override Color DataGridLinkHoverColor { get { return ColorHotTrack;} }
842 public override Color DataGridParentRowsBackColor { get { return ColorControl;} }
843 public override Color DataGridParentRowsForeColor { get { return ColorWindowText;} }
844 public override Color DataGridSelectionBackColor { get { return ColorActiveCaption;} }
845 public override Color DataGridSelectionForeColor { get { return ColorActiveCaptionText;} }
847 public override void DataGridPaint (PaintEventArgs pe, DataGrid grid)
849 DataGridPaintCaption (pe.Graphics, pe.ClipRectangle, grid);
850 DataGridPaintParentRows (pe.Graphics, pe.ClipRectangle, grid);
851 DataGridPaintColumnHeaders (pe.Graphics, pe.ClipRectangle, grid);
852 DataGridPaintRows (pe.Graphics, grid.cells_area, pe.ClipRectangle, grid);
854 // Paint scrollBar corner
855 if (grid.VScrollBar.Visible && grid.HScrollBar.Visible) {
857 Rectangle corner = new Rectangle (grid.ClientRectangle.X + grid.ClientRectangle.Width - grid.VScrollBar.Width,
858 grid.ClientRectangle.Y + grid.ClientRectangle.Height - grid.HScrollBar.Height,
859 grid.VScrollBar.Width, grid.HScrollBar.Height);
861 if (pe.ClipRectangle.IntersectsWith (corner)) {
862 pe.Graphics.FillRectangle (ResPool.GetSolidBrush (grid.ParentRowsBackColor),
868 public override void DataGridPaintCaption (Graphics g, Rectangle clip, DataGrid grid)
870 Rectangle modified_area = clip;
871 modified_area.Intersect (grid.caption_area);
873 g.FillRectangle (ResPool.GetSolidBrush (grid.CaptionBackColor),
876 g.DrawString (grid.CaptionText, grid.CaptionFont,
877 ResPool.GetSolidBrush (grid.CaptionForeColor),
880 if (modified_area.IntersectsWith (grid.back_button_rect)) {
881 g.DrawImage (grid.back_button_image, grid.back_button_rect);
882 if (grid.back_button_mouseover) {
883 CPDrawBorder3D (g, grid.back_button_rect, grid.back_button_active ? Border3DStyle.Sunken : Border3DStyle.Raised, all_sides);
886 if (modified_area.IntersectsWith (grid.parent_rows_button_rect)) {
887 g.DrawImage (grid.parent_rows_button_image, grid.parent_rows_button_rect);
888 if (grid.parent_rows_button_mouseover) {
889 CPDrawBorder3D (g, grid.parent_rows_button_rect, grid.parent_rows_button_active ? Border3DStyle.Sunken : Border3DStyle.Raised, all_sides);
894 public override void DataGridPaintColumnHeaders (Graphics g, Rectangle clip, DataGrid grid)
896 Rectangle columns_area = grid.columnhdrs_area;
898 if (grid.CurrentTableStyle.CurrentRowHeadersVisible) { // Paint corner shared between row and column header
899 Rectangle rect_bloc = grid.columnhdrs_area;
900 rect_bloc.Width = grid.RowHeaderWidth;
901 if (clip.IntersectsWith (rect_bloc)) {
902 if (grid.VisibleColumnCount > 0)
903 g.FillRectangle (ResPool.GetSolidBrush (grid.CurrentTableStyle.CurrentHeaderBackColor), rect_bloc);
905 g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor), rect_bloc);
908 columns_area.X += grid.RowHeaderWidth;
909 columns_area.Width -= grid.RowHeaderWidth;
913 Rectangle columnhdrs_area_complete = columns_area;
914 columnhdrs_area_complete.Width = grid.columnhdrs_maxwidth;
916 if (grid.CurrentTableStyle.CurrentRowHeadersVisible) {
917 columnhdrs_area_complete.Width -= grid.RowHeaderWidth;
920 // Set column painting
921 Rectangle rect_columnhdr = new Rectangle ();
924 Region prev_clip = g.Clip;
925 rect_columnhdr.Y = columns_area.Y;
926 rect_columnhdr.Height = columns_area.Height;
928 int column_cnt = grid.FirstVisibleColumn + grid.VisibleColumnCount;
929 for (int column = grid.FirstVisibleColumn; column < column_cnt; column++) {
930 if (grid.CurrentTableStyle.GridColumnStyles[column].bound == false)
933 col_pixel = grid.GetColumnStartingPixel (column);
934 rect_columnhdr.X = columns_area.X + col_pixel - grid.HorizPixelOffset;
935 rect_columnhdr.Width = grid.CurrentTableStyle.GridColumnStyles[column].Width;
937 if (clip.IntersectsWith (rect_columnhdr) == false)
940 current_clip = new Region (rect_columnhdr);
941 current_clip.Intersect (columns_area);
942 current_clip.Intersect (prev_clip);
943 g.Clip = current_clip;
945 grid.CurrentTableStyle.GridColumnStyles[column].PaintHeader (g, rect_columnhdr, column);
947 current_clip.Dispose ();
952 Rectangle not_usedarea = columnhdrs_area_complete;
953 not_usedarea.X = rect_columnhdr.X + rect_columnhdr.Width;
954 not_usedarea.Width = grid.ClientRectangle.X + grid.ClientRectangle.Width - rect_columnhdr.X - rect_columnhdr.Height;
955 g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor), not_usedarea);
959 public override void DataGridPaintParentRows (Graphics g, Rectangle clip, DataGrid grid)
961 Rectangle rect_row = new Rectangle ();
963 rect_row.X = grid.ParentRowsArea.X;
964 rect_row.Width = grid.ParentRowsArea.Width;
965 rect_row.Height = (grid.CaptionFont.Height + 3);
967 object[] parentRows = grid.dataSourceStack.ToArray();
970 Region prev_clip = g.Clip;
971 for (int row = 0; row < parentRows.Length; row++) {
972 rect_row.Y = grid.ParentRowsArea.Y + row * rect_row.Height;
974 if (clip.IntersectsWith (rect_row) == false)
977 current_clip = new Region (rect_row);
978 current_clip.Intersect (prev_clip);
979 g.Clip = current_clip;
981 DataGridPaintParentRow (g, rect_row, (DataGridDataSource)parentRows[parentRows.Length - row - 1], grid);
983 current_clip.Dispose ();
989 public override void DataGridPaintParentRow (Graphics g, Rectangle bounds, DataGridDataSource row, DataGrid grid)
991 //Console.WriteLine ("drawing parent row {0}", row);
994 g.FillRectangle (ResPool.GetSolidBrush (grid.ParentRowsBackColor),
997 Font bold_font = new Font (grid.Font.FontFamily, grid.Font.Size, grid.Font.Style | FontStyle.Bold);
998 // set up some standard string formating variables
999 StringFormat text_format = new StringFormat();
1000 text_format.LineAlignment = StringAlignment.Center;
1001 text_format.Alignment = StringAlignment.Near;
1003 string table_name = ((ITypedList)row.view.DataView).GetListName (null) + ": ";
1005 Rectangle text_rect;
1008 text_size = g.MeasureString (table_name, bold_font).ToSize();
1009 text_rect = new Rectangle(new Point(bounds.X + 3, bounds.Y + bounds.Height - text_size.Height), text_size);
1011 //Console.WriteLine ("drawing text at {0}", text_rect);
1013 g.DrawString (table_name,
1014 bold_font, ResPool.GetSolidBrush (grid.ParentRowsForeColor), text_rect, text_format);
1016 foreach (PropertyDescriptor pd in ((ICustomTypeDescriptor)row.view).GetProperties()) {
1017 if (typeof(IBindingList).IsAssignableFrom (pd.PropertyType))
1020 text_rect.X += text_rect.Size.Width + 5;
1022 string text = String.Format ("{0}: {1}",
1024 pd.GetValue (row.view));
1026 text_rect.Size = g.MeasureString (text, grid.Font).ToSize();
1027 text_rect.Y = bounds.Y + bounds.Height - text_rect.Height; // XXX
1029 //Console.WriteLine ("drawing text at {0}", text_rect);
1032 grid.Font, ResPool.GetSolidBrush (grid.ParentRowsForeColor), text_rect, text_format);
1035 if (grid.FlatMode == false) {
1038 g.DrawLine (ResPool.GetPen (ColorControlLight),
1039 bounds.X, bounds.Y, bounds.X + bounds.Width, bounds.Y);
1041 g.DrawLine (ResPool.GetPen (ColorControlLight),
1042 bounds.X, bounds.Y + 1, bounds.X, bounds.Y + bounds.Height - 1);
1044 g.DrawLine (ResPool.GetPen (ColorControlDark),
1045 bounds.X + bounds.Width - 1, bounds.Y + 1 , bounds.X + bounds.Width - 1, bounds.Y + bounds.Height - 1);
1047 g.DrawLine (ResPool.GetPen (ColorControlDark),
1048 bounds.X, bounds.Y + bounds.Height -1, bounds.X + bounds.Width, bounds.Y + bounds.Height -1);
1052 public override void DataGridPaintRowHeaderArrow (Graphics g, Rectangle bounds, DataGrid grid)
1054 Point[] arrow = new Point[3];
1056 int centerX, centerY, shiftX;
1059 rect = new Rectangle (bounds.X + bounds.Width /4,
1060 bounds.Y + bounds.Height/4, bounds.Width / 2, bounds.Height / 2);
1062 centerX = rect.Left + rect.Width / 2;
1063 centerY = rect.Top + rect.Height / 2;
1064 shiftX = Math.Max (1, rect.Width / 8);
1067 P1 = new Point (centerX, rect.Top - 1);
1068 P2 = new Point (centerX, rect.Bottom);
1069 P3 = new Point (rect.Right, centerY);
1074 g.FillPolygon (ResPool.GetSolidBrush
1075 (grid.CurrentTableStyle.CurrentHeaderForeColor), arrow, FillMode.Winding);
1078 public override void DataGridPaintRowHeader (Graphics g, Rectangle bounds, int row, DataGrid grid)
1080 bool is_add_row = grid.ShowEditRow && row == grid.DataGridRows.Length - 1;
1081 bool is_current_row = row == grid.CurrentCell.RowNumber;
1084 g.FillRectangle (ResPool.GetSolidBrush (grid.CurrentTableStyle.CurrentHeaderBackColor),
1088 if (is_current_row) {
1089 if (grid.IsChanging) {
1090 g.DrawString ("...", grid.Font,
1091 ResPool.GetSolidBrush (grid.CurrentTableStyle.CurrentHeaderForeColor),
1094 Rectangle rect = new Rectangle (bounds.X - 2, bounds.Y, 18, 18);
1095 DataGridPaintRowHeaderArrow (g, rect, grid);
1098 else if (is_add_row) {
1099 g.DrawString ("*", grid.Font, ResPool.GetSolidBrush (grid.CurrentTableStyle.CurrentHeaderForeColor),
1103 if (grid.FlatMode == false && !is_add_row) {
1105 g.DrawLine (ResPool.GetPen (ColorControlLight),
1106 bounds.X, bounds.Y, bounds.X + bounds.Width, bounds.Y);
1108 g.DrawLine (ResPool.GetPen (ColorControlLight),
1109 bounds.X, bounds.Y + 1, bounds.X, bounds.Y + bounds.Height - 1);
1111 g.DrawLine (ResPool.GetPen (ColorControlDark),
1112 bounds.X + bounds.Width - 1, bounds.Y + 1 , bounds.X + bounds.Width - 1, bounds.Y + bounds.Height - 1);
1114 g.DrawLine (ResPool.GetPen (ColorControlDark),
1115 bounds.X, bounds.Y + bounds.Height -1, bounds.X + bounds.Width, bounds.Y + bounds.Height -1);
1119 public override void DataGridPaintRows (Graphics g, Rectangle cells, Rectangle clip, DataGrid grid)
1121 Rectangle rect_row = new Rectangle ();
1122 Rectangle not_usedarea = new Rectangle ();
1124 int rowcnt = grid.VisibleRowCount;
1126 bool showing_add_row = false;
1128 if (grid.RowsCount < grid.DataGridRows.Length) {
1129 /* the table has an add row */
1131 if (grid.FirstVisibleRow + grid.VisibleRowCount >= grid.DataGridRows.Length) {
1132 showing_add_row = true;
1136 rect_row.Width = cells.Width + grid.RowHeadersArea.Width;
1137 for (int r = 0; r < rowcnt; r++) {
1138 int row = grid.FirstVisibleRow + r;
1139 if (row == grid.DataGridRows.Length - 1)
1140 rect_row.Height = grid.DataGridRows[row].Height;
1142 rect_row.Height = grid.DataGridRows[row + 1].VerticalOffset - grid.DataGridRows[row].VerticalOffset;
1143 rect_row.Y = cells.Y + grid.DataGridRows[row].VerticalOffset - grid.DataGridRows[grid.FirstVisibleRow].VerticalOffset;
1144 if (clip.IntersectsWith (rect_row)) {
1145 if (grid.CurrentTableStyle.HasRelations
1146 && !(showing_add_row && row == grid.DataGridRows.Length - 1))
1147 DataGridPaintRelationRow (g, row, rect_row, false, clip, grid);
1149 DataGridPaintRow (g, row, rect_row, showing_add_row && row == grid.DataGridRows.Length - 1, clip, grid);
1153 // XXX this should be moved elsewhere and turned into 1 g.FillRectangle call, not grid.DataGridRows.Length separate calls
1154 not_usedarea.Height = cells.Y + cells.Height - rect_row.Y - rect_row.Height;
1155 not_usedarea.Y = rect_row.Y + rect_row.Height;
1156 not_usedarea.Width = cells.Width + grid.RowHeadersArea.Width;
1159 g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor), not_usedarea);
1162 public override void DataGridPaintRelationRow (Graphics g, int row, Rectangle row_rect, bool is_newrow,
1163 Rectangle clip, DataGrid grid)
1165 Rectangle rect_header;
1166 Rectangle icon_bounds = new Rectangle ();
1167 Pen pen = ThemeEngine.Current.ResPool.GetPen (grid.CurrentTableStyle.ForeColor);
1169 /* paint the header if it's visible and intersects the clip */
1170 if (grid.CurrentTableStyle.CurrentRowHeadersVisible) {
1171 rect_header = row_rect;
1172 rect_header.Width = grid.RowHeaderWidth;
1173 row_rect.X += grid.RowHeaderWidth;
1174 if (clip.IntersectsWith (rect_header)) {
1175 DataGridPaintRowHeader (g, rect_header, row, grid);
1178 icon_bounds = rect_header;
1179 icon_bounds.X += icon_bounds.Width / 2;
1181 icon_bounds.Width = 8;
1182 icon_bounds.Height = 8;
1184 g.DrawRectangle (pen, icon_bounds);
1186 /* the - part of the icon */
1188 icon_bounds.X + 2, icon_bounds.Y + icon_bounds.Height / 2,
1189 icon_bounds.X + icon_bounds.Width - 2, icon_bounds.Y + icon_bounds.Height / 2);
1191 if (!grid.IsExpanded (row)) {
1192 /* the | part of the icon */
1194 icon_bounds.X + icon_bounds.Width / 2, icon_bounds.Y + 2,
1195 icon_bounds.X + icon_bounds.Width / 2, icon_bounds.Y + icon_bounds.Height - 2);
1199 Rectangle nested_rect = row_rect;
1201 if (grid.DataGridRows[row].IsExpanded)
1202 nested_rect.Height -= grid.DataGridRows[row].RelationHeight;
1204 DataGridPaintRowContents (g, row, nested_rect, is_newrow, clip, grid);
1206 if (grid.DataGridRows[row].IsExpanded) {
1207 // XXX we should create this in the
1208 // datagrid and cache it for use by
1209 // the theme instead of doing it each
1210 // time through here
1211 string[] relations = grid.CurrentTableStyle.Relations;
1212 StringBuilder relation_builder = new StringBuilder ("");
1214 for (int i = 0; i < relations.Length; i ++) {
1216 relation_builder.Append ("\n");
1218 relation_builder.Append (relations[i]);
1220 string relation_text = relation_builder.ToString ();
1222 StringFormat string_format = new StringFormat ();
1223 string_format.FormatFlags |= StringFormatFlags.NoWrap;
1226 //Region prev_clip = g.Clip;
1227 //Region current_clip;
1228 Rectangle rect_cell = row_rect;
1230 rect_cell.X = row_rect.X + grid.GetColumnStartingPixel (grid.FirstVisibleColumn) - grid.HorizPixelOffset;
1231 rect_cell.Y += nested_rect.Height;
1232 rect_cell.Height = grid.DataGridRows[row].RelationHeight;
1233 rect_cell.Width = 0;
1235 int column_cnt = grid.FirstVisibleColumn + grid.VisibleColumnCount;
1236 for (int column = grid.FirstVisibleColumn; column < column_cnt; column++) {
1237 if (grid.CurrentTableStyle.GridColumnStyles[column].bound == false)
1239 rect_cell.Width += grid.CurrentTableStyle.GridColumnStyles[column].Width;
1242 g.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (grid.CurrentTableStyle.BackColor),
1246 /* draw the line leading from the +/- to the relation area */
1247 Rectangle outline = grid.DataGridRows[row].relation_area;
1248 outline.Y = rect_cell.Y;
1252 icon_bounds.X + icon_bounds.Width / 2, icon_bounds.Y + icon_bounds.Height,
1253 icon_bounds.X + icon_bounds.Width / 2, outline.Y + outline.Height / 2);
1256 icon_bounds.X + icon_bounds.Width / 2, outline.Y + outline.Height / 2,
1257 outline.X, outline.Y + outline.Height / 2);
1259 g.DrawRectangle (pen, outline);
1261 g.DrawString (relation_text, grid.LinkFont, ResPool.GetSolidBrush (grid.LinkColor),
1262 outline, string_format);
1264 if (row_rect.X + row_rect.Width > rect_cell.X + rect_cell.Width) {
1265 Rectangle not_usedarea = new Rectangle ();
1266 not_usedarea.X = rect_cell.X + rect_cell.Width;
1267 not_usedarea.Width = row_rect.X + row_rect.Width - rect_cell.X - rect_cell.Width;
1268 not_usedarea.Y = row_rect.Y;
1269 not_usedarea.Height = row_rect.Height;
1270 if (clip.IntersectsWith (not_usedarea))
1271 g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor),
1277 public override void DataGridPaintRowContents (Graphics g, int row, Rectangle row_rect, bool is_newrow,
1278 Rectangle clip, DataGrid grid)
1280 Rectangle rect_cell = new Rectangle ();
1282 Color backcolor, forecolor;
1283 Brush backBrush, foreBrush;
1284 Rectangle not_usedarea = new Rectangle ();
1286 rect_cell.Y = row_rect.Y;
1287 rect_cell.Height = row_rect.Height;
1289 if (grid.IsSelected (row)) {
1290 backcolor = grid.SelectionBackColor;
1291 forecolor = grid.SelectionForeColor;
1294 backcolor = grid.BackColor;
1296 backcolor = grid.AlternatingBackColor;
1299 forecolor = grid.ForeColor;
1303 backBrush = ResPool.GetSolidBrush (backcolor);
1304 foreBrush = ResPool.GetSolidBrush (forecolor);
1306 // PaintCells at row, column
1307 int column_cnt = grid.FirstVisibleColumn + grid.VisibleColumnCount;
1309 Region prev_clip = g.Clip;
1310 Region current_clip;
1312 for (int column = grid.FirstVisibleColumn; column < column_cnt; column++) {
1313 if (grid.CurrentTableStyle.GridColumnStyles[column].bound == false)
1316 col_pixel = grid.GetColumnStartingPixel (column);
1318 rect_cell.X = row_rect.X + col_pixel - grid.HorizPixelOffset;
1319 rect_cell.Width = grid.CurrentTableStyle.GridColumnStyles[column].Width;
1321 if (clip.IntersectsWith (rect_cell)) {
1322 current_clip = new Region (rect_cell);
1323 current_clip.Intersect (row_rect);
1324 current_clip.Intersect (prev_clip);
1325 g.Clip = current_clip;
1328 grid.CurrentTableStyle.GridColumnStyles[column].PaintNewRow (g, rect_cell,
1332 grid.CurrentTableStyle.GridColumnStyles[column].Paint (g, rect_cell, grid.ListManager, row,
1335 grid.RightToLeft == RightToLeft.Yes);
1338 current_clip.Dispose ();
1344 if (row_rect.X + row_rect.Width > rect_cell.X + rect_cell.Width) {
1345 not_usedarea.X = rect_cell.X + rect_cell.Width;
1346 not_usedarea.Width = row_rect.X + row_rect.Width - rect_cell.X - rect_cell.Width;
1347 not_usedarea.Y = row_rect.Y;
1348 not_usedarea.Height = row_rect.Height;
1349 if (clip.IntersectsWith (not_usedarea))
1350 g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor),
1355 public override void DataGridPaintRow (Graphics g, int row, Rectangle row_rect, bool is_newrow,
1356 Rectangle clip, DataGrid grid)
1358 /* paint the header if it's visible and intersects the clip */
1359 if (grid.CurrentTableStyle.CurrentRowHeadersVisible) {
1360 Rectangle rect_header = row_rect;
1361 rect_header.Width = grid.RowHeaderWidth;
1362 row_rect.X += grid.RowHeaderWidth;
1363 if (clip.IntersectsWith (rect_header)) {
1364 DataGridPaintRowHeader (g, rect_header, row, grid);
1368 DataGridPaintRowContents (g, row, row_rect, is_newrow, clip, grid);
1371 #endregion // Datagrid
1373 #region DateTimePicker
1375 public override void DrawDateTimePicker (Graphics dc, Rectangle clip_rectangle, DateTimePicker dtp) {
1376 // if not showing the numeric updown control then render border
1377 if (!dtp.ShowUpDown && clip_rectangle.IntersectsWith (dtp.ClientRectangle)) {
1378 // draw the outer border
1379 Rectangle button_bounds = dtp.ClientRectangle;
1380 this.CPDrawBorder3D (dc, button_bounds, Border3DStyle.Sunken, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, dtp.BackColor);
1382 // deflate by the border width
1383 if (clip_rectangle.IntersectsWith (dtp.drop_down_arrow_rect)) {
1384 button_bounds.Inflate (-2,-2);
1385 ButtonState state = dtp.is_drop_down_visible ? ButtonState.Pushed : ButtonState.Normal;
1386 this.CPDrawComboButton (
1388 dtp.drop_down_arrow_rect,
1393 // render the date part
1394 if (clip_rectangle.IntersectsWith (dtp.date_area_rect)) {
1395 // fill the background
1396 dc.FillRectangle (SystemBrushes.Window, dtp.date_area_rect);
1398 // fill the currently highlighted area
1399 if (dtp.hilight_date_area != Rectangle.Empty) {
1400 dc.FillRectangle (SystemBrushes.Highlight, dtp.hilight_date_area);
1403 // Update date_area_rect if we are drawing the checkbox
1404 Rectangle date_area_rect = dtp.date_area_rect;
1405 if (dtp.ShowCheckBox) {
1406 Rectangle check_box_rect = dtp.CheckBoxRect;
1407 date_area_rect.X = date_area_rect.X + check_box_rect.Width + DateTimePicker.check_box_space*2;
1408 date_area_rect.Width = date_area_rect.Width - check_box_rect.Width - DateTimePicker.check_box_space*2;
1410 ButtonState bs = dtp.Checked ? ButtonState.Checked : ButtonState.Normal;
1411 CPDrawCheckBox (dc, check_box_rect, bs);
1414 // draw the text part
1415 // TODO: if date format is CUstom then we need to draw the dates as separate parts
1416 StringFormat text_format = new StringFormat();
1417 text_format.LineAlignment = StringAlignment.Center;
1418 text_format.Alignment = StringAlignment.Near;
1419 Brush text_brush = ResPool.GetSolidBrush (dtp.ShowCheckBox && dtp.Checked == false ?
1420 SystemColors.GrayText : dtp.ForeColor); // Use GrayText if Checked is false
1421 dc.DrawString (dtp.Text, dtp.Font, text_brush, Rectangle.Inflate (date_area_rect, -1, -1), text_format);
1422 text_format.Dispose ();
1426 #endregion // DateTimePicker
1429 public override void DrawGroupBox (Graphics dc, Rectangle area, GroupBox box) {
1430 StringFormat text_format;
1435 dc.FillRectangle (GetControlBackBrush (box.BackColor), box.ClientRectangle);
1437 text_format = new StringFormat();
1438 text_format.HotkeyPrefix = HotkeyPrefix.Show;
1440 size = dc.MeasureString (box.Text, box.Font);
1441 width = ((int) size.Width) + 7;
1443 if (width > box.Width - 16)
1444 width = box.Width - 16;
1446 y = box.Font.Height / 2;
1448 // Clip the are that the text will be in
1449 Region prev_clip = dc.Clip;
1450 dc.SetClip (new Rectangle (10, 0, width, box.Font.Height), CombineMode.Exclude);
1452 CPDrawBorder3D (dc, new Rectangle (0, y, box.Width, box.Height - y), Border3DStyle.Etched, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, box.BackColor);
1453 dc.Clip = prev_clip;
1456 if (box.Text.Length != 0) {
1458 dc.DrawString (box.Text, box.Font, ResPool.GetSolidBrush (box.ForeColor), 10, 0, text_format);
1460 CPDrawStringDisabled (dc, box.Text, box.Font, box.BackColor,
1461 new RectangleF (10, 0, width, box.Font.Height), text_format);
1465 text_format.Dispose ();
1468 public override Size GroupBoxDefaultSize {
1470 return new Size (200,100);
1476 public override Size HScrollBarDefaultSize {
1478 return new Size (80, this.ScrollBarButtonSize);
1482 #endregion // HScrollBar
1485 public override void DrawLabel (Graphics dc, Rectangle clip_rectangle, Label label)
1487 dc.FillRectangle (GetControlBackBrush (label.BackColor), clip_rectangle);
1489 if (label.Enabled) {
1490 dc.DrawString (label.Text, label.Font, ResPool.GetSolidBrush (label.ForeColor), clip_rectangle, label.string_format);
1492 ControlPaint.DrawStringDisabled (dc, label.Text, label.Font, label.BackColor, clip_rectangle, label.string_format);
1497 public override Size LabelDefaultSize {
1499 return new Size (100, 23);
1505 public override void DrawLinkLabel (Graphics dc, Rectangle clip_rectangle, LinkLabel label)
1507 dc.FillRectangle (GetControlBackBrush (label.BackColor), clip_rectangle);
1509 if (label.pieces == null)
1512 for (int i = 0; i < label.pieces.Length; i ++) {
1513 RectangleF clipf = new RectangleF (clip_rectangle.X, clip_rectangle.Y,
1514 clip_rectangle.Width, clip_rectangle.Height);
1515 RectangleF rectf = label.pieces[i].region.GetBounds (dc);
1517 if (!clipf.IntersectsWith (rectf))
1520 dc.DrawString (label.pieces[i].text, label.GetPieceFont (label.pieces[i]), ResPool.GetSolidBrush (label.GetPieceColor (label.pieces[i], i)),
1521 rectf, label.string_format);
1523 LinkLabel.Link link = label.pieces[i].link;
1524 if (link != null && link.Focused) {
1525 Rectangle rect = new Rectangle ((int)rectf.X, (int)rectf.Y,
1526 (int)rectf.Width, (int)rectf.Height);
1527 CPDrawFocusRectangle (dc, rect, label.ForeColor, label.BackColor);
1531 #endregion // LinkLabel
1534 public override void DrawListBoxItem (ListBox ctrl, DrawItemEventArgs e)
1536 Color back_color, fore_color;
1538 if ((e.State & DrawItemState.Selected) == DrawItemState.Selected) {
1539 back_color = ColorHighlight;
1540 fore_color = ColorHighlightText;
1542 back_color = e.BackColor;
1543 fore_color = e.ForeColor;
1546 e.Graphics.FillRectangle (ResPool.GetSolidBrush (back_color), e.Bounds);
1548 e.Graphics.DrawString (ctrl.GetItemText (ctrl.Items[e.Index]), e.Font,
1549 ResPool.GetSolidBrush (fore_color),
1550 e.Bounds.X, e.Bounds.Y, ctrl.StringFormat);
1552 if ((e.State & DrawItemState.Focus) == DrawItemState.Focus)
1553 CPDrawFocusRectangle (e.Graphics, e.Bounds, fore_color, back_color);
1560 public override void DrawListViewItems (Graphics dc, Rectangle clip, ListView control)
1562 bool details = control.View == View.Details;
1564 if (control.Enabled)
1565 dc.FillRectangle (GetControlBackBrush (control.BackColor), clip);
1567 dc.FillRectangle (ResPool.GetSolidBrush (ColorControl), clip);
1569 int first = control.FirstVisibleIndex;
1571 for (int i = first; i <= control.LastVisibleIndex; i ++) {
1572 if (clip.IntersectsWith (control.Items[i].GetBounds (ItemBoundsPortion.Entire)))
1573 DrawListViewItem (dc, control, control.Items [i]);
1576 // draw the gridlines
1577 if (details && control.GridLines) {
1578 int top = (control.HeaderStyle == ColumnHeaderStyle.None) ?
1579 2 : control.Font.Height + 2;
1581 // draw vertical gridlines
1582 foreach (ColumnHeader col in control.Columns)
1583 dc.DrawLine (SystemPens.Control,
1584 col.Rect.Right, top,
1585 col.Rect.Right, control.TotalHeight);
1586 // draw horizontal gridlines
1587 ListViewItem last_item = null;
1588 foreach (ListViewItem item in control.Items) {
1589 dc.DrawLine (SystemPens.Control,
1590 item.GetBounds (ItemBoundsPortion.Entire).Left, item.GetBounds (ItemBoundsPortion.Entire).Top,
1591 control.TotalWidth, item.GetBounds (ItemBoundsPortion.Entire).Top);
1595 // draw a line after at the bottom of the last item
1596 if (last_item != null) {
1597 dc.DrawLine (SystemPens.Control,
1598 last_item.GetBounds (ItemBoundsPortion.Entire).Left,
1599 last_item.GetBounds (ItemBoundsPortion.Entire).Bottom,
1601 last_item.GetBounds (ItemBoundsPortion.Entire).Bottom);
1605 // Draw corner between the two scrollbars
1606 if (control.h_scroll.Visible == true && control.h_scroll.Visible == true) {
1607 Rectangle rect = new Rectangle ();
1608 rect.X = control.h_scroll.Location.X + control.h_scroll.Width;
1609 rect.Width = control.v_scroll.Width;
1610 rect.Y = control.v_scroll.Location.Y + control.v_scroll.Height;
1611 rect.Height = control.h_scroll.Height;
1612 dc.FillRectangle (SystemBrushes.Control, rect);
1615 Rectangle box_select_rect = control.item_control.BoxSelectRectangle;
1616 if (!box_select_rect.Size.IsEmpty)
1617 dc.DrawRectangle (ResPool.GetDashPen (ColorControlText, DashStyle.Dot), box_select_rect);
1621 public override void DrawListViewHeader (Graphics dc, Rectangle clip, ListView control)
1623 bool details = (control.View == View.Details);
1625 // border is drawn directly in the Paint method
1626 if (details && control.HeaderStyle != ColumnHeaderStyle.None) {
1627 dc.FillRectangle (GetControlBackBrush (control.BackColor),
1628 0, 0, control.TotalWidth, control.Font.Height + 5);
1629 if (control.Columns.Count > 0) {
1630 foreach (ColumnHeader col in control.Columns) {
1631 Rectangle rect = col.Rect;
1632 rect.X -= control.h_marker;
1634 if (control.HeaderStyle == ColumnHeaderStyle.Clickable)
1635 state = col.Pressed ? ButtonState.Pushed : ButtonState.Normal;
1637 state = ButtonState.Flat;
1638 this.CPDrawButton (dc, rect, state);
1641 if (rect.Width <= 0)
1643 dc.DrawString (col.Text, DefaultFont,
1644 SystemBrushes.ControlText,
1647 int right = control.Columns [control.Columns.Count - 1].Rect.Right - control.h_marker;
1648 if (right < control.Right) {
1649 Rectangle rect = control.Columns [0].Rect;
1651 rect.Width = control.Right - right;
1653 if (control.HeaderStyle == ColumnHeaderStyle.Clickable)
1654 state = ButtonState.Normal;
1656 state = ButtonState.Flat;
1657 CPDrawButton (dc, rect, state);
1663 public override void DrawListViewHeaderDragDetails (Graphics dc, ListView view, ColumnHeader col, int target_x)
1665 Rectangle rect = col.Rect;
1666 rect.X -= view.h_marker;
1667 Color color = Color.FromArgb (0x7f, ColorControlDark.R, ColorControlDark.G, ColorControlDark.B);
1668 dc.FillRectangle (ResPool.GetSolidBrush (color), rect);
1671 if (rect.Width <= 0)
1673 color = Color.FromArgb (0x7f, ColorControlText.R, ColorControlText.G, ColorControlText.B);
1674 dc.DrawString (col.Text, DefaultFont, ResPool.GetSolidBrush (color), rect, col.Format);
1675 dc.DrawLine (ResPool.GetSizedPen (ColorHighlight, 2), target_x, 0, target_x, col.Rect.Height);
1678 protected virtual void DrawListViewItem (Graphics dc, ListView control, ListViewItem item)
1681 if (control.View == View.Details && control.Columns.Count > 0)
1682 col_offset = control.Columns [0].Rect.X;
1686 Rectangle rect_checkrect = item.CheckRectReal;
1687 rect_checkrect.X += col_offset;
1688 Rectangle icon_rect = item.GetBounds (ItemBoundsPortion.Icon);
1689 icon_rect.X += col_offset;
1690 Rectangle full_rect = item.GetBounds (ItemBoundsPortion.Entire);
1691 full_rect.X += col_offset;
1692 Rectangle text_rect = item.GetBounds (ItemBoundsPortion.Label);
1693 text_rect.X += col_offset;
1695 if (control.CheckBoxes) {
1696 if (control.StateImageList == null) {
1697 // Make sure we've got at least a line width of 1
1698 int check_wd = Math.Max (3, rect_checkrect.Width / 6);
1699 int scale = Math.Max (1, rect_checkrect.Width / 12);
1701 // set the checkbox background
1702 dc.FillRectangle (SystemBrushes.Window,
1704 // define a rectangle inside the border area
1705 Rectangle rect = new Rectangle (rect_checkrect.X + 2,
1706 rect_checkrect.Y + 2,
1707 rect_checkrect.Width - 4,
1708 rect_checkrect.Height - 4);
1709 Pen pen = ResPool.GetSizedPen (this.ColorWindowText, 2);
1710 dc.DrawRectangle (pen, rect);
1712 // Need to draw a check-mark
1714 Pen check_pen = ResPool.GetSizedPen (this.ColorWindowText, 1);
1715 // adjustments to get the check-mark at the right place
1716 rect.X ++; rect.Y ++;
1717 // following logic is taken from DrawFrameControl method
1718 for (int i = 0; i < check_wd; i++) {
1719 dc.DrawLine (check_pen, rect.Left + check_wd / 2,
1720 rect.Top + check_wd + i,
1721 rect.Left + check_wd / 2 + 2 * scale,
1722 rect.Top + check_wd + 2 * scale + i);
1723 dc.DrawLine (check_pen,
1724 rect.Left + check_wd / 2 + 2 * scale,
1725 rect.Top + check_wd + 2 * scale + i,
1726 rect.Left + check_wd / 2 + 6 * scale,
1727 rect.Top + check_wd - 2 * scale + i);
1732 if (item.Checked && control.StateImageList.Images.Count > 1)
1733 control.StateImageList.Draw (dc,
1734 rect_checkrect.Location, 1);
1735 else if (! item.Checked && control.StateImageList.Images.Count > 0)
1736 control.StateImageList.Draw (dc,
1737 rect_checkrect.Location, 0);
1741 if (control.View == View.LargeIcon) {
1742 if (item.ImageIndex > -1 && control.LargeImageList != null &&
1743 item.ImageIndex < control.LargeImageList.Images.Count)
1744 control.LargeImageList.Draw (dc, icon_rect.Location, item.ImageIndex);
1746 if (item.ImageIndex > -1 && control.SmallImageList != null &&
1747 item.ImageIndex < control.SmallImageList.Images.Count)
1748 control.SmallImageList.Draw (dc, icon_rect.Location, item.ImageIndex);
1751 // draw the item text
1752 // format for the item text
1753 StringFormat format = new StringFormat ();
1754 if (control.View == View.SmallIcon)
1755 format.LineAlignment = StringAlignment.Near;
1757 format.LineAlignment = StringAlignment.Center;
1758 if (control.View == View.LargeIcon)
1759 format.Alignment = StringAlignment.Center;
1761 format.Alignment = StringAlignment.Near;
1763 if (!control.LabelWrap)
1764 format.FormatFlags = StringFormatFlags.NoWrap;
1766 Rectangle highlight_rect = text_rect;
1767 if (control.View == View.Details && !control.FullRowSelect) {
1768 Size text_size = Size.Ceiling (dc.MeasureString (item.Text, item.Font));
1769 highlight_rect.Width = text_size.Width + 4;
1772 if (item.Selected && control.Focused)
1773 dc.FillRectangle (SystemBrushes.Highlight, highlight_rect);
1774 else if (item.Selected && !control.HideSelection)
1775 dc.FillRectangle (SystemBrushes.Control, highlight_rect);
1777 dc.FillRectangle (ResPool.GetSolidBrush (item.BackColor), text_rect);
1780 !control.Enabled ? SystemBrushes.ControlLight :
1781 (item.Selected && control.Focused) ? SystemBrushes.HighlightText :
1782 this.ResPool.GetSolidBrush (item.ForeColor);
1784 if (item.Text != null && item.Text.Length > 0) {
1785 if (item.Selected && control.Focused)
1786 dc.DrawString (item.Text, item.Font, textBrush, highlight_rect, format);
1788 dc.DrawString (item.Text, item.Font, textBrush, text_rect, format);
1791 if (control.View == View.Details && control.Columns.Count > 0) {
1792 // draw subitems for details view
1793 ListViewItem.ListViewSubItemCollection subItems = item.SubItems;
1794 int count = (control.Columns.Count < subItems.Count ?
1795 control.Columns.Count : subItems.Count);
1799 ListViewItem.ListViewSubItem subItem;
1800 Rectangle sub_item_rect = text_rect;
1802 // set the format for subitems
1803 format.FormatFlags = StringFormatFlags.NoWrap;
1805 // 0th subitem is the item already drawn
1806 for (int index = 1; index < count; index++) {
1807 subItem = subItems [index];
1808 col = control.Columns [index];
1809 format.Alignment = col.Format.Alignment;
1810 sub_item_rect.X = col.Rect.X - control.h_marker;
1811 sub_item_rect.Width = col.Wd;
1812 Rectangle sub_item_text_rect = sub_item_rect;
1813 sub_item_text_rect.X += 3;
1814 sub_item_text_rect.Width -= 6;
1816 SolidBrush sub_item_back_br = null;
1817 SolidBrush sub_item_fore_br = null;
1818 Font sub_item_font = null;
1820 if (item.UseItemStyleForSubItems) {
1821 sub_item_back_br = ResPool.GetSolidBrush (item.BackColor);
1822 sub_item_fore_br = ResPool.GetSolidBrush (item.ForeColor);
1823 sub_item_font = item.Font;
1825 sub_item_back_br = ResPool.GetSolidBrush (subItem.BackColor);
1826 sub_item_fore_br = ResPool.GetSolidBrush (subItem.ForeColor);
1827 sub_item_font = subItem.Font;
1830 if (item.Selected && (control.Focused || !control.HideSelection) && control.FullRowSelect) {
1832 if (control.Focused) {
1833 bg = SystemBrushes.Highlight;
1834 text = SystemBrushes.HighlightText;
1836 bg = SystemBrushes.Control;
1837 text = sub_item_fore_br;
1840 dc.FillRectangle (bg, sub_item_rect);
1841 if (subItem.Text != null && subItem.Text.Length > 0)
1842 dc.DrawString (subItem.Text, sub_item_font,
1843 text, sub_item_text_rect, format);
1845 dc.FillRectangle (sub_item_back_br, sub_item_rect);
1846 if (subItem.Text != null && subItem.Text.Length > 0)
1847 dc.DrawString (subItem.Text, sub_item_font,
1849 sub_item_text_rect, format);
1853 // Fill in selection for remaining columns if Column.Count > SubItems.Count
1854 if (item.Selected && (control.Focused || !control.HideSelection) && control.FullRowSelect) {
1855 for (int index = count; index < control.Columns.Count; index++)
1857 col = control.Columns [index];
1858 sub_item_rect.X = col.Rect.X - control.h_marker;
1859 sub_item_rect.Width = col.Wd;
1860 if (control.Focused)
1861 dc.FillRectangle (SystemBrushes.Highlight, sub_item_rect);
1863 dc.FillRectangle (SystemBrushes.Control, sub_item_rect);
1869 if (item.Focused && control.Focused) {
1870 Rectangle focus_rect = highlight_rect;
1871 if (control.FullRowSelect && control.View == View.Details) {
1873 foreach (ColumnHeader col in control.Columns)
1875 focus_rect = new Rectangle (0, full_rect.Y, width, full_rect.Height);
1878 CPDrawFocusRectangle (dc, focus_rect, ColorHighlightText, ColorHighlight);
1880 CPDrawFocusRectangle (dc, focus_rect, control.ForeColor, control.BackColor);
1887 public override Size ListViewCheckBoxSize {
1888 get { return new Size (16, 16); }
1891 public override int ListViewColumnHeaderHeight {
1895 public override int ListViewDefaultColumnWidth {
1899 public override int ListViewVerticalSpacing {
1903 public override int ListViewEmptyColumnWidth {
1907 public override int ListViewHorizontalSpacing {
1911 public override Size ListViewDefaultSize {
1912 get { return new Size (121, 97); }
1914 #endregion // ListView
1917 public override void CalcItemSize (Graphics dc, MenuItem item, int y, int x, bool menuBar)
1922 if (item.Visible == false) {
1928 if (item.Separator == true) {
1929 item.Height = SEPARATOR_HEIGHT / 2;
1934 if (item.MeasureEventDefined) {
1935 MeasureItemEventArgs mi = new MeasureItemEventArgs (dc, item.Index);
1936 item.PerformMeasureItem (mi);
1937 item.Height = mi.ItemHeight;
1938 item.Width = mi.ItemWidth;
1942 size = dc.MeasureString (item.Text, MenuFont);
1943 item.Width = (int) size.Width;
1944 item.Height = (int) size.Height;
1947 if (item.Shortcut != Shortcut.None && item.ShowShortcut) {
1948 item.XTab = MenuCheckSize.Width + MENU_TAB_SPACE + (int) size.Width;
1949 size = dc.MeasureString (" " + item.GetShortCutText (), MenuFont);
1950 item.Width += MENU_TAB_SPACE + (int) size.Width;
1953 item.Width += 4 + (MenuCheckSize.Width * 2);
1955 item.Width += MENU_BAR_ITEMS_SPACE;
1959 if (item.Height < MenuHeight)
1960 item.Height = MenuHeight;
1964 // Updates the menu rect and returns the height
1965 public override int CalcMenuBarSize (Graphics dc, Menu menu, int width)
1971 foreach (MenuItem item in menu.MenuItems) {
1973 CalcItemSize (dc, item, y, x, true);
1975 if (x + item.Width > width) {
1983 item.MenuBar = true;
1985 if (y + item.Height > menu.Height)
1986 menu.Height = item.Height + y;
1993 public override void CalcPopupMenuSize (Graphics dc, Menu menu)
2001 while (start < menu.MenuItems.Count) {
2004 for (i = start; i < menu.MenuItems.Count; i++) {
2005 MenuItem item = menu.MenuItems [i];
2007 if ((i != start) && (item.Break || item.BarBreak))
2010 CalcItemSize (dc, item, y, x, false);
2013 if (item.Width > max)
2017 // Replace the -1 by the menu width (separators)
2018 for (n = start; n < i; n++, start++)
2019 menu.MenuItems [n].Width = max;
2021 if (y > menu.Height)
2033 menu.Width += SM_CXBORDER;
2034 menu.Height += SM_CYBORDER;
2037 // Draws a menu bar in a window
2038 public override void DrawMenuBar (Graphics dc, Menu menu, Rectangle rect)
2040 if (menu.Height == 0)
2041 CalcMenuBarSize (dc, menu, rect.Width);
2043 bool keynav = (menu as MainMenu).tracker.Navigating;
2044 HotkeyPrefix hp = always_draw_hotkeys || keynav ? HotkeyPrefix.Show : HotkeyPrefix.Hide;
2045 string_format_menu_menubar_text.HotkeyPrefix = hp;
2046 string_format_menu_text.HotkeyPrefix = hp;
2048 rect.Height = menu.Height;
2049 dc.FillRectangle (SystemBrushes.Menu, rect);
2051 for (int i = 0; i < menu.MenuItems.Count; i++) {
2052 MenuItem item = menu.MenuItems [i];
2053 Rectangle item_rect = item.bounds;
2054 item_rect.X += rect.X;
2055 item_rect.Y += rect.Y;
2056 item.MenuHeight = menu.Height;
2057 item.PerformDrawItem (new DrawItemEventArgs (dc, MenuFont, item_rect, i, item.Status));
2061 protected Bitmap CreateGlyphBitmap (Size size, MenuGlyph glyph, Color color)
2064 if (color.R == 0 && color.G == 0 && color.B == 0)
2065 bg_color = Color.White;
2067 bg_color = Color.Black;
2068 Bitmap bmp = new Bitmap (size.Width, size.Height);
2069 Graphics gr = Graphics.FromImage (bmp);
2070 Rectangle rect = new Rectangle (Point.Empty, size);
2071 gr.FillRectangle (ResPool.GetSolidBrush (bg_color), rect);
2072 CPDrawMenuGlyph (gr, rect, glyph, color);
2073 bmp.MakeTransparent (bg_color);
2078 public override void DrawMenuItem (MenuItem item, DrawItemEventArgs e)
2080 StringFormat string_format;
2081 Rectangle rect_text = e.Bounds;
2083 if (item.Visible == false)
2087 string_format = string_format_menu_menubar_text;
2089 string_format = string_format_menu_text;
2091 if (item.Separator == true) {
2092 e.Graphics.DrawLine (SystemPens.ControlDark,
2093 e.Bounds.X, e.Bounds.Y, e.Bounds.X + e.Bounds.Width, e.Bounds.Y);
2095 e.Graphics.DrawLine (SystemPens.ControlLight,
2096 e.Bounds.X, e.Bounds.Y + 1, e.Bounds.X + e.Bounds.Width, e.Bounds.Y + 1);
2102 rect_text.X += MenuCheckSize.Width;
2104 if (item.BarBreak) { /* Draw vertical break bar*/
2105 Rectangle rect = e.Bounds;
2108 rect.Height = item.MenuHeight - 6;
2110 e.Graphics.DrawLine (SystemPens.ControlDark,
2111 rect.X, rect.Y , rect.X, rect.Y + rect.Height);
2113 e.Graphics.DrawLine (SystemPens.ControlLight,
2114 rect.X + 1, rect.Y , rect.X +1, rect.Y + rect.Height);
2119 Brush brush_text = null;
2120 Brush brush_back = null;
2122 if ((e.State & DrawItemState.Selected) == DrawItemState.Selected && !item.MenuBar) {
2123 color_text = ColorHighlightText;
2124 color_back = ColorHighlight;
2125 brush_text = SystemBrushes.HighlightText;
2126 brush_back = SystemBrushes.Highlight;
2128 color_text = ColorMenuText;
2129 color_back = ColorMenu;
2130 brush_text = ResPool.GetSolidBrush (ColorMenuText);
2131 brush_back = SystemBrushes.Menu;
2134 /* Draw background */
2135 Rectangle rect_back = e.Bounds;
2137 rect_back.Width -=2;
2139 e.Graphics.FillRectangle (brush_back, rect_back);
2142 e.Graphics.DrawString (item.Text, e.Font,
2144 rect_text, string_format);
2146 if (!item.MenuBar && item.Shortcut != Shortcut.None && item.ShowShortcut) {
2147 string str = item.GetShortCutText ();
2148 Rectangle rect = rect_text;
2150 rect.Width -= item.XTab;
2152 e.Graphics.DrawString (str, e.Font, brush_text,
2153 rect, string_format_menu_shortcut);
2157 Border3DStyle border_style = Border3DStyle.Adjust;
2158 if ((item.Status & DrawItemState.HotLight) != 0)
2159 border_style = Border3DStyle.RaisedInner;
2160 else if ((item.Status & DrawItemState.Selected) != 0)
2161 border_style = Border3DStyle.SunkenOuter;
2163 if (border_style != Border3DStyle.Adjust)
2164 CPDrawBorder3D(e.Graphics, rect_back, border_style, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, ColorMenu);
2167 if ((item.Status & DrawItemState.Selected) != DrawItemState.Selected) {
2168 e.Graphics.DrawString (item.Text, e.Font, Brushes.White,
2169 new RectangleF(rect_text.X + 1, rect_text.Y + 1, rect_text.Width, rect_text.Height),
2173 e.Graphics.DrawString (item.Text, e.Font, ResPool.GetSolidBrush(ColorGrayText), rect_text, string_format);
2177 if (item.MenuBar == false && item.IsPopup || item.MdiList) {
2179 int cx = MenuCheckSize.Width;
2180 int cy = MenuCheckSize.Height;
2181 Bitmap bmp = CreateGlyphBitmap (new Size (cx, cy), MenuGlyph.Arrow, color_text);
2184 e.Graphics.DrawImage (bmp, e.Bounds.X + e.Bounds.Width - cx,
2185 e.Bounds.Y + ((e.Bounds.Height - cy) /2));
2187 ControlPaint.DrawImageDisabled (e.Graphics, bmp, e.Bounds.X + e.Bounds.Width - cx,
2188 e.Bounds.Y + ((e.Bounds.Height - cy) /2), color_back);
2194 /* Draw checked or radio */
2195 if (item.MenuBar == false && item.Checked) {
2197 Rectangle area = e.Bounds;
2198 int cx = MenuCheckSize.Width;
2199 int cy = MenuCheckSize.Height;
2200 Bitmap bmp = CreateGlyphBitmap (new Size (cx, cy), item.RadioCheck ? MenuGlyph.Bullet : MenuGlyph.Checkmark, color_text);
2202 e.Graphics.DrawImage (bmp, area.X, e.Bounds.Y + ((e.Bounds.Height - cy) / 2));
2208 public override void DrawPopupMenu (Graphics dc, Menu menu, Rectangle cliparea, Rectangle rect)
2211 dc.FillRectangle (SystemBrushes.Menu, cliparea);
2213 Pen pen_cht = SystemPens.HighlightText;
2214 Pen pen_ccd = SystemPens.ControlDark;
2215 Pen pen_ccdd = SystemPens.ControlDarkDark;
2217 /* Draw menu borders */
2218 dc.DrawLine (pen_cht,
2219 rect.X, rect.Y, rect.X + rect.Width, rect.Y);
2221 dc.DrawLine (pen_cht,
2222 rect.X, rect.Y, rect.X, rect.Y + rect.Height);
2224 dc.DrawLine (pen_ccd,
2225 rect.X + rect.Width - 1 , rect.Y , rect.X + rect.Width - 1, rect.Y + rect.Height);
2227 dc.DrawLine (pen_ccdd,
2228 rect.X + rect.Width, rect.Y , rect.X + rect.Width, rect.Y + rect.Height);
2230 dc.DrawLine (pen_ccd,
2231 rect.X , rect.Y + rect.Height - 1 , rect.X + rect.Width - 1, rect.Y + rect.Height -1);
2233 dc.DrawLine (pen_ccdd,
2234 rect.X , rect.Y + rect.Height, rect.X + rect.Width - 1, rect.Y + rect.Height);
2236 for (int i = 0; i < menu.MenuItems.Count; i++)
2237 if (cliparea.IntersectsWith (menu.MenuItems [i].bounds)) {
2238 MenuItem item = menu.MenuItems [i];
2239 item.MenuHeight = menu.Height;
2240 item.PerformDrawItem (new DrawItemEventArgs (dc, MenuFont,
2241 item.bounds, i, item.Status));
2247 #region MonthCalendar
2249 // draw the month calendar
2250 public override void DrawMonthCalendar(Graphics dc, Rectangle clip_rectangle, MonthCalendar mc)
2252 Rectangle client_rectangle = mc.ClientRectangle;
2253 Size month_size = mc.SingleMonthSize;
2254 // cache local copies of Marshal-by-ref internal members (gets around error CS0197)
2255 Size calendar_spacing = (Size)((object)mc.calendar_spacing);
2256 Size date_cell_size = (Size)((object)mc.date_cell_size);
2258 // draw the singlecalendars
2261 // adjust for the position of the specific month
2262 for (int i=0; i < mc.CalendarDimensions.Height; i++)
2266 y_offset += month_size.Height + calendar_spacing.Height;
2268 // now adjust for x position
2269 for (int j=0; j < mc.CalendarDimensions.Width; j++)
2273 x_offset += month_size.Width + calendar_spacing.Width;
2280 Rectangle month_rect = new Rectangle (x_offset, y_offset, month_size.Width, month_size.Height);
2281 if (month_rect.IntersectsWith (clip_rectangle)) {
2293 Rectangle bottom_rect = new Rectangle (
2295 Math.Max(client_rectangle.Bottom - date_cell_size.Height - 3, 0),
2296 client_rectangle.Width,
2297 date_cell_size.Height + 2);
2298 // draw the today date if it's set
2299 if (mc.ShowToday && bottom_rect.IntersectsWith (clip_rectangle))
2301 dc.FillRectangle (GetControlBackBrush (mc.BackColor), bottom_rect);
2303 int today_offset = 5;
2304 if (mc.ShowTodayCircle)
2306 Rectangle today_circle_rect = new Rectangle (
2307 client_rectangle.X + 5,
2308 Math.Max(client_rectangle.Bottom - date_cell_size.Height - 2, 0),
2309 date_cell_size.Width,
2310 date_cell_size.Height);
2311 DrawTodayCircle (dc, today_circle_rect);
2312 today_offset += date_cell_size.Width + 5;
2314 // draw today's date
2315 StringFormat text_format = new StringFormat();
2316 text_format.LineAlignment = StringAlignment.Center;
2317 text_format.Alignment = StringAlignment.Near;
2318 Rectangle today_rect = new Rectangle (
2319 today_offset + client_rectangle.X,
2320 Math.Max(client_rectangle.Bottom - date_cell_size.Height, 0),
2321 Math.Max(client_rectangle.Width - today_offset, 0),
2322 date_cell_size.Height);
2323 dc.DrawString ("Today: " + DateTime.Now.ToShortDateString(), mc.bold_font, GetControlForeBrush (mc.ForeColor), today_rect, text_format);
2324 text_format.Dispose ();
2328 // finally paint the borders of the calendars as required
2329 for (int i = 0; i <= mc.CalendarDimensions.Width; i++) {
2330 if (i == 0 && clip_rectangle.X == client_rectangle.X) {
2331 dc.FillRectangle (GetControlBackBrush (mc.BackColor), client_rectangle.X, client_rectangle.Y, 1, client_rectangle.Height);
2332 } else if (i == mc.CalendarDimensions.Width && clip_rectangle.Right == client_rectangle.Right) {
2333 dc.FillRectangle (GetControlBackBrush (mc.BackColor), client_rectangle.Right-1, client_rectangle.Y, 1, client_rectangle.Height);
2335 Rectangle rect = new Rectangle (
2336 client_rectangle.X + (month_size.Width*i) + (calendar_spacing.Width * (i-1)) + 1,
2338 calendar_spacing.Width,
2339 client_rectangle.Height);
2340 if (i < mc.CalendarDimensions.Width && i > 0 && clip_rectangle.IntersectsWith (rect)) {
2341 dc.FillRectangle (GetControlBackBrush (mc.BackColor), rect);
2345 for (int i = 0; i <= mc.CalendarDimensions.Height; i++) {
2346 if (i == 0 && clip_rectangle.Y == client_rectangle.Y) {
2347 dc.FillRectangle (GetControlBackBrush (mc.BackColor), client_rectangle.X, client_rectangle.Y, client_rectangle.Width, 1);
2348 } else if (i == mc.CalendarDimensions.Height && clip_rectangle.Bottom == client_rectangle.Bottom) {
2349 dc.FillRectangle (GetControlBackBrush (mc.BackColor), client_rectangle.X, client_rectangle.Bottom-1, client_rectangle.Width, 1);
2351 Rectangle rect = new Rectangle (
2353 client_rectangle.Y + (month_size.Height*i) + (calendar_spacing.Height*(i-1)) + 1,
2354 client_rectangle.Width,
2355 calendar_spacing.Height);
2356 if (i < mc.CalendarDimensions.Height && i > 0 && clip_rectangle.IntersectsWith (rect)) {
2357 dc.FillRectangle (GetControlBackBrush (mc.BackColor), rect);
2362 // draw the drop down border if need
2363 if (mc.owner != null) {
2364 Rectangle bounds = mc.ClientRectangle;
2365 if (clip_rectangle.Contains (mc.Location)) {
2366 // find out if top or left line to draw
2367 if(clip_rectangle.Contains (new Point (bounds.Left, bounds.Bottom))) {
2369 dc.DrawLine (SystemPens.ControlText, bounds.X, bounds.Y, bounds.X, bounds.Bottom-1);
2371 if(clip_rectangle.Contains (new Point (bounds.Right, bounds.Y))) {
2372 dc.DrawLine (SystemPens.ControlText, bounds.X, bounds.Y, bounds.Right-1, bounds.Y);
2375 if (clip_rectangle.Contains (new Point(bounds.Right, bounds.Bottom))) {
2376 // find out if bottom or right line to draw
2377 if(clip_rectangle.Contains (new Point (bounds.Left, bounds.Bottom))) {
2378 dc.DrawLine (SystemPens.ControlText, bounds.X, bounds.Bottom-1, bounds.Right-1, bounds.Bottom-1);
2380 if(clip_rectangle.Contains (new Point (bounds.Right, bounds.Y))) {
2381 dc.DrawLine (SystemPens.ControlText, bounds.Right-1, bounds.Y, bounds.Right-1, bounds.Bottom-1);
2387 // darws a single part of the month calendar (with one month)
2388 private void DrawSingleMonth(Graphics dc, Rectangle clip_rectangle, Rectangle rectangle, MonthCalendar mc, int row, int col)
2390 // cache local copies of Marshal-by-ref internal members (gets around error CS0197)
2391 Size title_size = (Size)((object)mc.title_size);
2392 Size date_cell_size = (Size)((object)mc.date_cell_size);
2393 DateTime current_month = (DateTime)((object)mc.current_month);
2395 // draw the title back ground
2396 DateTime this_month = current_month.AddMonths (row*mc.CalendarDimensions.Width+col);
2397 Rectangle title_rect = new Rectangle(rectangle.X, rectangle.Y, title_size.Width, title_size.Height);
2398 if (title_rect.IntersectsWith (clip_rectangle)) {
2399 dc.FillRectangle (ResPool.GetSolidBrush (mc.TitleBackColor), title_rect);
2401 string title_text = this_month.ToString ("MMMM yyyy");
2402 dc.DrawString (title_text, mc.bold_font, ResPool.GetSolidBrush (mc.TitleForeColor), title_rect, mc.centered_format);
2404 // draw previous and next buttons if it's time
2405 if (row == 0 && col == 0)
2407 // draw previous button
2408 DrawMonthCalendarButton (
2414 (System.Drawing.Size)((object)mc.button_size),
2417 if (row == 0 && col == mc.CalendarDimensions.Width-1)
2420 DrawMonthCalendarButton (
2426 (System.Drawing.Size)((object)mc.button_size),
2431 // set the week offset and draw week nums if needed
2432 int col_offset = (mc.ShowWeekNumbers) ? 1 : 0;
2433 Rectangle day_name_rect = new Rectangle(
2435 rectangle.Y + title_size.Height,
2436 (7 + col_offset) * date_cell_size.Width,
2437 date_cell_size.Height);
2438 if (day_name_rect.IntersectsWith (clip_rectangle)) {
2439 dc.FillRectangle (GetControlBackBrush (mc.BackColor), day_name_rect);
2440 // draw the day names
2441 DayOfWeek first_day_of_week = mc.GetDayOfWeek(mc.FirstDayOfWeek);
2442 for (int i=0; i < 7; i++)
2444 int position = i - (int) first_day_of_week;
2447 position = 7 + position;
2450 Rectangle day_rect = new Rectangle(
2451 day_name_rect.X + ((i + col_offset)* date_cell_size.Width),
2453 date_cell_size.Width,
2454 date_cell_size.Height);
2455 dc.DrawString (((DayOfWeek)i).ToString().Substring(0, 3), mc.Font, ResPool.GetSolidBrush (mc.TitleBackColor), day_rect, mc.centered_format);
2458 // draw the vertical divider
2459 int vert_divider_y = Math.Max(title_size.Height+ date_cell_size.Height-1, 0);
2461 ResPool.GetPen (mc.ForeColor),
2462 rectangle.X + (col_offset * date_cell_size.Width) + mc.divider_line_offset,
2463 rectangle.Y + vert_divider_y,
2464 rectangle.Right - mc.divider_line_offset,
2465 rectangle.Y + vert_divider_y);
2469 // draw the actual date items in the grid (including the week numbers)
2470 Rectangle date_rect = new Rectangle (
2472 rectangle.Y + title_size.Height + date_cell_size.Height,
2473 date_cell_size.Width,
2474 date_cell_size.Height);
2475 int month_row_count = 0;
2476 bool draw_week_num_divider = false;
2477 DateTime current_date = mc.GetFirstDateInMonthGrid ( new DateTime (this_month.Year, this_month.Month, 1));
2478 for (int i=0; i < 6; i++)
2480 // establish if this row is in our clip_area
2481 Rectangle row_rect = new Rectangle (
2483 rectangle.Y + title_size.Height + (date_cell_size.Height * (i+1)),
2484 date_cell_size.Width * 7,
2485 date_cell_size.Height);
2486 if (mc.ShowWeekNumbers) {
2487 row_rect.Width += date_cell_size.Width;
2490 bool draw_row = row_rect.IntersectsWith (clip_rectangle);
2492 dc.FillRectangle (GetControlBackBrush (mc.BackColor), row_rect);
2494 // establish if this is a valid week to draw
2495 if (mc.IsValidWeekToDraw (this_month, current_date, row, col)) {
2496 month_row_count = i;
2499 // draw the week number if required
2500 if (mc.ShowWeekNumbers && month_row_count == i) {
2501 if (!draw_week_num_divider) {
2502 draw_week_num_divider = draw_row;
2504 // get the week for this row
2505 int week = mc.GetWeekOfYear (current_date);
2511 ResPool.GetSolidBrush (mc.TitleBackColor),
2513 mc.centered_format);
2515 date_rect.Offset(date_cell_size.Width, 0);
2518 // only draw the days if we have to
2519 if(month_row_count == i) {
2520 for (int j=0; j < 7; j++)
2523 DrawMonthCalendarDate (
2534 current_date = current_date.AddDays(1);
2535 date_rect.Offset(date_cell_size.Width, 0);
2538 // shift the rectangle down one row
2539 int offset = (mc.ShowWeekNumbers) ? -8 : -7;
2540 date_rect.Offset(offset*date_cell_size.Width, date_cell_size.Height);
2544 // month_row_count is zero based, so add one
2547 // draw week numbers if required
2548 if (draw_week_num_divider) {
2551 ResPool.GetPen (mc.ForeColor),
2552 rectangle.X + date_cell_size.Width - 1,
2553 rectangle.Y + title_size.Height + date_cell_size.Height + mc.divider_line_offset,
2554 rectangle.X + date_cell_size.Width - 1,
2555 rectangle.Y + title_size.Height + date_cell_size.Height + (month_row_count * date_cell_size.Height) - mc.divider_line_offset);
2559 // draws the pervious or next button
2560 private void DrawMonthCalendarButton (Graphics dc, Rectangle rectangle, MonthCalendar mc, Size title_size, int x_offset, Size button_size, bool is_previous)
2562 bool is_clicked = false;
2563 Rectangle button_rect;
2564 Rectangle arrow_rect = new Rectangle (rectangle.X, rectangle.Y, 4, 7);
2565 Point[] arrow_path = new Point[3];
2566 // prepare the button
2569 is_clicked = mc.is_previous_clicked;
2570 button_rect = new Rectangle (
2571 rectangle.X + 1 + x_offset,
2572 rectangle.Y + 1 + ((title_size.Height - button_size.Height)/2),
2573 Math.Max(button_size.Width - 1, 0),
2574 Math.Max(button_size.Height - 1, 0));
2575 arrow_rect.X = button_rect.X + ((button_rect.Width - arrow_rect.Width)/2);
2576 arrow_rect.Y = button_rect.Y + ((button_rect.Height - arrow_rect.Height)/2);
2578 arrow_rect.Offset(1,1);
2580 arrow_path[0] = new Point (arrow_rect.Right, arrow_rect.Y);
2581 arrow_path[1] = new Point (arrow_rect.X, arrow_rect.Y + arrow_rect.Height/2);
2582 arrow_path[2] = new Point (arrow_rect.Right, arrow_rect.Bottom);
2586 is_clicked = mc.is_next_clicked;
2587 button_rect = new Rectangle (
2588 rectangle.Right - 1 - x_offset - button_size.Width,
2589 rectangle.Y + 1 + ((title_size.Height - button_size.Height)/2),
2590 Math.Max(button_size.Width - 1, 0),
2591 Math.Max(button_size.Height - 1, 0));
2592 arrow_rect.X = button_rect.X + ((button_rect.Width - arrow_rect.Width)/2);
2593 arrow_rect.Y = button_rect.Y + ((button_rect.Height - arrow_rect.Height)/2);
2595 arrow_rect.Offset(1,1);
2597 arrow_path[0] = new Point (arrow_rect.X, arrow_rect.Y);
2598 arrow_path[1] = new Point (arrow_rect.Right, arrow_rect.Y + arrow_rect.Height/2);
2599 arrow_path[2] = new Point (arrow_rect.X, arrow_rect.Bottom);
2602 // fill the background
2603 dc.FillRectangle (SystemBrushes.Control, button_rect);
2606 dc.DrawRectangle (SystemPens.ControlDark, button_rect);
2609 CPDrawBorder3D (dc, button_rect, Border3DStyle.Raised, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom);
2612 dc.FillPolygon (SystemBrushes.ControlText, arrow_path);
2616 // draws one day in the calendar grid
2617 private void DrawMonthCalendarDate (Graphics dc, Rectangle rectangle, MonthCalendar mc, DateTime date, DateTime month, int row, int col) {
2618 Color date_color = mc.ForeColor;
2619 Rectangle interior = new Rectangle (rectangle.X, rectangle.Y, Math.Max(rectangle.Width - 1, 0), Math.Max(rectangle.Height - 1, 0));
2621 // find out if we are the lead of the first calendar or the trail of the last calendar
2622 if (date.Year != month.Year || date.Month != month.Month) {
2623 DateTime check_date = month.AddMonths (-1);
2624 // check if it's the month before
2625 if (check_date.Year == date.Year && check_date.Month == date.Month && row == 0 && col == 0) {
2626 date_color = mc.TrailingForeColor;
2628 // check if it's the month after
2629 check_date = month.AddMonths (1);
2630 if (check_date.Year == date.Year && check_date.Month == date.Month && row == mc.CalendarDimensions.Height-1 && col == mc.CalendarDimensions.Width-1) {
2631 date_color = mc.TrailingForeColor;
2637 date_color = mc.ForeColor;
2641 if (date == mc.SelectionStart && date == mc.SelectionEnd) {
2642 // see if the date is in the start of selection
2643 date_color = mc.BackColor;
2644 // draw the left hand of the back ground
2645 Rectangle selection_rect = Rectangle.Inflate(rectangle, -3, -3);
2646 dc.FillPie (ResPool.GetSolidBrush (mc.TitleBackColor), selection_rect, 0, 359);
2647 } else if (date == mc.SelectionStart) {
2648 // see if the date is in the start of selection
2649 date_color = mc.BackColor;
2650 // draw the left hand of the back ground
2651 Rectangle selection_rect = Rectangle.Inflate(rectangle, -3, -3);
2652 dc.FillPie (ResPool.GetSolidBrush (mc.TitleBackColor), selection_rect, 90, 180);
2653 // fill the other side as a straight rect
2654 if (date < mc.SelectionEnd)
2656 // use rectangle instead of rectangle to go all the way to edge of rect
2657 selection_rect.X = (int) Math.Floor((double)(rectangle.X + rectangle.Width / 2));
2658 selection_rect.Width = Math.Max(rectangle.Right - selection_rect.X, 0);
2659 dc.FillRectangle (ResPool.GetSolidBrush (mc.TitleBackColor), selection_rect);
2661 } else if (date == mc.SelectionEnd) {
2662 // see if it is the end of selection
2663 date_color = mc.BackColor;
2664 // draw the left hand of the back ground
2665 Rectangle selection_rect = Rectangle.Inflate(rectangle, -3, -3);
2666 dc.FillPie (ResPool.GetSolidBrush (mc.TitleBackColor), selection_rect, 270, 180);
2667 // fill the other side as a straight rect
2668 if (date > mc.SelectionStart) {
2669 selection_rect.X = rectangle.X;
2670 selection_rect.Width = rectangle.Width - (rectangle.Width / 2);
2671 dc.FillRectangle (ResPool.GetSolidBrush (mc.TitleBackColor), selection_rect);
2673 } else if (date > mc.SelectionStart && date < mc.SelectionEnd) {
2674 // now see if it's in the middle
2675 date_color = mc.BackColor;
2676 // draw the left hand of the back ground
2677 Rectangle selection_rect = Rectangle.Inflate(rectangle, 0, -3);
2678 dc.FillRectangle (ResPool.GetSolidBrush (mc.TitleBackColor), selection_rect);
2681 // establish if it's a bolded font
2682 Font font = mc.IsBoldedDate (date) ? mc.bold_font : mc.Font;
2684 // just draw the date now
2685 dc.DrawString (date.Day.ToString(), font, ResPool.GetSolidBrush (date_color), rectangle, mc.centered_format);
2687 // today circle if needed
2688 if (mc.ShowTodayCircle && date == DateTime.Now.Date) {
2689 DrawTodayCircle (dc, interior);
2692 // draw the selection grid
2693 if (mc.is_date_clicked && mc.clicked_date == date) {
2694 Pen pen = ResPool.GetDashPen (Color.Black, DashStyle.Dot);
2695 dc.DrawRectangle (pen, interior);
2699 private void DrawTodayCircle (Graphics dc, Rectangle rectangle) {
2700 Color circle_color = Color.FromArgb (248, 0, 0);
2701 // draw the left hand of the circle
2702 Rectangle lhs_circle_rect = new Rectangle (rectangle.X + 1, rectangle.Y + 4, Math.Max(rectangle.Width - 2, 0), Math.Max(rectangle.Height - 5, 0));
2703 Rectangle rhs_circle_rect = new Rectangle (rectangle.X + 1, rectangle.Y + 1, Math.Max(rectangle.Width - 2, 0), Math.Max(rectangle.Height - 2, 0));
2704 Point [] curve_points = new Point [3];
2705 curve_points [0] = new Point (lhs_circle_rect.X, rhs_circle_rect.Y + rhs_circle_rect.Height/12);
2706 curve_points [1] = new Point (lhs_circle_rect.X + lhs_circle_rect.Width/9, rhs_circle_rect.Y);
2707 curve_points [2] = new Point (lhs_circle_rect.X + lhs_circle_rect.Width/2 + 1, rhs_circle_rect.Y);
2709 Pen pen = ResPool.GetSizedPen(circle_color, 2);
2710 dc.DrawArc (pen, lhs_circle_rect, 90, 180);
2711 dc.DrawArc (pen, rhs_circle_rect, 270, 180);
2712 dc.DrawCurve (pen, curve_points);
2713 dc.DrawLine (ResPool.GetPen (circle_color), curve_points [2], new Point (curve_points [2].X, lhs_circle_rect.Y));
2716 #endregion // MonthCalendar
2719 public override Size PanelDefaultSize {
2721 return new Size (200, 100);
2727 public override void DrawPictureBox (Graphics dc, Rectangle clip, PictureBox pb) {
2728 Rectangle client = pb.ClientRectangle;
2730 // FIXME - instead of drawing the whole picturebox every time
2731 // intersect the clip rectangle with the drawn picture and only draw what's needed,
2732 // Also, we only need a background fill where no image goes
2733 if (pb.Image != null) {
2734 switch (pb.SizeMode) {
2735 case PictureBoxSizeMode.StretchImage:
2736 dc.DrawImage (pb.Image, 0, 0, client.Width, client.Height);
2739 case PictureBoxSizeMode.CenterImage:
2740 dc.FillRectangle(GetControlBackBrush (pb.BackColor), clip);
2741 dc.DrawImage (pb.Image, (client.Width / 2) - (pb.Image.Width / 2), (client.Height / 2) - (pb.Image.Height / 2));
2744 dc.FillRectangle(GetControlBackBrush (pb.BackColor), clip);
2746 dc.DrawImage(pb.Image, 0, 0, pb.Image.Width, pb.Image.Height);
2753 // We only get here if no image is set. At least paint the background
2754 dc.FillRectangle(GetControlBackBrush (pb.BackColor), clip);
2757 public override Size PictureBoxDefaultSize {
2759 return new Size (100, 50);
2762 #endregion // PictureBox
2764 #region PrintPreviewControl
2765 public override int PrintPreviewControlPadding {
2769 public override Size PrintPreviewControlGetPageSize (PrintPreviewControl preview)
2771 int page_width, page_height;
2772 int padding = PrintPreviewControlPadding;
2773 PreviewPageInfo[] pis = preview.page_infos;
2775 if (preview.AutoZoom) {
2776 int height_available = preview.ClientRectangle.Height - (preview.Rows) * padding - 2 * padding;
2777 int width_available = preview.ClientRectangle.Width - (preview.Columns - 1) * padding - 2 * padding;
2779 float image_ratio = (float)pis[0].Image.Width / pis[0].Image.Height;
2781 /* try to lay things out using the width to determine the size */
2782 page_width = width_available / preview.Columns;
2783 page_height = (int)(page_width / image_ratio);
2785 /* does the height fit? */
2786 if (page_height * (preview.Rows + 1) > height_available) {
2787 /* no, lay things out via the height */
2788 page_height = height_available / (preview.Rows + 1);
2789 page_width = (int)(page_height * image_ratio);
2793 page_width = (int)(pis[0].Image.Width * preview.Zoom);
2794 page_height = (int)(pis[0].Image.Height * preview.Zoom);
2797 return new Size (page_width, page_height);
2800 public override void PrintPreviewControlPaint (PaintEventArgs pe, PrintPreviewControl preview, Size page_size)
2803 PreviewPageInfo[] pis = preview.page_infos;
2807 int width = page_size.Width * preview.Columns + padding * (preview.Columns - 1) + 2 * padding;
2808 int height = page_size.Height * (preview.Rows + 1) + padding * preview.Rows + 2 * padding;
2810 Rectangle viewport = preview.ViewPort;
2812 pe.Graphics.Clip = new Region (viewport);
2814 /* center things if we can */
2815 int off_x = viewport.Width / 2 - width / 2;
2816 if (off_x < 0) off_x = 0;
2817 int off_y = viewport.Height / 2 - height / 2;
2818 if (off_y < 0) off_y = 0;
2820 page_y = off_y + padding - preview.vbar_value;
2822 if (preview.StartPage > 0) {
2823 int p = preview.StartPage - 1;
2824 for (int py = 0; py < preview.Rows + 1; py ++) {
2825 page_x = off_x + padding - preview.hbar_value;
2826 for (int px = 0; px < preview.Columns; px ++) {
2827 if (p >= pis.Length)
2829 Image image = preview.image_cache[p];
2831 image = pis[p].Image;
2832 Rectangle dest = new Rectangle (new Point (page_x, page_y), page_size);
2834 pe.Graphics.DrawImage (image, dest, 0, 0, image.Width, image.Height, GraphicsUnit.Pixel);
2836 page_x += padding + page_size.Width;
2839 page_y += padding + page_size.Height;
2843 #endregion // PrintPreviewControl
2846 public override void DrawProgressBar (Graphics dc, Rectangle clip_rect, ProgressBar ctrl)
2848 Rectangle block_rect;
2849 Rectangle client_area = ctrl.client_area;
2850 int space_betweenblocks = 2;
2855 block_width = (client_area.Height * 2 ) / 3;
2856 barpos_pixels = ((ctrl.Value - ctrl.Minimum) * client_area.Width) / (ctrl.Maximum - ctrl.Minimum);
2857 increment = block_width + space_betweenblocks;
2860 CPDrawBorder3D (dc, ctrl.ClientRectangle, Border3DStyle.SunkenOuter, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom & ~Border3DSide.Middle, ColorControl);
2863 block_rect = new Rectangle (client_area.X, client_area.Y, block_width, client_area.Height);
2864 while ((block_rect.X - client_area.X) < barpos_pixels) {
2866 if (clip_rect.IntersectsWith (block_rect) == true) {
2867 dc.FillRectangle (ResPool.GetSolidBrush (progressbarblock_color), block_rect);
2870 block_rect.X += increment;
2874 public override Size ProgressBarDefaultSize {
2876 return new Size (100, 23);
2880 #endregion // ProgressBar
2883 public override void DrawRadioButton (Graphics dc, Rectangle clip_rectangle, RadioButton radio_button) {
2884 StringFormat text_format;
2885 Rectangle client_rectangle;
2886 Rectangle text_rectangle;
2887 Rectangle radiobutton_rectangle;
2888 int radiobutton_size = 13;
2889 int radiobutton_space = 4;
2891 client_rectangle = radio_button.ClientRectangle;
2892 text_rectangle = client_rectangle;
2893 radiobutton_rectangle = new Rectangle(text_rectangle.X, text_rectangle.Y, radiobutton_size, radiobutton_size);
2895 text_format = new StringFormat();
2896 text_format.Alignment = StringAlignment.Near;
2897 text_format.LineAlignment = StringAlignment.Center;
2898 text_format.HotkeyPrefix = HotkeyPrefix.Show;
2900 /* Calculate the position of text and checkbox rectangle */
2901 if (radio_button.appearance!=Appearance.Button) {
2902 switch(radio_button.radiobutton_alignment) {
2903 case ContentAlignment.BottomCenter: {
2904 radiobutton_rectangle.X=(client_rectangle.Right-client_rectangle.Left)/2-radiobutton_size/2;
2905 radiobutton_rectangle.Y=client_rectangle.Bottom-radiobutton_size;
2906 text_rectangle.X=client_rectangle.X;
2907 text_rectangle.Width=client_rectangle.Width;
2908 text_rectangle.Height=client_rectangle.Height-radiobutton_size-radiobutton_space;
2912 case ContentAlignment.BottomLeft: {
2913 radiobutton_rectangle.X=client_rectangle.Left;
2914 radiobutton_rectangle.Y=client_rectangle.Bottom-radiobutton_size;
2915 text_rectangle.X=client_rectangle.X+radiobutton_size+radiobutton_space;
2916 text_rectangle.Width=client_rectangle.Width-radiobutton_size-radiobutton_space;
2920 case ContentAlignment.BottomRight: {
2921 radiobutton_rectangle.X=client_rectangle.Right-radiobutton_size;
2922 radiobutton_rectangle.Y=client_rectangle.Bottom-radiobutton_size;
2923 text_rectangle.X=client_rectangle.X;
2924 text_rectangle.Width=client_rectangle.Width-radiobutton_size-radiobutton_space;
2928 case ContentAlignment.MiddleCenter: {
2929 radiobutton_rectangle.X=(client_rectangle.Right-client_rectangle.Left)/2-radiobutton_size/2;
2930 radiobutton_rectangle.Y=(client_rectangle.Bottom-client_rectangle.Top)/2-radiobutton_size/2;
2931 text_rectangle.X=client_rectangle.X;
2932 text_rectangle.Width=client_rectangle.Width;
2937 case ContentAlignment.MiddleLeft: {
2938 radiobutton_rectangle.X=client_rectangle.Left;
2939 radiobutton_rectangle.Y=(client_rectangle.Bottom-client_rectangle.Top)/2-radiobutton_size/2;
2940 text_rectangle.X=client_rectangle.X+radiobutton_size+radiobutton_space;
2941 text_rectangle.Width=client_rectangle.Width-radiobutton_size-radiobutton_space;
2945 case ContentAlignment.MiddleRight: {
2946 radiobutton_rectangle.X=client_rectangle.Right-radiobutton_size;
2947 radiobutton_rectangle.Y=(client_rectangle.Bottom-client_rectangle.Top)/2-radiobutton_size/2;
2948 text_rectangle.X=client_rectangle.X;
2949 text_rectangle.Width=client_rectangle.Width-radiobutton_size-radiobutton_space;
2953 case ContentAlignment.TopCenter: {
2954 radiobutton_rectangle.X=(client_rectangle.Right-client_rectangle.Left)/2-radiobutton_size/2;
2955 radiobutton_rectangle.Y=client_rectangle.Top;
2956 text_rectangle.X=client_rectangle.X;
2957 text_rectangle.Y=radiobutton_size+radiobutton_space;
2958 text_rectangle.Width=client_rectangle.Width;
2959 text_rectangle.Height=client_rectangle.Height-radiobutton_size-radiobutton_space;
2963 case ContentAlignment.TopLeft: {
2964 radiobutton_rectangle.X=client_rectangle.Left;
2965 radiobutton_rectangle.Y=client_rectangle.Top;
2966 text_rectangle.X=client_rectangle.X+radiobutton_size+radiobutton_space;
2967 text_rectangle.Width=client_rectangle.Width-radiobutton_size-radiobutton_space;
2971 case ContentAlignment.TopRight: {
2972 radiobutton_rectangle.X=client_rectangle.Right-radiobutton_size;
2973 radiobutton_rectangle.Y=client_rectangle.Top;
2974 text_rectangle.X=client_rectangle.X;
2975 text_rectangle.Width=client_rectangle.Width-radiobutton_size-radiobutton_space;
2980 text_rectangle.X=client_rectangle.X;
2981 text_rectangle.Width=client_rectangle.Width;
2984 /* Set the horizontal alignment of our text */
2985 switch(radio_button.text_alignment) {
2986 case ContentAlignment.BottomLeft:
2987 case ContentAlignment.MiddleLeft:
2988 case ContentAlignment.TopLeft: {
2989 text_format.Alignment=StringAlignment.Near;
2993 case ContentAlignment.BottomCenter:
2994 case ContentAlignment.MiddleCenter:
2995 case ContentAlignment.TopCenter: {
2996 text_format.Alignment=StringAlignment.Center;
3000 case ContentAlignment.BottomRight:
3001 case ContentAlignment.MiddleRight:
3002 case ContentAlignment.TopRight: {
3003 text_format.Alignment=StringAlignment.Far;
3008 /* Set the vertical alignment of our text */
3009 switch(radio_button.text_alignment) {
3010 case ContentAlignment.TopLeft:
3011 case ContentAlignment.TopCenter:
3012 case ContentAlignment.TopRight: {
3013 text_format.LineAlignment=StringAlignment.Near;
3017 case ContentAlignment.BottomLeft:
3018 case ContentAlignment.BottomCenter:
3019 case ContentAlignment.BottomRight: {
3020 text_format.LineAlignment=StringAlignment.Far;
3024 case ContentAlignment.MiddleLeft:
3025 case ContentAlignment.MiddleCenter:
3026 case ContentAlignment.MiddleRight: {
3027 text_format.LineAlignment=StringAlignment.Center;
3032 ButtonState state = ButtonState.Normal;
3033 if (radio_button.FlatStyle == FlatStyle.Flat) {
3034 state |= ButtonState.Flat;
3037 if (radio_button.Checked) {
3038 state |= ButtonState.Checked;
3041 if (!radio_button.Enabled) {
3042 state |= ButtonState.Inactive;
3046 RadioButton_DrawButton(radio_button, dc, state, radiobutton_rectangle);
3048 if ((radio_button.image != null) || (radio_button.image_list != null))
3049 ButtonBase_DrawImage(radio_button, dc);
3051 RadioButton_DrawText(radio_button, text_rectangle, dc, text_format);
3053 RadioButton_DrawFocus(radio_button, dc, text_rectangle);
3055 text_format.Dispose ();
3058 protected virtual void RadioButton_DrawButton(RadioButton radio_button, Graphics dc, ButtonState state, Rectangle radiobutton_rectangle)
3060 dc.FillRectangle(GetControlBackBrush (radio_button.BackColor), radio_button.ClientRectangle);
3062 if (radio_button.appearance==Appearance.Button) {
3063 ButtonBase_DrawButton (radio_button, dc);
3065 if ((radio_button.Focused) && radio_button.Enabled)
3066 ButtonBase_DrawFocus(radio_button, dc);
3068 // establish if we are rendering a flat style of some sort
3069 if (radio_button.FlatStyle == FlatStyle.Flat || radio_button.FlatStyle == FlatStyle.Popup) {
3070 DrawFlatStyleRadioButton (dc, radiobutton_rectangle, radio_button);
3072 CPDrawRadioButton(dc, radiobutton_rectangle, state);
3077 protected virtual void RadioButton_DrawText(RadioButton radio_button, Rectangle text_rectangle, Graphics dc, StringFormat text_format)
3079 DrawCheckBox_and_RadioButtonText (radio_button, text_rectangle, dc,
3080 text_format, radio_button.Appearance, radio_button.Checked);
3083 protected virtual void RadioButton_DrawFocus(RadioButton radio_button, Graphics dc, Rectangle text_rectangle)
3085 if ( radio_button.Focused && radio_button.appearance != Appearance.Button && radio_button.Enabled )
3086 DrawInnerFocusRectangle( dc, text_rectangle, radio_button.BackColor );
3089 // renders a radio button with the Flat and Popup FlatStyle
3090 protected virtual void DrawFlatStyleRadioButton (Graphics graphics, Rectangle rectangle, RadioButton radio_button)
3094 if (radio_button.Enabled) {
3096 // draw the outer flatstyle arcs
3097 if (radio_button.FlatStyle == FlatStyle.Flat) {
3098 graphics.DrawArc (SystemPens.ControlDarkDark, rectangle, 0, 359);
3100 // fill in the area depending on whether or not the mouse is hovering
3101 if ((radio_button.is_entered || radio_button.Capture) && !radio_button.is_pressed) {
3102 graphics.FillPie (SystemBrushes.ControlLight, rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2, 0, 359);
3104 graphics.FillPie (SystemBrushes.ControlLightLight, rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2, 0, 359);
3107 // must be a popup radio button
3109 graphics.FillPie (SystemBrushes.ControlLightLight, rectangle, 0, 359);
3111 if (radio_button.is_entered || radio_button.Capture) {
3112 // draw the popup 3d button knob
3113 graphics.DrawArc (SystemPens.ControlLight, rectangle.X+1, rectangle.Y+1, rectangle.Width-2, rectangle.Height-2, 0, 359);
3115 graphics.DrawArc (SystemPens.ControlDark, rectangle, 135, 180);
3116 graphics.DrawArc (SystemPens.ControlLightLight, rectangle, 315, 180);
3119 // just draw lighter flatstyle outer circle
3120 graphics.DrawArc (SystemPens.ControlDark, rectangle, 0, 359);
3125 // fill control background color regardless of actual backcolor
3126 graphics.FillPie (SystemBrushes.Control, rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2, 0, 359);
3127 // draw the ark as control dark
3128 graphics.DrawArc (SystemPens.ControlDark, rectangle, 0, 359);
3132 if (radio_button.Checked) {
3133 lineWidth = Math.Max (1, Math.Min(rectangle.Width, rectangle.Height)/3);
3135 Pen dot_pen = SystemPens.ControlDarkDark;
3136 Brush dot_brush = SystemBrushes.ControlDarkDark;
3138 if (!radio_button.Enabled || ((radio_button.FlatStyle == FlatStyle.Popup) && radio_button.is_pressed)) {
3139 dot_pen = SystemPens.ControlDark;
3140 dot_brush = SystemBrushes.ControlDark;
3143 if (rectangle.Height > 13) {
3144 graphics.FillPie (dot_brush, rectangle.X + lineWidth, rectangle.Y + lineWidth, rectangle.Width - lineWidth * 2, rectangle.Height - lineWidth * 2, 0, 359);
3146 int x_half_pos = (rectangle.Width / 2) + rectangle.X;
3147 int y_half_pos = (rectangle.Height / 2) + rectangle.Y;
3149 graphics.DrawLine (dot_pen, x_half_pos - 1, y_half_pos, x_half_pos + 2, y_half_pos);
3150 graphics.DrawLine (dot_pen, x_half_pos - 1, y_half_pos + 1, x_half_pos + 2, y_half_pos + 1);
3152 graphics.DrawLine (dot_pen, x_half_pos, y_half_pos - 1, x_half_pos, y_half_pos + 2);
3153 graphics.DrawLine (dot_pen, x_half_pos + 1, y_half_pos - 1, x_half_pos + 1, y_half_pos + 2);
3158 public override Size RadioButtonDefaultSize {
3160 return new Size (104,24);
3163 #endregion // RadioButton
3166 public override void DrawScrollBar (Graphics dc, Rectangle clip, ScrollBar bar)
3168 int scrollbutton_width = bar.scrollbutton_width;
3169 int scrollbutton_height = bar.scrollbutton_height;
3170 Rectangle first_arrow_area;
3171 Rectangle second_arrow_area;
3172 Rectangle thumb_pos;
3174 thumb_pos = bar.ThumbPos;
3177 first_arrow_area = new Rectangle(0, 0, bar.Width, scrollbutton_height);
3178 bar.FirstArrowArea = first_arrow_area;
3180 second_arrow_area = new Rectangle(0, bar.ClientRectangle.Height - scrollbutton_height, bar.Width, scrollbutton_height);
3181 bar.SecondArrowArea = second_arrow_area;
3183 thumb_pos.Width = bar.Width;
3184 bar.ThumbPos = thumb_pos;
3187 if (clip.IntersectsWith (first_arrow_area))
3188 CPDrawScrollButton (dc, first_arrow_area, ScrollButton.Up, bar.firstbutton_state);
3189 if (clip.IntersectsWith (second_arrow_area))
3190 CPDrawScrollButton (dc, second_arrow_area, ScrollButton.Down, bar.secondbutton_state);
3193 switch (bar.thumb_moving) {
3194 case ScrollBar.ThumbMoving.None: {
3195 ScrollBar_Vertical_Draw_ThumbMoving_None(scrollbutton_height, bar, clip, dc);
3198 case ScrollBar.ThumbMoving.Forward: {
3199 ScrollBar_Vertical_Draw_ThumbMoving_Forward(scrollbutton_height, bar, thumb_pos, clip, dc);
3203 case ScrollBar.ThumbMoving.Backwards: {
3204 ScrollBar_Vertical_Draw_ThumbMoving_Backwards(scrollbutton_height, bar, thumb_pos, clip, dc);
3212 first_arrow_area = new Rectangle(0, 0, scrollbutton_width, bar.Height);
3213 bar.FirstArrowArea = first_arrow_area;
3215 second_arrow_area = new Rectangle (bar.ClientRectangle.Width - scrollbutton_width, 0, scrollbutton_width, bar.Height);
3216 bar.SecondArrowArea = second_arrow_area;
3218 thumb_pos.Height = bar.Height;
3219 bar.ThumbPos = thumb_pos;
3222 if (clip.IntersectsWith (first_arrow_area))
3223 CPDrawScrollButton (dc, first_arrow_area, ScrollButton.Left, bar.firstbutton_state);
3224 if (clip.IntersectsWith (second_arrow_area))
3225 CPDrawScrollButton (dc, second_arrow_area, ScrollButton.Right, bar.secondbutton_state);
3228 switch (bar.thumb_moving) {
3229 case ScrollBar.ThumbMoving.None: {
3230 ScrollBar_Horizontal_Draw_ThumbMoving_None(scrollbutton_width, bar, clip, dc);
3234 case ScrollBar.ThumbMoving.Forward: {
3235 ScrollBar_Horizontal_Draw_ThumbMoving_Forward(scrollbutton_width, thumb_pos, bar, clip, dc);
3239 case ScrollBar.ThumbMoving.Backwards: {
3240 ScrollBar_Horizontal_Draw_ThumbMoving_Backwards(scrollbutton_width, thumb_pos, bar, clip, dc);
3247 ScrollBar_DrawThumb(bar, thumb_pos, clip, dc);
3250 protected virtual void ScrollBar_DrawThumb(ScrollBar bar, Rectangle thumb_pos, Rectangle clip, Graphics dc)
3252 if (bar.Enabled && thumb_pos.Width > 0 && thumb_pos.Height > 0 && clip.IntersectsWith(thumb_pos))
3253 DrawScrollButtonPrimitive(dc, thumb_pos, ButtonState.Normal);
3256 protected virtual void ScrollBar_Vertical_Draw_ThumbMoving_None( int scrollbutton_height, ScrollBar bar, Rectangle clip, Graphics dc )
3258 Rectangle r = new Rectangle( 0,
3259 scrollbutton_height, bar.ClientRectangle.Width, bar.ClientRectangle.Height - ( scrollbutton_height * 2 ) );
3260 Rectangle intersect = Rectangle.Intersect( clip, r );
3262 if ( intersect != Rectangle.Empty )
3264 Brush h = ResPool.GetHatchBrush( HatchStyle.Percent50, ColorScrollBar, Color.White);
3265 dc.FillRectangle( h, intersect );
3269 protected virtual void ScrollBar_Vertical_Draw_ThumbMoving_Forward( int scrollbutton_height, ScrollBar bar, Rectangle thumb_pos, Rectangle clip, Graphics dc )
3271 Rectangle r = new Rectangle( 0, scrollbutton_height,
3272 bar.ClientRectangle.Width, thumb_pos.Y - scrollbutton_height );
3273 Rectangle intersect = Rectangle.Intersect( clip, r );
3275 if ( intersect != Rectangle.Empty )
3276 dc.FillRectangle( ResPool.GetHatchBrush( HatchStyle.Percent50, ColorScrollBar, Color.White ), intersect );
3279 r.Y = thumb_pos.Y + thumb_pos.Height;
3280 r.Width = bar.ClientRectangle.Width;
3281 r.Height = bar.ClientRectangle.Height - ( thumb_pos.Y + thumb_pos.Height ) - scrollbutton_height;
3283 intersect = Rectangle.Intersect( clip, r );
3284 if ( intersect != Rectangle.Empty )
3285 dc.FillRectangle( ResPool.GetHatchBrush( HatchStyle.Percent50, Color.FromArgb( 255, 63, 63, 63 ), Color.Black ), intersect );
3288 protected virtual void ScrollBar_Vertical_Draw_ThumbMoving_Backwards( int scrollbutton_height, ScrollBar bar, Rectangle thumb_pos, Rectangle clip, Graphics dc )
3290 Rectangle r = new Rectangle( 0, scrollbutton_height,
3291 bar.ClientRectangle.Width, thumb_pos.Y - scrollbutton_height );
3292 Rectangle intersect = Rectangle.Intersect( clip, r );
3294 if ( intersect != Rectangle.Empty )
3295 dc.FillRectangle( ResPool.GetHatchBrush( HatchStyle.Percent50, Color.FromArgb( 255, 63, 63, 63 ), Color.Black ), intersect );
3298 r.Y = thumb_pos.Y + thumb_pos.Height;
3299 r.Width = bar.ClientRectangle.Width;
3300 r.Height = bar.ClientRectangle.Height - ( thumb_pos.Y + thumb_pos.Height ) - scrollbutton_height;
3302 intersect = Rectangle.Intersect( clip, r );
3303 if ( intersect != Rectangle.Empty )
3304 dc.FillRectangle( ResPool.GetHatchBrush( HatchStyle.Percent50, ColorScrollBar, Color.White), intersect );
3307 protected virtual void ScrollBar_Horizontal_Draw_ThumbMoving_None( int scrollbutton_width, ScrollBar bar, Rectangle clip, Graphics dc )
3309 Rectangle r = new Rectangle( scrollbutton_width,
3310 0, bar.ClientRectangle.Width - ( scrollbutton_width * 2 ), bar.ClientRectangle.Height );
3311 Rectangle intersect = Rectangle.Intersect( clip, r );
3313 if ( intersect != Rectangle.Empty )
3314 dc.FillRectangle( ResPool.GetHatchBrush( HatchStyle.Percent50, ColorScrollBar, Color.White), intersect );
3317 protected virtual void ScrollBar_Horizontal_Draw_ThumbMoving_Forward( int scrollbutton_width, Rectangle thumb_pos, ScrollBar bar, Rectangle clip, Graphics dc )
3319 Rectangle r = new Rectangle( scrollbutton_width, 0,
3320 thumb_pos.X - scrollbutton_width, bar.ClientRectangle.Height );
3321 Rectangle intersect = Rectangle.Intersect( clip, r );
3323 if ( intersect != Rectangle.Empty )
3324 dc.FillRectangle( ResPool.GetHatchBrush( HatchStyle.Percent50, ColorScrollBar, Color.White), intersect );
3326 r.X = thumb_pos.X + thumb_pos.Width;
3328 r.Width = bar.ClientRectangle.Width - ( thumb_pos.X + thumb_pos.Width ) - scrollbutton_width;
3329 r.Height = bar.ClientRectangle.Height;
3331 intersect = Rectangle.Intersect( clip, r );
3332 if ( intersect != Rectangle.Empty )
3333 dc.FillRectangle( ResPool.GetHatchBrush( HatchStyle.Percent50, Color.FromArgb( 255, 63, 63, 63 ), Color.Black ), intersect );
3336 protected virtual void ScrollBar_Horizontal_Draw_ThumbMoving_Backwards( int scrollbutton_width, Rectangle thumb_pos, ScrollBar bar, Rectangle clip, Graphics dc )
3338 Rectangle r = new Rectangle( scrollbutton_width, 0,
3339 thumb_pos.X - scrollbutton_width, bar.ClientRectangle.Height );
3340 Rectangle intersect = Rectangle.Intersect( clip, r );
3342 if ( intersect != Rectangle.Empty )
3343 dc.FillRectangle( ResPool.GetHatchBrush( HatchStyle.Percent50, Color.FromArgb( 255, 63, 63, 63 ), Color.Black ), intersect );
3345 r.X = thumb_pos.X + thumb_pos.Width;
3347 r.Width = bar.ClientRectangle.Width - ( thumb_pos.X + thumb_pos.Width ) - scrollbutton_width;
3348 r.Height = bar.ClientRectangle.Height;
3350 intersect = Rectangle.Intersect( clip, r );
3351 if ( intersect != Rectangle.Empty )
3352 dc.FillRectangle( ResPool.GetHatchBrush( HatchStyle.Percent50, ColorScrollBar, Color.White), intersect );
3355 public override int ScrollBarButtonSize {
3358 #endregion // ScrollBar
3361 public override void DrawStatusBar (Graphics dc, Rectangle clip, StatusBar sb) {
3362 Rectangle area = sb.ClientRectangle;
3363 int horz_border = 2;
3364 int vert_border = 2;
3366 bool is_color_control = sb.BackColor.ToArgb () == ColorControl.ToArgb ();
3368 Brush brush = is_color_control ? SystemBrushes.Control : ResPool.GetSolidBrush (sb.BackColor);
3369 dc.FillRectangle (brush, clip);
3371 if (sb.Panels.Count == 0 && sb.Text != String.Empty) {
3372 string text = sb.Text;
3373 StringFormat string_format = new StringFormat ();
3374 string_format.Trimming = StringTrimming.Character;
3375 string_format.FormatFlags = StringFormatFlags.NoWrap;
3377 if (text [0] == '\t') {
3378 string_format.Alignment = StringAlignment.Center;
3379 text = text.Substring (1);
3380 if (text [0] == '\t') {
3381 string_format.Alignment = StringAlignment.Far;
3382 text = text.Substring (1);
3386 dc.DrawString (text, sb.Font, ResPool.GetSolidBrush (sb.ForeColor),
3387 new Rectangle(area.X + 2, area.Y + 2, area.Width - 4, area.Height - 4), string_format);
3388 string_format.Dispose ();
3389 } else if (sb.ShowPanels) {
3390 Brush br_forecolor = GetControlForeBrush (sb.ForeColor);
3391 int prev_x = area.X + horz_border;
3392 int y = area.Y + vert_border;
3393 for (int i = 0; i < sb.Panels.Count; i++) {
3394 Rectangle pr = new Rectangle (prev_x, y,
3395 sb.Panels [i].Width, area.Height);
3396 prev_x += pr.Width + StatusBarHorzGapWidth;
3397 if (pr.IntersectsWith (clip))
3398 DrawStatusBarPanel (dc, pr, i, br_forecolor, sb.Panels [i]);
3402 if (sb.SizingGrip) {
3403 area = new Rectangle (area.Right - 16 - 2, area.Bottom - 12 - 1, 16, 16);
3404 CPDrawSizeGrip (dc, ColorControl, area);
3410 protected virtual void DrawStatusBarPanel (Graphics dc, Rectangle area, int index,
3411 Brush br_forecolor, StatusBarPanel panel) {
3412 int border_size = 3; // this is actually const, even if the border style is none
3413 int icon_width = 16;
3415 area.Height -= border_size;
3417 if (panel.BorderStyle != StatusBarPanelBorderStyle.None) {
3418 Border3DStyle border_style = Border3DStyle.SunkenOuter;
3419 if (panel.BorderStyle == StatusBarPanelBorderStyle.Raised)
3420 border_style = Border3DStyle.RaisedInner;
3422 CPDrawBorder3D(dc, area, border_style, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, panel.Parent.BackColor);
3425 if (panel.Style == StatusBarPanelStyle.OwnerDraw) {
3426 StatusBarDrawItemEventArgs e = new StatusBarDrawItemEventArgs (
3427 dc, panel.Parent.Font, area, index, DrawItemState.Default,
3428 panel, panel.Parent.ForeColor, panel.Parent.BackColor);
3429 panel.Parent.OnDrawItemInternal (e);
3433 if (panel.Text == String.Empty)
3436 string text = panel.Text;
3437 StringFormat string_format = new StringFormat ();
3438 string_format.Trimming = StringTrimming.Character;
3439 string_format.FormatFlags = StringFormatFlags.NoWrap;
3442 if (text [0] == '\t') {
3443 string_format.Alignment = StringAlignment.Center;
3444 text = text.Substring (1);
3445 if (text [0] == '\t') {
3446 string_format.Alignment = StringAlignment.Far;
3447 text = text.Substring (1);
3451 Rectangle string_rect = Rectangle.Empty;
3455 int y = (area.Height / 2 - (int) panel.Parent.Font.Size / 2) - 1;
3457 switch (panel.Alignment) {
3458 case HorizontalAlignment.Right:
3459 len = (int) dc.MeasureString (text, panel.Parent.Font).Width;
3460 x = area.Right - len - 4;
3461 string_rect = new Rectangle (x, y,
3462 area.Right - x - border_size,
3463 area.Bottom - y - border_size);
3464 if (panel.Icon != null) {
3465 icon_x = x - icon_width - 2;
3468 case HorizontalAlignment.Center:
3469 len = (int) dc.MeasureString (text, panel.Parent.Font).Width;
3470 x = (panel.Width / 2) + (len / 2);
3471 string_rect = new Rectangle (x, y,
3472 area.Right - x - border_size,
3473 area.Bottom - y - border_size);
3475 if (panel.Icon != null) {
3476 icon_x = x - icon_width - 2;
3482 int left = area.Left + border_size;;
3483 if (panel.Icon != null) {
3484 icon_x = area.Left + 2;
3485 left = icon_x + icon_width + 2;
3489 string_rect = new Rectangle (x, y,
3490 area.Right - x - border_size,
3491 area.Bottom - y - border_size);
3495 dc.DrawString (text, panel.Parent.Font, br_forecolor, string_rect, string_format);
3497 if (panel.Icon != null) {
3498 dc.DrawIcon (panel.Icon, new Rectangle (icon_x, y, icon_width, icon_width));
3502 public override int StatusBarSizeGripWidth {
3506 public override int StatusBarHorzGapWidth {
3510 public override Size StatusBarDefaultSize {
3512 return new Size (100, 22);
3515 #endregion // StatusBar
3517 public override void DrawTabControl (Graphics dc, Rectangle area, TabControl tab)
3519 Brush brush = SystemBrushes.Control;
3520 dc.FillRectangle (brush, area);
3521 Rectangle panel_rect = GetTabPanelRectExt (tab);
3523 if (tab.Appearance == TabAppearance.Normal) {
3524 CPDrawBorder3D (dc, panel_rect, Border3DStyle.RaisedInner, Border3DSide.Left | Border3DSide.Top, ColorControl);
3525 CPDrawBorder3D (dc, panel_rect, Border3DStyle.Raised, Border3DSide.Right | Border3DSide.Bottom, ColorControl);
3528 if (tab.Alignment == TabAlignment.Top) {
3529 for (int r = tab.TabPages.Count; r > 0; r--) {
3530 for (int i = tab.SliderPos; i < tab.TabPages.Count; i++) {
3531 if (i == tab.SelectedIndex)
3533 if (r != tab.TabPages [i].Row)
3535 Rectangle rect = tab.GetTabRect (i);
3536 if (!rect.IntersectsWith (area))
3538 DrawTab (dc, tab.TabPages [i], tab, rect, false);
3542 for (int r = 0; r < tab.TabPages.Count; r++) {
3543 for (int i = tab.SliderPos; i < tab.TabPages.Count; i++) {
3544 if (i == tab.SelectedIndex)
3546 if (r != tab.TabPages [i].Row)
3548 Rectangle rect = tab.GetTabRect (i);
3549 if (!rect.IntersectsWith (area))
3551 DrawTab (dc, tab.TabPages [i], tab, rect, false);
3556 if (tab.SelectedIndex != -1 && tab.SelectedIndex >= tab.SliderPos) {
3557 Rectangle rect = tab.GetTabRect (tab.SelectedIndex);
3558 if (rect.IntersectsWith (area))
3559 DrawTab (dc, tab.TabPages [tab.SelectedIndex], tab, rect, true);
3562 if (tab.ShowSlider) {
3563 Rectangle right = GetTabControlRightScrollRect (tab);
3564 Rectangle left = GetTabControlLeftScrollRect (tab);
3565 CPDrawScrollButton (dc, right, ScrollButton.Right, tab.RightSliderState);
3566 CPDrawScrollButton (dc, left, ScrollButton.Left, tab.LeftSliderState);
3570 public override Rectangle GetTabControlLeftScrollRect (TabControl tab)
3572 switch (tab.Alignment) {
3573 case TabAlignment.Top:
3574 return new Rectangle (tab.ClientRectangle.Right - 34, tab.ClientRectangle.Top + 1, 17, 17);
3576 Rectangle panel_rect = GetTabPanelRectExt (tab);
3577 return new Rectangle (tab.ClientRectangle.Right - 34, panel_rect.Bottom + 2, 17, 17);
3581 public override Rectangle GetTabControlRightScrollRect (TabControl tab)
3583 switch (tab.Alignment) {
3584 case TabAlignment.Top:
3585 return new Rectangle (tab.ClientRectangle.Right - 17, tab.ClientRectangle.Top + 1, 17, 17);
3587 Rectangle panel_rect = GetTabPanelRectExt (tab);
3588 return new Rectangle (tab.ClientRectangle.Right - 17, panel_rect.Bottom + 2, 17, 17);
3592 public override Size TabControlDefaultItemSize {
3593 get { return new Size (42, 21); }
3596 public override Point TabControlDefaultPadding {
3597 get { return new Point (6, 3); }
3600 public override int TabControlMinimumTabWidth {
3604 public override Rectangle GetTabControlDisplayRectangle (TabControl tab)
3606 Rectangle ext = GetTabPanelRectExt (tab);
3607 // Account for border size
3608 return new Rectangle (ext.Left + 2, ext.Top + 1, ext.Width - 6, ext.Height - 4);
3611 public override Size TabControlGetSpacing (TabControl tab) {
3612 switch (tab.Appearance) {
3613 case TabAppearance.Normal:
3614 return new Size (1, -2);
3615 case TabAppearance.Buttons:
3616 return new Size (3, 3);
3617 case TabAppearance.FlatButtons:
3618 return new Size (9, 3);
3620 throw new Exception ("Invalid Appearance value: " + tab.Appearance);
3624 protected virtual Rectangle GetTabPanelRectExt (TabControl tab)
3626 // Offset the tab from the top corner
3627 Rectangle res = new Rectangle (tab.ClientRectangle.X + 2,
3628 tab.ClientRectangle.Y,
3629 tab.ClientRectangle.Width - 2,
3630 tab.ClientRectangle.Height - 1);
3632 if (tab.TabCount == 0)
3635 int spacing = TabControlGetSpacing (tab).Height;
3636 int offset = (tab.ItemSize.Height + spacing) * tab.RowCount + 3;
3638 switch (tab.Alignment) {
3639 case TabAlignment.Left:
3641 res.Width -= offset;
3643 case TabAlignment.Right:
3644 res.Width -= offset;
3646 case TabAlignment.Top:
3648 res.Height -= offset;
3650 case TabAlignment.Bottom:
3651 res.Height -= offset;
3658 protected virtual int DrawTab (Graphics dc, TabPage page, TabControl tab, Rectangle bounds, bool is_selected)
3660 int FlatButtonSpacing = 8;
3662 int res = bounds.Width;
3666 // we can't fill the background right away because the bounds might be adjusted if the tab is selected
3668 StringFormat string_format = new StringFormat ();
3669 if (tab.Appearance == TabAppearance.Buttons || tab.Appearance == TabAppearance.FlatButtons) {
3670 dc.FillRectangle (ResPool.GetSolidBrush (tab.BackColor), bounds);
3673 if (tab.Appearance == TabAppearance.FlatButtons) {
3674 int width = bounds.Width;
3675 bounds.Width += (FlatButtonSpacing - 2);
3677 CPDrawBorder3D (dc, bounds, Border3DStyle.Etched, Border3DSide.Right);
3678 bounds.Width = width;
3682 CPDrawBorder3D (dc, bounds, Border3DStyle.Sunken, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom);
3683 } else if (tab.Appearance != TabAppearance.FlatButtons) {
3684 CPDrawBorder3D (dc, bounds, Border3DStyle.Raised, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom);
3687 interior = new Rectangle (bounds.Left + 2, bounds.Top + 2, bounds.Width - 4, bounds.Height - 4);
3690 string_format.Alignment = StringAlignment.Center;
3691 string_format.LineAlignment = StringAlignment.Center;
3692 string_format.FormatFlags = StringFormatFlags.NoWrap;
3694 CPColor cpcolor = ResPool.GetCPColor (tab.BackColor);
3696 Pen light = ResPool.GetPen (cpcolor.LightLight);
3698 switch (tab.Alignment) {
3700 case TabAlignment.Top:
3702 dc.FillRectangle (ResPool.GetSolidBrush (tab.BackColor), bounds);
3704 dc.DrawLine (light, bounds.Left, bounds.Bottom, bounds.Left, bounds.Top + 3);
3705 dc.DrawLine (light, bounds.Left, bounds.Top + 3, bounds.Left + 3, bounds.Top);
3706 dc.DrawLine (light, bounds.Left + 3, bounds.Top, bounds.Right - 3, bounds.Top);
3708 dc.DrawLine (SystemPens.ControlDark, bounds.Right - 1, bounds.Top + 1, bounds.Right - 1, bounds.Bottom);
3709 dc.DrawLine (SystemPens.ControlDarkDark, bounds.Right - 1, bounds.Top + 2, bounds.Right, bounds.Top + 3);
3710 dc.DrawLine (SystemPens.ControlDarkDark, bounds.Right, bounds.Top + 3, bounds.Right, bounds.Bottom);
3712 interior = new Rectangle (bounds.Left + 4, bounds.Top + 4, bounds.Width - 8, bounds.Height - 8);
3714 string_format.Alignment = StringAlignment.Center;
3715 string_format.LineAlignment = StringAlignment.Center;
3716 string_format.FormatFlags = StringFormatFlags.NoWrap;
3720 case TabAlignment.Bottom:
3722 dc.FillRectangle (ResPool.GetSolidBrush (tab.BackColor), bounds);
3724 dc.DrawLine (light, bounds.Left, bounds.Top, bounds.Left, bounds.Bottom - 3);
3725 dc.DrawLine (light, bounds.Left, bounds.Bottom - 3, bounds.Left + 2, bounds.Bottom - 1);
3727 dc.DrawLine (SystemPens.ControlDark, bounds.Left + 3, bounds.Bottom - 1, bounds.Right - 3, bounds.Bottom - 1);
3728 dc.DrawLine (SystemPens.ControlDark, bounds.Right - 1, bounds.Bottom - 3, bounds.Right - 1, bounds.Top);
3730 dc.DrawLine (SystemPens.ControlDarkDark, bounds.Left + 3, bounds.Bottom, bounds.Right - 3, bounds.Bottom);
3731 dc.DrawLine (SystemPens.ControlDarkDark, bounds.Right - 3, bounds.Bottom, bounds.Right, bounds.Bottom - 3);
3732 dc.DrawLine (SystemPens.ControlDarkDark, bounds.Right, bounds.Bottom - 3, bounds.Right, bounds.Top);
3734 interior = new Rectangle (bounds.Left + 4, bounds.Top + 4, bounds.Width - 8, bounds.Height - 8);
3736 string_format.Alignment = StringAlignment.Center;
3737 string_format.LineAlignment = StringAlignment.Center;
3738 string_format.FormatFlags = StringFormatFlags.NoWrap;
3742 case TabAlignment.Left:
3744 dc.FillRectangle (ResPool.GetSolidBrush (tab.BackColor), bounds);
3746 dc.DrawLine (light, bounds.Left, bounds.Bottom - 3, bounds.Left, bounds.Top + 3);
3747 dc.DrawLine (light, bounds.Left, bounds.Top + 3, bounds.Left + 3, bounds.Top);
3748 dc.DrawLine (light, bounds.Left + 3, bounds.Top, bounds.Right, bounds.Top);
3750 dc.DrawLine (SystemPens.ControlDark, bounds.Right, bounds.Bottom - 1, bounds.Left + 2, bounds.Bottom - 1);
3752 dc.DrawLine (SystemPens.ControlDarkDark, bounds.Right, bounds.Bottom, bounds.Left + 2, bounds.Bottom);
3753 dc.DrawLine (SystemPens.ControlDarkDark, bounds.Left + 2, bounds.Bottom, bounds.Left, bounds.Bottom - 3);
3755 interior = new Rectangle (bounds.Left + 4, bounds.Top + 4, bounds.Width - 8, bounds.Height - 8);
3757 string_format.Alignment = StringAlignment.Center;
3758 string_format.LineAlignment = StringAlignment.Center;
3759 string_format.FormatFlags = StringFormatFlags.NoWrap;
3760 string_format.FormatFlags = StringFormatFlags.DirectionVertical;
3765 // TabAlignment.Right
3767 dc.FillRectangle (ResPool.GetSolidBrush (tab.BackColor), bounds);
3769 dc.DrawLine (light, bounds.Left, bounds.Top, bounds.Right - 3, bounds.Top);
3770 dc.DrawLine (light, bounds.Right - 3, bounds.Top, bounds.Right, bounds.Top + 3);
3772 dc.DrawLine (SystemPens.ControlDark, bounds.Right - 1, bounds.Top + 1, bounds.Right - 1, bounds.Bottom - 1);
3773 dc.DrawLine (SystemPens.ControlDark, bounds.Left, bounds.Bottom - 1, bounds.Right - 2, bounds.Bottom - 1);
3775 dc.DrawLine (SystemPens.ControlDarkDark, bounds.Right, bounds.Top + 3, bounds.Right, bounds.Bottom - 3);
3776 dc.DrawLine (SystemPens.ControlDarkDark, bounds.Left, bounds.Bottom, bounds.Right - 3, bounds.Bottom);
3778 interior = new Rectangle (bounds.Left + 4, bounds.Top + 4, bounds.Width - 8, bounds.Height - 8);
3780 string_format.Alignment = StringAlignment.Center;
3781 string_format.LineAlignment = StringAlignment.Center;
3782 string_format.FormatFlags = StringFormatFlags.NoWrap;
3783 string_format.FormatFlags = StringFormatFlags.DirectionVertical;
3789 if (tab.DrawMode == TabDrawMode.Normal && page.Text != null) {
3790 if (tab.Alignment == TabAlignment.Left) {
3791 int wo = interior.Width / 2;
3792 int ho = interior.Height / 2;
3793 dc.TranslateTransform (interior.X + wo, interior.Y + ho);
3794 dc.RotateTransform (180);
3795 dc.DrawString (page.Text, page.Font, SystemBrushes.ControlText, 0, 0, string_format);
3796 dc.ResetTransform ();
3798 Rectangle str_rect = interior;
3800 if (tab.ImageList != null && page.ImageIndex >= 0 && page.ImageIndex < tab.ImageList.Images.Count) {
3801 tab.ImageList.Draw (dc, new Point (interior.X, interior.Y), page.ImageIndex);
3802 str_rect.X += tab.ImageList.ImageSize.Width + 2;
3803 str_rect.Width -= tab.ImageList.ImageSize.Width + 2;
3805 dc.DrawString (page.Text, page.Font,
3806 SystemBrushes.ControlText,
3807 str_rect, string_format);
3809 } else if (page.Text != null) {
3810 DrawItemState state = DrawItemState.None;
3811 if (page == tab.SelectedTab)
3812 state |= DrawItemState.Selected;
3813 DrawItemEventArgs e = new DrawItemEventArgs (dc,
3814 tab.Font, bounds, tab.IndexForTabPage (page),
3815 state, page.ForeColor, page.BackColor);
3816 tab.OnDrawItemInternal (e);
3820 if (page.parent.Focused && is_selected) {
3821 CPDrawFocusRectangle (dc, interior, tab.ForeColor, tab.BackColor);
3828 public override void DrawToolBar (Graphics dc, Rectangle clip_rectangle, ToolBar control)
3830 StringFormat format = new StringFormat ();
3831 format.Trimming = StringTrimming.EllipsisCharacter;
3832 format.LineAlignment = StringAlignment.Center;
3833 if (control.TextAlign == ToolBarTextAlign.Underneath)
3834 format.Alignment = StringAlignment.Center;
3836 format.Alignment = StringAlignment.Near;
3838 if (control is PropertyGrid.PropertyToolBar) {
3839 dc.FillRectangle (ResPool.GetSolidBrush(control.BackColor), clip_rectangle);
3841 if (clip_rectangle.X == 0) {
3842 dc.DrawLine (SystemPens.ControlLightLight, clip_rectangle.X, 1, clip_rectangle.X, control.Bottom);
3845 if (clip_rectangle.Y < 2) {
3846 dc.DrawLine (SystemPens.ControlLightLight, clip_rectangle.X, 1, clip_rectangle.Right, 1);
3849 if (clip_rectangle.Bottom == control.Bottom) {
3850 dc.DrawLine (SystemPens.ControlDark, clip_rectangle.X, clip_rectangle.Bottom - 1, clip_rectangle.Right, clip_rectangle.Bottom - 1);
3853 if (clip_rectangle.Right == control.Right) {
3854 dc.DrawLine (SystemPens.ControlDark, clip_rectangle.Right - 1, 1, clip_rectangle.Right - 1, control.Bottom - 1);
3858 if (control.Appearance == ToolBarAppearance.Flat && control.Parent != null) {
3859 if (control.Parent.BackgroundImage != null) {
3860 using (TextureBrush b = new TextureBrush (control.Parent.BackgroundImage, WrapMode.Tile))
3861 dc.FillRectangle (b, clip_rectangle);
3863 dc.FillRectangle (ResPool.GetSolidBrush (control.Parent.BackColor), clip_rectangle);
3866 dc.FillRectangle (SystemBrushes.Control, clip_rectangle);
3869 if (control.Divider && clip_rectangle.Y < 2) {
3870 if (clip_rectangle.Y < 1) {
3871 dc.DrawLine (SystemPens.ControlDark, clip_rectangle.X, 0, clip_rectangle.Right, 0);
3873 dc.DrawLine (SystemPens.ControlLightLight, clip_rectangle.X, 1, clip_rectangle.Right, 1);
3877 foreach (ToolBarButton button in control.Buttons)
3878 if (button.Visible && clip_rectangle.IntersectsWith (button.Rectangle))
3879 DrawToolBarButton (dc, control, button, format);
3884 protected virtual void DrawToolBarButton (Graphics dc, ToolBar control, ToolBarButton button, StringFormat format)
3886 bool is_flat = control.Appearance == ToolBarAppearance.Flat;
3888 DrawToolBarButtonBorder (dc, button, is_flat);
3890 switch (button.Style) {
3891 case ToolBarButtonStyle.DropDownButton:
3892 if (control.DropDownArrows)
3893 DrawToolBarDropDownArrow (dc, button, is_flat);
3894 DrawToolBarButtonContents (dc, control, button, format);
3897 case ToolBarButtonStyle.Separator:
3899 DrawToolBarSeparator (dc, button);
3902 case ToolBarButtonStyle.ToggleButton:
3903 DrawToolBarToggleButtonBackground (dc, button);
3904 DrawToolBarButtonContents (dc, control, button, format);
3908 DrawToolBarButtonContents (dc, control, button, format);
3913 const Border3DSide all_sides = Border3DSide.Left | Border3DSide.Top | Border3DSide.Right | Border3DSide.Bottom;
3915 protected virtual void DrawToolBarButtonBorder (Graphics dc, ToolBarButton button, bool is_flat)
3917 if (button.Style == ToolBarButtonStyle.Separator)
3920 Border3DStyle style;
3923 if (button.Pushed || button.Pressed)
3924 style = Border3DStyle.SunkenOuter;
3925 else if (button.Hilight)
3926 style = Border3DStyle.RaisedInner;
3931 if (button.Pushed || button.Pressed)
3932 style = Border3DStyle.Sunken;
3934 style = Border3DStyle.Raised;
3937 CPDrawBorder3D (dc, button.Rectangle, style, all_sides);
3940 protected virtual void DrawToolBarSeparator (Graphics dc, ToolBarButton button)
3942 Rectangle area = button.Rectangle;
3943 int offset = (int) SystemPens.Control.Width + 1;
3944 dc.DrawLine (SystemPens.ControlDark, area.X + 1, area.Y, area.X + 1, area.Bottom);
3945 dc.DrawLine (SystemPens.ControlLight, area.X + offset, area.Y, area.X + offset, area.Bottom);
3948 protected virtual void DrawToolBarToggleButtonBackground (Graphics dc, ToolBarButton button)
3950 Rectangle area = button.Rectangle;
3951 area.X += ToolBarImageGripWidth;
3952 area.Y += ToolBarImageGripWidth;
3953 area.Width -= 2 * ToolBarImageGripWidth;
3954 area.Height -= 2 * ToolBarImageGripWidth;
3957 dc.FillRectangle (SystemBrushes.ControlLightLight, area);
3958 else if (button.PartialPush)
3959 dc.FillRectangle (SystemBrushes.ControlLight, area);
3961 dc.FillRectangle (SystemBrushes.Control, area);
3964 protected virtual void DrawToolBarDropDownArrow (Graphics dc, ToolBarButton button, bool is_flat)
3966 Rectangle rect = button.Rectangle;
3967 rect.X = button.Rectangle.Right - ToolBarDropDownWidth;
3968 rect.Width = ToolBarDropDownWidth;
3970 if (button.dd_pressed) {
3971 CPDrawBorder3D (dc, rect, Border3DStyle.SunkenOuter, all_sides);
3972 CPDrawBorder3D (dc, rect, Border3DStyle.SunkenInner, Border3DSide.Bottom | Border3DSide.Right);
3973 } else if (button.Pushed || button.Pressed)
3974 CPDrawBorder3D (dc, rect, Border3DStyle.Sunken, all_sides);
3977 CPDrawBorder3D (dc, rect, Border3DStyle.RaisedOuter, all_sides);
3979 CPDrawBorder3D (dc, rect, Border3DStyle.Raised, all_sides);
3981 PointF [] vertices = new PointF [3];
3982 PointF ddCenter = new PointF (rect.X + (rect.Width/2.0f), rect.Y + (rect.Height/2.0f));
3983 vertices [0].X = ddCenter.X - ToolBarDropDownArrowWidth / 2.0f + 0.5f;
3984 vertices [0].Y = ddCenter.Y;
3985 vertices [1].X = ddCenter.X + ToolBarDropDownArrowWidth / 2.0f + 0.5f;
3986 vertices [1].Y = ddCenter.Y;
3987 vertices [2].X = ddCenter.X + 0.5f; // 0.5 is added for adjustment
3988 vertices [2].Y = ddCenter.Y + ToolBarDropDownArrowHeight;
3989 dc.FillPolygon (SystemBrushes.ControlText, vertices);
3992 protected virtual void DrawToolBarButtonContents (Graphics dc, ToolBar control, ToolBarButton button, StringFormat format)
3994 if (button.Image != null) {
3995 int x = button.ImageRectangle.X + ToolBarImageGripWidth;
3996 int y = button.ImageRectangle.Y + ToolBarImageGripWidth;
3998 dc.DrawImage (button.Image, x, y);
4000 CPDrawImageDisabled (dc, button.Image, x, y, ColorControl);
4003 Rectangle text_rect = button.TextRectangle;
4004 if (text_rect.Width <= 0 || text_rect.Height <= 0)
4008 dc.DrawString (button.Text, control.Font, SystemBrushes.ControlText, text_rect, format);
4010 CPDrawStringDisabled (dc, button.Text, control.Font, control.BackColor, text_rect, format);
4013 // Grip width for the ToolBar
4014 public override int ToolBarGripWidth {
4018 // Grip width for the Image on the ToolBarButton
4019 public override int ToolBarImageGripWidth {
4023 // width of the separator
4024 public override int ToolBarSeparatorWidth {
4028 // width of the dropdown arrow rect
4029 public override int ToolBarDropDownWidth {
4033 // width for the dropdown arrow on the ToolBarButton
4034 public override int ToolBarDropDownArrowWidth {
4038 // height for the dropdown arrow on the ToolBarButton
4039 public override int ToolBarDropDownArrowHeight {
4043 public override Size ToolBarDefaultSize {
4045 return new Size (100, 42);
4049 public override bool ToolBarInvalidateEntireButton {
4050 get { return false; }
4053 #endregion // ToolBar
4056 public override void DrawToolTip(Graphics dc, Rectangle clip_rectangle, ToolTip.ToolTipWindow control) {
4057 dc.FillRectangle(SystemBrushes.Info, control.client_rect);
4058 dc.DrawRectangle(SystemPens.WindowFrame, 0, 0, control.Width-1, control.Height-1);
4059 dc.DrawString(control.text, control.Font, ResPool.GetSolidBrush(this.ColorInfoText), control.client_rect, control.string_format);
4062 public override Size ToolTipSize(ToolTip.ToolTipWindow tt, string text) {
4065 sizef = tt.DeviceContext.MeasureString(text, tt.Font);
4066 return new Size((int)sizef.Width+8, (int)sizef.Height+3); // Need space for the border
4068 #endregion // ToolTip
4071 private void DrawTrackBar_Vertical (Graphics dc, Rectangle clip_rectangle, TrackBar tb,
4072 ref Rectangle thumb_pos, ref Rectangle thumb_area, Brush br_thumb,
4073 float ticks, int value_pos, bool mouse_value) {
4075 Point toptick_startpoint = new Point ();
4076 Point bottomtick_startpoint = new Point ();
4077 Point channel_startpoint = new Point ();
4079 float pixels_betweenticks;
4080 const int space_from_right = 8;
4081 const int space_from_left = 8;
4082 const int space_from_bottom = 11;
4083 Rectangle area = tb.ClientRectangle;
4085 switch (tb.TickStyle) {
4086 case TickStyle.BottomRight:
4087 case TickStyle.None:
4088 channel_startpoint.Y = 8;
4089 channel_startpoint.X = 9;
4090 bottomtick_startpoint.Y = 13;
4091 bottomtick_startpoint.X = 24;
4093 case TickStyle.TopLeft:
4094 channel_startpoint.Y = 8;
4095 channel_startpoint.X = 19;
4096 toptick_startpoint.Y = 13;
4097 toptick_startpoint.X = 8;
4099 case TickStyle.Both:
4100 channel_startpoint.Y = 8;
4101 channel_startpoint.X = 18;
4102 bottomtick_startpoint.Y = 13;
4103 bottomtick_startpoint.X = 32;
4104 toptick_startpoint.Y = 13;
4105 toptick_startpoint.X = 8;
4111 thumb_area.X = area.X + channel_startpoint.X;
4112 thumb_area.Y = area.Y + channel_startpoint.Y;
4113 thumb_area.Height = area.Height - space_from_right - space_from_left;
4114 thumb_area.Width = 4;
4117 dc.FillRectangle (SystemBrushes.ControlDark, channel_startpoint.X, channel_startpoint.Y,
4118 1, thumb_area.Height);
4120 dc.FillRectangle (SystemBrushes.ControlDarkDark, channel_startpoint.X + 1, channel_startpoint.Y,
4121 1, thumb_area.Height);
4123 dc.FillRectangle (SystemBrushes.ControlLight, channel_startpoint.X + 3, channel_startpoint.Y,
4124 1, thumb_area.Height);
4126 pixel_len = thumb_area.Height - 11;
4127 pixels_betweenticks = pixel_len / (tb.Maximum - tb.Minimum);
4129 /* Convert thumb position from mouse position to value*/
4131 if (value_pos < thumb_area.Bottom)
4132 value_pos = (int) ((thumb_area.Bottom - value_pos) / pixels_betweenticks);
4136 if (value_pos + tb.Minimum > tb.Maximum)
4137 value_pos = tb.Maximum - tb.Minimum;
4139 tb.Value = value_pos + tb.Minimum;
4142 // thumb_pos.Y = channel_startpoint.Y ; // + (int) (pixels_betweenticks * (float) value_pos);
4143 thumb_pos.Y = thumb_area.Bottom - space_from_bottom - (int) (pixels_betweenticks * (float) value_pos);
4145 /* Draw thumb fixed 10x22 size */
4146 thumb_pos.Width = 10;
4147 thumb_pos.Height = 22;
4149 switch (tb.TickStyle) {
4150 case TickStyle.BottomRight:
4151 case TickStyle.None: {
4152 thumb_pos.X = channel_startpoint.X - 8;
4154 Pen pen = SystemPens.ControlLight;
4155 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X , thumb_pos.Y + 10);
4156 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X + 16, thumb_pos.Y);
4157 dc.DrawLine (pen, thumb_pos.X + 16, thumb_pos.Y, thumb_pos.X + 16 + 4, thumb_pos.Y + 4);
4159 pen = SystemPens.ControlDark;
4160 dc.DrawLine (pen, thumb_pos.X +1, thumb_pos.Y + 9, thumb_pos.X +15, thumb_pos.Y +9);
4161 dc.DrawLine (pen, thumb_pos.X + 16, thumb_pos.Y + 9, thumb_pos.X +16 + 4, thumb_pos.Y +9 - 4);
4163 pen = SystemPens.ControlDarkDark;
4164 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 10, thumb_pos.X +16, thumb_pos.Y +10);
4165 dc.DrawLine (pen, thumb_pos.X + 16, thumb_pos.Y + 10, thumb_pos.X +16 + 5, thumb_pos.Y +10 - 5);
4167 dc.FillRectangle (br_thumb, thumb_pos.X + 1, thumb_pos.Y + 1, 16, 8);
4168 dc.FillRectangle (br_thumb, thumb_pos.X + 17, thumb_pos.Y + 2, 1, 6);
4169 dc.FillRectangle (br_thumb, thumb_pos.X + 18, thumb_pos.Y + 3, 1, 4);
4170 dc.FillRectangle (br_thumb, thumb_pos.X + 19, thumb_pos.Y + 4, 1, 2);
4174 case TickStyle.TopLeft: {
4175 thumb_pos.X = channel_startpoint.X - 10;
4177 Pen pen = SystemPens.ControlLight;
4178 dc.DrawLine (pen, thumb_pos.X + 4, thumb_pos.Y, thumb_pos.X + 4 + 16, thumb_pos.Y);
4179 dc.DrawLine (pen, thumb_pos.X + 4, thumb_pos.Y, thumb_pos.X, thumb_pos.Y + 4);
4181 pen = SystemPens.ControlDark;
4182 dc.DrawLine (pen, thumb_pos.X + 4, thumb_pos.Y + 9, thumb_pos.X + 4 + 16 , thumb_pos.Y+ 9);
4183 dc.DrawLine (pen, thumb_pos.X + 4, thumb_pos.Y + 9, thumb_pos.X, thumb_pos.Y + 5);
4184 dc.DrawLine (pen, thumb_pos.X + 19, thumb_pos.Y + 9, thumb_pos.X +19 , thumb_pos.Y+ 1);
4186 pen = SystemPens.ControlDarkDark;
4187 dc.DrawLine (pen, thumb_pos.X + 4, thumb_pos.Y+ 10, thumb_pos.X + 4 + 16, thumb_pos.Y+ 10);
4188 dc.DrawLine (pen, thumb_pos.X + 4, thumb_pos.Y + 10, thumb_pos.X -1, thumb_pos.Y+ 5);
4189 dc.DrawLine (pen, thumb_pos.X + 20, thumb_pos.Y, thumb_pos.X+ 20, thumb_pos.Y + 10);
4191 dc.FillRectangle (br_thumb, thumb_pos.X + 4, thumb_pos.Y + 1, 15, 8);
4192 dc.FillRectangle (br_thumb, thumb_pos.X + 3, thumb_pos.Y + 2, 1, 6);
4193 dc.FillRectangle (br_thumb, thumb_pos.X + 2, thumb_pos.Y + 3, 1, 4);
4194 dc.FillRectangle (br_thumb, thumb_pos.X + 1, thumb_pos.Y + 4, 1, 2);
4199 case TickStyle.Both: {
4200 thumb_pos.X = area.X + 10;
4202 Pen pen = SystemPens.ControlLight;
4203 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X, thumb_pos.Y + 9);
4204 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X + 19, thumb_pos.Y);
4206 pen = SystemPens.ControlDark;
4207 dc.DrawLine (pen, thumb_pos.X + 1, thumb_pos.Y + 9, thumb_pos.X+ 19, thumb_pos.Y + 9);
4208 dc.DrawLine (pen, thumb_pos.X + 10, thumb_pos.Y+ 1, thumb_pos.X + 19, thumb_pos.Y + 8);
4210 pen = SystemPens.ControlDarkDark;
4211 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 10, thumb_pos.X+ 20, thumb_pos.Y +10);
4212 dc.DrawLine (pen, thumb_pos.X + 20, thumb_pos.Y, thumb_pos.X + 20, thumb_pos.Y+ 9);
4214 dc.FillRectangle (br_thumb, thumb_pos.X + 1, thumb_pos.Y + 1, 18, 8);
4223 pixel_len = thumb_area.Height - 11;
4224 pixels_betweenticks = pixel_len / ticks;
4226 thumb_area.X = thumb_pos.X;
4227 thumb_area.Y = channel_startpoint.Y;
4228 thumb_area.Width = thumb_pos.Height;
4231 Region outside = new Region (area);
4232 outside.Exclude (thumb_area);
4234 if (outside.IsVisible (clip_rectangle)) {
4235 if (pixels_betweenticks > 0 && ((tb.TickStyle & TickStyle.BottomRight) == TickStyle.BottomRight ||
4236 ((tb.TickStyle & TickStyle.Both) == TickStyle.Both))) {
4238 for (float inc = 0; inc < (pixel_len + 1); inc += pixels_betweenticks) {
4239 if (inc == 0 || (inc + pixels_betweenticks) >= pixel_len +1)
4240 dc.DrawLine (ResPool.GetPen (pen_ticks_color), area.X + bottomtick_startpoint.X , area.Y + bottomtick_startpoint.Y + inc,
4241 area.X + bottomtick_startpoint.X + 3, area.Y + bottomtick_startpoint.Y + inc);
4243 dc.DrawLine (ResPool.GetPen (pen_ticks_color), area.X + bottomtick_startpoint.X, area.Y + bottomtick_startpoint.Y + inc,
4244 area.X + bottomtick_startpoint.X + 2, area.Y + bottomtick_startpoint.Y + inc);
4248 if (pixels_betweenticks > 0 && ((tb.TickStyle & TickStyle.TopLeft) == TickStyle.TopLeft ||
4249 ((tb.TickStyle & TickStyle.Both) == TickStyle.Both))) {
4251 pixel_len = thumb_area.Height - 11;
4252 pixels_betweenticks = pixel_len / ticks;
4254 for (float inc = 0; inc < (pixel_len + 1); inc += pixels_betweenticks) {
4255 if (inc == 0 || (inc + pixels_betweenticks) >= pixel_len +1)
4256 dc.DrawLine (ResPool.GetPen (pen_ticks_color), area.X + toptick_startpoint.X - 3 , area.Y + toptick_startpoint.Y + inc,
4257 area.X + toptick_startpoint.X, area.Y + toptick_startpoint.Y + inc);
4259 dc.DrawLine (ResPool.GetPen (pen_ticks_color), area.X + toptick_startpoint.X - 2, area.Y + toptick_startpoint.Y + inc,
4260 area.X + toptick_startpoint.X, area.Y + toptick_startpoint.Y + inc);
4272 Does not matter the size of the control, Win32 always draws:
4273 - Ticks starting from pixel 13, 8
4274 - Channel starting at pos 8, 19 and ends at Width - 8
4275 - Autosize makes always the control 40 pixels height
4276 - Ticks are draw at (channel.Witdh - 10) / (Maximum - Minimum)
4279 private void DrawTrackBar_Horizontal (Graphics dc, Rectangle clip_rectangle, TrackBar tb,
4280 ref Rectangle thumb_pos, ref Rectangle thumb_area, Brush br_thumb,
4281 float ticks, int value_pos, bool mouse_value) {
4282 Point toptick_startpoint = new Point ();
4283 Point bottomtick_startpoint = new Point ();
4284 Point channel_startpoint = new Point ();
4286 float pixels_betweenticks;
4287 const int space_from_right = 8;
4288 const int space_from_left = 8;
4289 Rectangle area = tb.ClientRectangle;
4291 switch (tb.TickStyle) {
4292 case TickStyle.BottomRight:
4293 case TickStyle.None:
4294 channel_startpoint.X = 8;
4295 channel_startpoint.Y = 9;
4296 bottomtick_startpoint.X = 13;
4297 bottomtick_startpoint.Y = 24;
4299 case TickStyle.TopLeft:
4300 channel_startpoint.X = 8;
4301 channel_startpoint.Y = 19;
4302 toptick_startpoint.X = 13;
4303 toptick_startpoint.Y = 8;
4305 case TickStyle.Both:
4306 channel_startpoint.X = 8;
4307 channel_startpoint.Y = 18;
4308 bottomtick_startpoint.X = 13;
4309 bottomtick_startpoint.Y = 32;
4310 toptick_startpoint.X = 13;
4311 toptick_startpoint.Y = 8;
4317 thumb_area.X = area.X + channel_startpoint.X;
4318 thumb_area.Y = area.Y + channel_startpoint.Y;
4319 thumb_area.Width = area.Width - space_from_right - space_from_left;
4320 thumb_area.Height = 4;
4323 dc.FillRectangle (SystemBrushes.ControlDark, channel_startpoint.X, channel_startpoint.Y,
4324 thumb_area.Width, 1);
4326 dc.FillRectangle (SystemBrushes.ControlDarkDark, channel_startpoint.X, channel_startpoint.Y + 1,
4327 thumb_area.Width, 1);
4329 dc.FillRectangle (SystemBrushes.ControlLight, channel_startpoint.X, channel_startpoint.Y +3,
4330 thumb_area.Width, 1);
4332 pixel_len = thumb_area.Width - 11;
4333 pixels_betweenticks = pixel_len / (tb.Maximum - tb.Minimum);
4335 /* Convert thumb position from mouse position to value*/
4337 if (value_pos >= channel_startpoint.X)
4338 value_pos = (int)(((float) (value_pos - channel_startpoint.X)) / pixels_betweenticks);
4342 if (value_pos + tb.Minimum > tb.Maximum)
4343 value_pos = tb.Maximum - tb.Minimum;
4345 tb.Value = value_pos + tb.Minimum;
4348 thumb_pos.X = channel_startpoint.X + (int) (pixels_betweenticks * (float) value_pos);
4350 /* Draw thumb fixed 10x22 size */
4351 thumb_pos.Width = 10;
4352 thumb_pos.Height = 22;
4354 switch (tb.TickStyle) {
4355 case TickStyle.BottomRight:
4356 case TickStyle.None: {
4357 thumb_pos.Y = channel_startpoint.Y - 8;
4359 Pen pen = SystemPens.ControlLight;
4360 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X + 10, thumb_pos.Y);
4361 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X, thumb_pos.Y + 16);
4362 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 16, thumb_pos.X + 4, thumb_pos.Y + 16 + 4);
4364 pen = SystemPens.ControlDark;
4365 dc.DrawLine (pen, thumb_pos.X + 9, thumb_pos.Y + 1, thumb_pos.X +9, thumb_pos.Y +15);
4366 dc.DrawLine (pen, thumb_pos.X + 9, thumb_pos.Y + 16, thumb_pos.X +9 - 4, thumb_pos.Y +16 + 4);
4368 pen = SystemPens.ControlDarkDark;
4369 dc.DrawLine (pen, thumb_pos.X + 10, thumb_pos.Y, thumb_pos.X +10, thumb_pos.Y +16);
4370 dc.DrawLine (pen, thumb_pos.X + 10, thumb_pos.Y + 16, thumb_pos.X +10 - 5, thumb_pos.Y +16 + 5);
4372 dc.FillRectangle (br_thumb, thumb_pos.X + 1, thumb_pos.Y + 1, 8, 16);
4373 dc.FillRectangle (br_thumb, thumb_pos.X + 2, thumb_pos.Y + 17, 6, 1);
4374 dc.FillRectangle (br_thumb, thumb_pos.X + 3, thumb_pos.Y + 18, 4, 1);
4375 dc.FillRectangle (br_thumb, thumb_pos.X + 4, thumb_pos.Y + 19, 2, 1);
4378 case TickStyle.TopLeft: {
4379 thumb_pos.Y = channel_startpoint.Y - 10;
4381 Pen pen = SystemPens.ControlLight;
4382 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 4, thumb_pos.X, thumb_pos.Y + 4 + 16);
4383 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 4, thumb_pos.X + 4, thumb_pos.Y);
4385 pen = SystemPens.ControlDark;
4386 dc.DrawLine (pen, thumb_pos.X + 9, thumb_pos.Y + 4, thumb_pos.X + 9, thumb_pos.Y + 4 + 16);
4387 dc.DrawLine (pen, thumb_pos.X + 9, thumb_pos.Y + 4, thumb_pos.X + 5, thumb_pos.Y);
4388 dc.DrawLine (pen, thumb_pos.X + 9, thumb_pos.Y + 19, thumb_pos.X + 1 , thumb_pos.Y +19);
4390 pen = SystemPens.ControlDarkDark;
4391 dc.DrawLine (pen, thumb_pos.X + 10, thumb_pos.Y + 4, thumb_pos.X + 10, thumb_pos.Y + 4 + 16);
4392 dc.DrawLine (pen, thumb_pos.X + 10, thumb_pos.Y + 4, thumb_pos.X + 5, thumb_pos.Y -1);
4393 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 20, thumb_pos.X + 10, thumb_pos.Y + 20);
4395 dc.FillRectangle (br_thumb, thumb_pos.X + 1, thumb_pos.Y + 4, 8, 15);
4396 dc.FillRectangle (br_thumb, thumb_pos.X + 2, thumb_pos.Y + 3, 6, 1);
4397 dc.FillRectangle (br_thumb, thumb_pos.X + 3, thumb_pos.Y + 2, 4, 1);
4398 dc.FillRectangle (br_thumb, thumb_pos.X + 4, thumb_pos.Y + 1, 2, 1);
4402 case TickStyle.Both: {
4403 thumb_pos.Y = area.Y + 10;
4405 Pen pen = SystemPens.ControlLight;
4406 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X + 9, thumb_pos.Y);
4407 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X, thumb_pos.Y + 19);
4409 pen = SystemPens.ControlDark;
4410 dc.DrawLine (pen, thumb_pos.X + 9, thumb_pos.Y + 1, thumb_pos.X + 9, thumb_pos.Y + 19);
4411 dc.DrawLine (pen, thumb_pos.X + 1, thumb_pos.Y + 10, thumb_pos.X + 8, thumb_pos.Y + 19);
4413 pen = SystemPens.ControlDarkDark;
4414 dc.DrawLine (pen, thumb_pos.X + 10, thumb_pos.Y, thumb_pos.X +10, thumb_pos.Y + 20);
4415 dc.DrawLine (pen, thumb_pos.X, thumb_pos.Y + 20, thumb_pos.X + 9, thumb_pos.Y + 20);
4417 dc.FillRectangle (br_thumb, thumb_pos.X + 1, thumb_pos.Y + 1, 8, 18);
4426 pixel_len = thumb_area.Width - 11;
4427 pixels_betweenticks = pixel_len / ticks;
4430 thumb_area.Y = thumb_pos.Y;
4431 thumb_area.X = channel_startpoint.X;
4432 thumb_area.Height = thumb_pos.Height;
4433 Region outside = new Region (area);
4434 outside.Exclude (thumb_area);
4436 if (outside.IsVisible (clip_rectangle)) {
4437 if (pixels_betweenticks > 0 && ((tb.TickStyle & TickStyle.BottomRight) == TickStyle.BottomRight ||
4438 ((tb.TickStyle & TickStyle.Both) == TickStyle.Both))) {
4440 for (float inc = 0; inc < (pixel_len + 1); inc += pixels_betweenticks) {
4441 if (inc == 0 || (inc + pixels_betweenticks) >= pixel_len +1)
4442 dc.DrawLine (ResPool.GetPen (pen_ticks_color), area.X + bottomtick_startpoint.X + inc , area.Y + bottomtick_startpoint.Y,
4443 area.X + bottomtick_startpoint.X + inc , area.Y + bottomtick_startpoint.Y + 3);
4445 dc.DrawLine (ResPool.GetPen (pen_ticks_color), area.X + bottomtick_startpoint.X + inc, area.Y + bottomtick_startpoint.Y,
4446 area.X + bottomtick_startpoint.X + inc, area.Y + bottomtick_startpoint.Y + 2);
4450 if (pixels_betweenticks > 0 && ((tb.TickStyle & TickStyle.TopLeft) == TickStyle.TopLeft ||
4451 ((tb.TickStyle & TickStyle.Both) == TickStyle.Both))) {
4453 for (float inc = 0; inc < (pixel_len + 1); inc += pixels_betweenticks) {
4454 if (inc == 0 || (inc + pixels_betweenticks) >= pixel_len +1)
4455 dc.DrawLine (ResPool.GetPen (pen_ticks_color), area.X + toptick_startpoint.X + inc , area.Y + toptick_startpoint.Y - 3,
4456 area.X + toptick_startpoint.X + inc , area.Y + toptick_startpoint.Y);
4458 dc.DrawLine (ResPool.GetPen (pen_ticks_color), area.X + toptick_startpoint.X + inc, area.Y + toptick_startpoint.Y - 2,
4459 area.X + toptick_startpoint.X + inc, area.Y + toptick_startpoint.Y );
4467 public override void DrawTrackBar (Graphics dc, Rectangle clip_rectangle, TrackBar tb)
4472 float ticks = (tb.Maximum - tb.Minimum) / tb.tickFrequency; /* N of ticks draw*/
4474 Rectangle thumb_pos = tb.ThumbPos;
4475 Rectangle thumb_area = tb.ThumbArea;
4477 if (tb.thumb_pressed) {
4478 value_pos = tb.thumb_mouseclick;
4481 value_pos = tb.Value - tb.Minimum;
4482 mouse_value = false;
4485 area = tb.ClientRectangle;
4488 br_thumb = (Brush) ResPool.GetHatchBrush (HatchStyle.Percent50, ColorControlLightLight, ColorControlLight);
4489 } else if (tb.thumb_pressed == true) {
4490 br_thumb = (Brush) ResPool.GetHatchBrush (HatchStyle.Percent50, ColorControlLight, ColorControl);
4492 br_thumb = SystemBrushes.Control;
4496 /* Control Background */
4497 if (tb.BackColor.ToArgb () == DefaultControlBackColor.ToArgb ()) {
4498 dc.FillRectangle (SystemBrushes.Control, clip_rectangle);
4500 dc.FillRectangle (ResPool.GetSolidBrush (tb.BackColor), clip_rectangle);
4505 Brush brush = ResPool.GetHatchBrush (HatchStyle.Percent50, ColorControl, Color.Black);
4506 dc.FillRectangle (brush, area.X, area.Y, area.Width - 1, 1);
4507 dc.FillRectangle (brush, area.X, area.Y + area.Height - 1, area.Width - 1, 1);
4508 dc.FillRectangle (brush, area.X, area.Y, 1, area.Height - 1);
4509 dc.FillRectangle (brush, area.X + area.Width - 1, area.Y, 1, area.Height - 1);
4512 if (tb.Orientation == Orientation.Vertical) {
4513 DrawTrackBar_Vertical (dc, clip_rectangle, tb, ref thumb_pos, ref thumb_area,
4514 br_thumb, ticks, value_pos, mouse_value);
4517 DrawTrackBar_Horizontal (dc, clip_rectangle, tb, ref thumb_pos, ref thumb_area,
4518 br_thumb, ticks, value_pos, mouse_value);
4521 tb.ThumbPos = thumb_pos;
4522 tb.ThumbArea = thumb_area;
4525 public override Size TrackBarDefaultSize {
4527 return new Size (104, 42);
4531 #endregion // TrackBar
4534 public override Size VScrollBarDefaultSize {
4536 return new Size (this.ScrollBarButtonSize, 80);
4539 #endregion // VScrollBar
4542 public override Size TreeViewDefaultSize {
4544 return new Size (121, 97);
4550 public override int ManagedWindowTitleBarHeight (InternalWindowManager wm)
4552 if (wm.IsToolWindow && !wm.IsMinimized)
4553 return SystemInformation.ToolWindowCaptionHeight;
4554 if (wm.Form.FormBorderStyle == FormBorderStyle.None)
4556 return SystemInformation.CaptionHeight;
4559 public override int ManagedWindowBorderWidth (InternalWindowManager wm)
4564 public override int ManagedWindowIconWidth (InternalWindowManager wm)
4566 return ManagedWindowTitleBarHeight (wm) - 5;
4569 public override void ManagedWindowSetButtonLocations (InternalWindowManager wm)
4571 int bw = ManagedWindowBorderWidth (wm);
4572 Size btsize = ManagedWindowButtonSize (wm);
4573 int btw = btsize.Width;
4574 int bth = btsize.Height;
4576 if ((!wm.IsToolWindow || wm.IsMinimized) && wm.HasBorders) {
4577 if (!wm.IsMaximized) {
4578 wm.close_button.Rectangle = new Rectangle (wm.Form.Width - bw - btw - 2,
4580 wm.maximize_button.Rectangle = new Rectangle (wm.close_button.Rectangle.Left - 2 - btw,
4582 wm.minimize_button.Rectangle = new Rectangle (wm.maximize_button.Rectangle.Left - btw,
4587 } else if (wm.IsToolWindow) {
4588 wm.close_button.Rectangle = new Rectangle (wm.Form.Width - bw - 2 - btw, bw + 2, btw, bth);
4592 public override void DrawManagedWindowDecorations (Graphics dc, Rectangle clip, InternalWindowManager wm)
4594 Form form = wm.Form;
4595 int tbheight = ManagedWindowTitleBarHeight (wm);
4596 int bdwidth = ManagedWindowBorderWidth (wm);
4597 Color titlebar_color = Color.FromArgb (255, 0, 0, 255);
4599 if (wm.HasBorders) {
4600 Rectangle borders = new Rectangle (0, 0, form.Width, form.Height);
4601 // The 3d border is only 2 pixels wide, so we draw the innermost pixel ourselves
4602 dc.DrawRectangle (new Pen (ColorControl, 1), 2, 2, form.Width - 5, form.Height - 5);
4603 ControlPaint.DrawBorder3D (dc, borders, Border3DStyle.Raised);
4606 Color color = ThemeEngine.Current.ColorControlDark;
4608 if (wm.IsActive () && !wm.IsMaximized)
4609 color = titlebar_color;
4611 Rectangle tb = new Rectangle (bdwidth, bdwidth,
4612 form.Width - (bdwidth * 2), tbheight);
4614 // HACK: For now always draw the titlebar until we get updates better
4615 // Rectangle vis = Rectangle.Intersect (tb, pe.ClipRectangle);
4616 //if (vis != Rectangle.Empty)
4617 dc.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (color), tb);
4619 dc.DrawLine (new Pen (SystemColors.ControlLight, 1), bdwidth,
4620 tbheight + bdwidth, form.Width - (bdwidth * 2),
4621 tbheight + bdwidth);
4623 if (!wm.IsToolWindow) {
4624 tb.X += 18; // Room for the icon and the buttons
4625 tb.Width = (form.Width - 62) - tb.X;
4628 if (form.Text != null) {
4629 StringFormat format = new StringFormat ();
4630 format.FormatFlags = StringFormatFlags.NoWrap;
4631 format.Trimming = StringTrimming.EllipsisCharacter;
4632 format.LineAlignment = StringAlignment.Center;
4634 if (tb.IntersectsWith (clip))
4635 dc.DrawString (form.Text, form.Font,
4636 ThemeEngine.Current.ResPool.GetSolidBrush (Color.White),
4640 if (wm.HasBorders) {
4641 if (!wm.IsToolWindow && form.Icon != null) {
4642 Rectangle icon = new Rectangle (bdwidth + 3,
4643 bdwidth + 2, wm.IconWidth, wm.IconWidth);
4644 if (icon.IntersectsWith (clip))
4645 dc.DrawIcon (form.Icon, icon);
4648 if (!wm.IsMaximized) {
4649 if (!wm.IsToolWindow || wm.IsMinimized) {
4650 DrawTitleButton (dc, wm.minimize_button, clip);
4651 DrawTitleButton (dc, wm.maximize_button, clip);
4653 DrawTitleButton (dc, wm.close_button, clip);
4655 // DrawMaximizedButtons (pe, form.ActiveMenu);
4660 public override Size ManagedWindowButtonSize (InternalWindowManager wm)
4662 int height = ManagedWindowTitleBarHeight (wm);
4663 if (!wm.IsMaximized && !wm.IsMinimized) {
4664 if (wm.IsToolWindow)
4665 return new Size (SystemInformation.ToolWindowCaptionButtonSize.Width - 2,
4667 if (wm.Form.FormBorderStyle == FormBorderStyle.None)
4670 height = SystemInformation.CaptionHeight;
4672 return new Size (SystemInformation.CaptionButtonSize.Width - 2,
4676 private void DrawTitleButton (Graphics dc, InternalWindowManager.TitleButton button, Rectangle clip)
4678 if (!button.Rectangle.IntersectsWith (clip))
4681 dc.FillRectangle (SystemBrushes.Control, button.Rectangle);
4683 ControlPaint.DrawCaptionButton (dc, button.Rectangle,
4684 button.Caption, ButtonState.Normal);
4687 #region ControlPaint
4688 public override void CPDrawBorder (Graphics graphics, Rectangle bounds, Color leftColor, int leftWidth,
4689 ButtonBorderStyle leftStyle, Color topColor, int topWidth, ButtonBorderStyle topStyle,
4690 Color rightColor, int rightWidth, ButtonBorderStyle rightStyle, Color bottomColor,
4691 int bottomWidth, ButtonBorderStyle bottomStyle) {
4692 DrawBorderInternal(graphics, bounds.Left, bounds.Top, bounds.Left, bounds.Bottom-1, leftWidth, leftColor, leftStyle, Border3DSide.Left);
4693 DrawBorderInternal(graphics, bounds.Left, bounds.Top, bounds.Right-1, bounds.Top, topWidth, topColor, topStyle, Border3DSide.Top);
4694 DrawBorderInternal(graphics, bounds.Right-1, bounds.Top, bounds.Right-1, bounds.Bottom-1, rightWidth, rightColor, rightStyle, Border3DSide.Right);
4695 DrawBorderInternal(graphics, bounds.Left, bounds.Bottom-1, bounds.Right-1, bounds.Bottom-1, bottomWidth, bottomColor, bottomStyle, Border3DSide.Bottom);
4698 public override void CPDrawBorder3D (Graphics graphics, Rectangle rectangle, Border3DStyle style, Border3DSide sides) {
4699 CPDrawBorder3D(graphics, rectangle, style, sides, ColorControl);
4702 protected virtual void CPDrawBorder3D (Graphics graphics, Rectangle rectangle, Border3DStyle style, Border3DSide sides, Color control_color)
4705 Pen penTopLeftInner;
4707 Pen penBottomRightInner;
4708 Rectangle rect= new Rectangle (rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
4709 bool is_ColorControl = control_color.ToArgb () == ColorControl.ToArgb () ? true : false;
4711 if ((style & Border3DStyle.Adjust) != 0) {
4718 penTopLeft = penTopLeftInner = penBottomRight = penBottomRightInner = is_ColorControl ? SystemPens.Control : ResPool.GetPen (control_color);
4720 CPColor cpcolor = CPColor.Empty;
4722 if (!is_ColorControl)
4723 cpcolor = ResPool.GetCPColor (control_color);
4726 case Border3DStyle.Raised:
4727 penTopLeftInner = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
4728 penBottomRight = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
4729 penBottomRightInner = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
4731 case Border3DStyle.Sunken:
4732 penTopLeft = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
4733 penTopLeftInner = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
4734 penBottomRight = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
4736 case Border3DStyle.Etched:
4737 penTopLeft = penBottomRightInner = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
4738 penTopLeftInner = penBottomRight = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
4740 case Border3DStyle.RaisedOuter:
4741 penBottomRight = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
4743 case Border3DStyle.SunkenOuter:
4744 penTopLeft = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
4745 penBottomRight = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
4747 case Border3DStyle.RaisedInner:
4748 penTopLeft = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen (cpcolor.LightLight);
4749 penBottomRight = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
4751 case Border3DStyle.SunkenInner:
4752 penTopLeft = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
4754 case Border3DStyle.Flat:
4755 penTopLeft = penBottomRight = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen (cpcolor.Dark);
4757 case Border3DStyle.Bump:
4758 penTopLeftInner = penBottomRight = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen (cpcolor.DarkDark);
4764 if ((sides & Border3DSide.Middle) != 0) {
4765 Brush brush = is_ColorControl ? SystemBrushes.Control : ResPool.GetSolidBrush (control_color);
4766 graphics.FillRectangle (brush, rect);
4769 if ((sides & Border3DSide.Left) != 0) {
4770 graphics.DrawLine (penTopLeft, rect.Left, rect.Bottom - 2, rect.Left, rect.Top);
4771 graphics.DrawLine (penTopLeftInner, rect.Left + 1, rect.Bottom - 2, rect.Left + 1, rect.Top);
4774 if ((sides & Border3DSide.Top) != 0) {
4775 graphics.DrawLine (penTopLeft, rect.Left, rect.Top, rect.Right - 2, rect.Top);
4776 graphics.DrawLine (penTopLeftInner, rect.Left + 1, rect.Top + 1, rect.Right - 3, rect.Top + 1);
4779 if ((sides & Border3DSide.Right) != 0) {
4780 graphics.DrawLine (penBottomRight, rect.Right - 1, rect.Top, rect.Right - 1, rect.Bottom - 1);
4781 graphics.DrawLine (penBottomRightInner, rect.Right - 2, rect.Top + 1, rect.Right - 2, rect.Bottom - 2);
4784 if ((sides & Border3DSide.Bottom) != 0) {
4785 graphics.DrawLine (penBottomRight, rect.Left, rect.Bottom - 1, rect.Right - 1, rect.Bottom - 1);
4786 graphics.DrawLine (penBottomRightInner, rect.Left + 1, rect.Bottom - 2, rect.Right - 2, rect.Bottom - 2);
4790 public override void CPDrawButton (Graphics dc, Rectangle rectangle, ButtonState state)
4792 // sadly enough, the rectangle gets always filled with a hatchbrush
4793 dc.FillRectangle (ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (ColorControl.R + 3, ColorControl.G, ColorControl.B), ColorControl), rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2);
4795 if ((state & ButtonState.All) == ButtonState.All || ((state & ButtonState.Checked) == ButtonState.Checked && (state & ButtonState.Flat) == ButtonState.Flat)) {
4796 dc.FillRectangle (ResPool.GetHatchBrush (HatchStyle.Percent50, ColorControlLight, ColorControl), rectangle.X + 2, rectangle.Y + 2, rectangle.Width - 4, rectangle.Height - 4);
4798 dc.DrawRectangle (SystemPens.ControlDark, rectangle.X, rectangle.Y, rectangle.Width - 1, rectangle.Height - 1);
4800 if ((state & ButtonState.Flat) == ButtonState.Flat) {
4801 dc.DrawRectangle (SystemPens.ControlDark, rectangle.X, rectangle.Y, rectangle.Width - 1, rectangle.Height - 1);
4803 if ((state & ButtonState.Checked) == ButtonState.Checked) {
4804 dc.FillRectangle (ResPool.GetHatchBrush (HatchStyle.Percent50, ColorControlLight, ColorControl), rectangle.X + 2, rectangle.Y + 2, rectangle.Width - 4, rectangle.Height - 4);
4806 Pen pen = SystemPens.ControlDarkDark;
4807 dc.DrawLine (pen, rectangle.X, rectangle.Y, rectangle.X, rectangle.Bottom - 2);
4808 dc.DrawLine (pen, rectangle.X + 1, rectangle.Y, rectangle.Right - 2, rectangle.Y);
4810 pen = SystemPens.ControlDark;
4811 dc.DrawLine (pen, rectangle.X + 1, rectangle.Y + 1, rectangle.X + 1, rectangle.Bottom - 3);
4812 dc.DrawLine (pen, rectangle.X + 2, rectangle.Y + 1, rectangle.Right - 3, rectangle.Y + 1);
4814 pen = SystemPens.ControlLight;
4815 dc.DrawLine (pen, rectangle.X, rectangle.Bottom - 1, rectangle.Right - 2, rectangle.Bottom - 1);
4816 dc.DrawLine (pen, rectangle.Right - 1, rectangle.Y, rectangle.Right - 1, rectangle.Bottom - 1);
4818 if (((state & ButtonState.Pushed) == ButtonState.Pushed) && ((state & ButtonState.Normal) == ButtonState.Normal)) {
4819 Pen pen = SystemPens.ControlDarkDark;
4820 dc.DrawLine (pen, rectangle.X, rectangle.Y, rectangle.X, rectangle.Bottom - 2);
4821 dc.DrawLine (pen, rectangle.X + 1, rectangle.Y, rectangle.Right - 2, rectangle.Y);
4823 pen = SystemPens.ControlDark;
4824 dc.DrawLine (pen, rectangle.X + 1, rectangle.Y + 1, rectangle.X + 1, rectangle.Bottom - 3);
4825 dc.DrawLine (pen, rectangle.X + 2, rectangle.Y + 1, rectangle.Right - 3, rectangle.Y + 1);
4827 pen = SystemPens.ControlLight;
4828 dc.DrawLine (pen, rectangle.X, rectangle.Bottom - 1, rectangle.Right - 2, rectangle.Bottom - 1);
4829 dc.DrawLine (pen, rectangle.Right - 1, rectangle.Y, rectangle.Right - 1, rectangle.Bottom - 1);
4831 if (((state & ButtonState.Inactive) == ButtonState.Inactive) || ((state & ButtonState.Normal) == ButtonState.Normal)) {
4832 Pen pen = SystemPens.ControlLight;
4833 dc.DrawLine (pen, rectangle.X, rectangle.Y, rectangle.Right - 2, rectangle.Y);
4834 dc.DrawLine (pen, rectangle.X, rectangle.Y, rectangle.X, rectangle.Bottom - 2);
4836 pen = SystemPens.ControlDark;
4837 dc.DrawLine (pen, rectangle.X + 1, rectangle.Bottom - 2, rectangle.Right - 2, rectangle.Bottom - 2);
4838 dc.DrawLine (pen, rectangle.Right - 2, rectangle.Y + 1, rectangle.Right - 2, rectangle.Bottom - 3);
4840 pen = SystemPens.ControlDarkDark;
4841 dc.DrawLine (pen, rectangle.X, rectangle.Bottom - 1, rectangle.Right - 1, rectangle.Bottom - 1);
4842 dc.DrawLine (pen, rectangle.Right - 1, rectangle.Y, rectangle.Right - 1, rectangle.Bottom - 2);
4847 public override void CPDrawCaptionButton (Graphics graphics, Rectangle rectangle, CaptionButton button, ButtonState state) {
4848 Rectangle captionRect;
4851 CPDrawButton(graphics, rectangle, state);
4853 if (rectangle.Width<rectangle.Height) {
4854 captionRect=new Rectangle(rectangle.X+1, rectangle.Y+rectangle.Height/2-rectangle.Width/2+1, rectangle.Width-4, rectangle.Width-4);
4856 captionRect=new Rectangle(rectangle.X+rectangle.Width/2-rectangle.Height/2+1, rectangle.Y+1, rectangle.Height-4, rectangle.Height-4);
4859 if ((state & ButtonState.Pushed)!=0) {
4860 captionRect=new Rectangle(rectangle.X+2, rectangle.Y+2, rectangle.Width-3, rectangle.Height-3);
4863 /* Make sure we've got at least a line width of 1 */
4864 lineWidth=Math.Max(1, captionRect.Width/7);
4867 case CaptionButton.Close: {
4870 if ((state & ButtonState.Inactive)!=0) {
4871 pen = ResPool.GetSizedPen (ColorControlLight, lineWidth);
4872 DrawCaptionHelper(graphics, ColorControlLight, pen, lineWidth, 1, captionRect, button);
4874 pen = ResPool.GetSizedPen (ColorControlDark, lineWidth);
4875 DrawCaptionHelper(graphics, ColorControlDark, pen, lineWidth, 0, captionRect, button);
4878 pen = ResPool.GetSizedPen (ColorControlText, lineWidth);
4879 DrawCaptionHelper(graphics, ColorControlText, pen, lineWidth, 0, captionRect, button);
4884 case CaptionButton.Help:
4885 case CaptionButton.Maximize:
4886 case CaptionButton.Minimize:
4887 case CaptionButton.Restore: {
4888 if ((state & ButtonState.Inactive)!=0) {
4889 DrawCaptionHelper(graphics, ColorControlLight, SystemPens.ControlLightLight, lineWidth, 1, captionRect, button);
4891 DrawCaptionHelper(graphics, ColorControlDark, SystemPens.ControlDark, lineWidth, 0, captionRect, button);
4894 DrawCaptionHelper(graphics, ColorControlText, SystemPens.ControlText, lineWidth, 0, captionRect, button);
4901 public override void CPDrawCheckBox (Graphics dc, Rectangle rectangle, ButtonState state)
4903 Pen check_pen = SystemPens.ControlDarkDark;
4905 Rectangle cb_rect = new Rectangle (rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
4907 if ((state & ButtonState.All) == ButtonState.All) {
4909 cb_rect.Height -= 2;
4911 dc.FillRectangle (SystemBrushes.Control, cb_rect.X, cb_rect.Y, cb_rect.Width - 1, cb_rect.Height - 1);
4912 dc.DrawRectangle (SystemPens.ControlDark, cb_rect.X, cb_rect.Y, cb_rect.Width - 1, cb_rect.Height - 1);
4914 check_pen = SystemPens.ControlDark;
4916 if ((state & ButtonState.Flat) == ButtonState.Flat) {
4918 cb_rect.Height -= 2;
4920 dc.FillRectangle (SystemBrushes.ControlLight, cb_rect.X, cb_rect.Y, cb_rect.Width - 1, cb_rect.Height - 1);
4921 dc.DrawRectangle (SystemPens.ControlDark, cb_rect.X, cb_rect.Y, cb_rect.Width - 1, cb_rect.Height - 1);
4924 cb_rect.Height -= 1;
4926 int check_box_visible_size = (cb_rect.Height > cb_rect.Width) ? cb_rect.Width : cb_rect.Height;
4928 int x_pos = Math.Max (0, cb_rect.X + (cb_rect.Width / 2) - check_box_visible_size / 2);
4929 int y_pos = Math.Max (0, cb_rect.Y + (cb_rect.Height / 2) - check_box_visible_size / 2);
4931 Rectangle rect = new Rectangle (x_pos, y_pos, check_box_visible_size, check_box_visible_size);
4933 if (((state & ButtonState.Pushed) == ButtonState.Pushed) || ((state & ButtonState.Inactive) == ButtonState.Inactive)) {
4934 dc.FillRectangle (ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (ColorControl.R + 3, ColorControl.G, ColorControl.B), ColorControl), rect.X + 2, rect.Y + 2, rect.Width - 3, rect.Height - 3);
4936 dc.FillRectangle (SystemBrushes.ControlLightLight, rect.X + 2, rect.Y + 2, rect.Width - 3, rect.Height - 3);
4938 Pen pen = SystemPens.ControlDark;
4939 dc.DrawLine (pen, rect.X, rect.Y, rect.X, rect.Bottom - 1);
4940 dc.DrawLine (pen, rect.X + 1, rect.Y, rect.Right - 1, rect.Y);
4942 pen = SystemPens.ControlDarkDark;
4943 dc.DrawLine (pen, rect.X + 1, rect.Y + 1, rect.X + 1, rect.Bottom - 2);
4944 dc.DrawLine (pen, rect.X + 2, rect.Y + 1, rect.Right - 2, rect.Y + 1);
4946 pen = SystemPens.ControlLight;
4947 dc.DrawLine (pen, rect.Right, rect.Y, rect.Right, rect.Bottom);
4948 dc.DrawLine (pen, rect.X, rect.Bottom, rect.Right, rect.Bottom);
4950 // oh boy, matching ms is like fighting against windmills
4951 using (Pen h_pen = new Pen (ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (ColorControl.R + 3, ColorControl.G, ColorControl.B), ColorControl))) {
4952 dc.DrawLine (h_pen, rect.X + 1, rect.Bottom - 1, rect.Right - 1, rect.Bottom - 1);
4953 dc.DrawLine (h_pen, rect.Right - 1, rect.Y + 1, rect.Right - 1, rect.Bottom - 1);
4956 if ((state & ButtonState.Inactive) == ButtonState.Inactive)
4957 check_pen = SystemPens.ControlDark;
4960 if ((state & ButtonState.Checked) == ButtonState.Checked) {
4961 int check_size = (cb_rect.Height > cb_rect.Width) ? cb_rect.Width / 2: cb_rect.Height / 2;
4963 if (check_size < 7) {
4964 int lineWidth = Math.Max (3, check_size / 3);
4965 int Scale = Math.Max (1, check_size / 9);
4967 Rectangle rect = new Rectangle (cb_rect.X + (cb_rect.Width / 2) - (check_size / 2) - 1, cb_rect.Y + (cb_rect.Height / 2) - (check_size / 2) - 1,
4968 check_size, check_size);
4970 for (int i = 0; i < lineWidth; i++) {
4971 dc.DrawLine (check_pen, rect.Left + lineWidth / 2, rect.Top + lineWidth + i, rect.Left + lineWidth / 2 + 2 * Scale, rect.Top + lineWidth + 2 * Scale + i);
4972 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);
4975 int lineWidth = Math.Max (3, check_size / 3) + 1;
4977 int x_half = cb_rect.Width / 2;
4978 int y_half = cb_rect.Height / 2;
4980 Rectangle rect = new Rectangle (cb_rect.X + x_half - (check_size / 2) - 1, cb_rect.Y + y_half - (check_size / 2),
4981 check_size, check_size);
4983 int gradient_left = check_size / 3;
4984 int gradient_right = check_size - gradient_left - 1;
4987 for (int i = 0; i < lineWidth; i++) {
4988 dc.DrawLine (check_pen, rect.X, rect.Bottom - 1 - gradient_left - i, rect.X + gradient_left, rect.Bottom - 1 - i);
4989 dc.DrawLine (check_pen, rect.X + gradient_left, rect.Bottom - 1 - i, rect.Right - 1, rect.Bottom - i - 1 - gradient_right);
4995 public override void CPDrawComboButton (Graphics graphics, Rectangle rectangle, ButtonState state) {
4996 Point[] arrow = new Point[3];
5006 if ((state & ButtonState.Checked)!=0) {
5007 graphics.FillRectangle(ResPool.GetHatchBrush (HatchStyle.Percent50, ColorControlLightLight, ColorControlLight),rectangle);
5010 if ((state & ButtonState.Flat)!=0) {
5011 ControlPaint.DrawBorder(graphics, rectangle, ColorControlDark, ButtonBorderStyle.Solid);
5013 if ((state & (ButtonState.Pushed | ButtonState.Checked))!=0) {
5014 // this needs to render like a pushed button - jba
5015 // CPDrawBorder3D(graphics, rectangle, Border3DStyle.Sunken, Border3DSide.Left | Border3DSide.Top | Border3DSide.Right | Border3DSide.Bottom, ColorControl);
5016 Rectangle trace_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max (rectangle.Width-1, 0), Math.Max (rectangle.Height-1, 0));
5017 graphics.DrawRectangle (SystemPens.ControlDark, trace_rectangle);
5019 CPDrawBorder3D(graphics, rectangle, Border3DStyle.Raised, Border3DSide.Left | Border3DSide.Top | Border3DSide.Right | Border3DSide.Bottom, ColorControl);
5023 rect=new Rectangle(rectangle.X+rectangle.Width/4, rectangle.Y+rectangle.Height/4, rectangle.Width/2, rectangle.Height/2);
5024 centerX=rect.Left+rect.Width/2;
5025 centerY=rect.Top+rect.Height/2;
5026 shiftX=Math.Max(1, rect.Width/8);
5027 shiftY=Math.Max(1, rect.Height/8);
5029 if ((state & ButtonState.Pushed)!=0) {
5036 P1=new Point(rect.Left, centerY);
5037 P2=new Point(rect.Right, centerY);
5038 P3=new Point(centerX, rect.Bottom);
5044 /* Draw the arrow */
5045 if ((state & ButtonState.Inactive)!=0) {
5046 /* Move away from the shadow */
5047 arrow[0].X += 1; arrow[0].Y += 1;
5048 arrow[1].X += 1; arrow[1].Y += 1;
5049 arrow[2].X += 1; arrow[2].Y += 1;
5051 graphics.FillPolygon(SystemBrushes.ControlLightLight, arrow, FillMode.Winding);
5057 graphics.FillPolygon(SystemBrushes.ControlDark, arrow, FillMode.Winding);
5059 graphics.FillPolygon(SystemBrushes.ControlText, arrow, FillMode.Winding);
5064 public override void CPDrawContainerGrabHandle (Graphics graphics, Rectangle bounds)
5066 Pen pen = Pens.Black;
5067 Rectangle rect = new Rectangle (bounds.X, bounds.Y, bounds.Width - 1, bounds.Height - 1); // Dunno why, but MS does it that way, too
5071 graphics.FillRectangle (SystemBrushes.ControlLightLight, rect);
5072 graphics.DrawRectangle (pen, rect);
5074 X = rect.X + rect.Width / 2;
5075 Y = rect.Y + rect.Height / 2;
5077 /* Draw the cross */
5078 graphics.DrawLine (pen, X, rect.Y + 2, X, rect.Bottom - 2);
5079 graphics.DrawLine (pen, rect.X + 2, Y, rect.Right - 2, Y);
5081 /* Draw 'arrows' for vertical lines */
5082 graphics.DrawLine (pen, X - 1, rect.Y + 3, X + 1, rect.Y + 3);
5083 graphics.DrawLine (pen, X - 1, rect.Bottom - 3, X + 1, rect.Bottom - 3);
5085 /* Draw 'arrows' for horizontal lines */
5086 graphics.DrawLine (pen, rect.X + 3, Y - 1, rect.X + 3, Y + 1);
5087 graphics.DrawLine (pen, rect.Right - 3, Y - 1, rect.Right - 3, Y + 1);
5090 public virtual void DrawFlatStyleFocusRectangle (Graphics graphics, Rectangle rectangle, ButtonBase button, Color foreColor, Color backColor) {
5091 // make a rectange to trace around border of the button
5092 Rectangle trace_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max (rectangle.Width-1, 0), Math.Max (rectangle.Height-1, 0));
5094 Color outerColor = foreColor;
5095 // adjust focus color according to the flatstyle
5096 if (button.FlatStyle == FlatStyle.Popup && !button.is_pressed) {
5097 outerColor = (backColor.ToArgb () == ColorControl.ToArgb ()) ? ControlPaint.Dark(ColorControl) : ColorControlText;
5100 // draw the outer rectangle
5101 graphics.DrawRectangle (ResPool.GetPen (outerColor), trace_rectangle);
5103 // draw the inner rectangle
5104 if (button.FlatStyle == FlatStyle.Popup) {
5105 DrawInnerFocusRectangle (graphics, Rectangle.Inflate (rectangle, -4, -4), backColor);
5107 // draw a flat inner rectangle
5108 Pen pen = ResPool.GetPen (ControlPaint.LightLight (backColor));
5109 graphics.DrawRectangle(pen, Rectangle.Inflate (trace_rectangle, -4, -4));
5113 public virtual void DrawInnerFocusRectangle(Graphics graphics, Rectangle rectangle, Color backColor)
5115 // make a rectange to trace around border of the button
5116 Rectangle trace_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max (rectangle.Width-1, 0), Math.Max (rectangle.Height-1, 0));
5118 #if NotUntilCairoIsFixed
5119 Color colorBackInverted = Color.FromArgb (Math.Abs (backColor.R-255), Math.Abs (backColor.G-255), Math.Abs (backColor.B-255));
5120 DashStyle oldStyle; // used for caching old penstyle
5121 Pen pen = ResPool.GetPen (colorBackInverted);
5123 oldStyle = pen.DashStyle;
5124 pen.DashStyle = DashStyle.Dot;
5126 graphics.DrawRectangle (pen, trace_rectangle);
5127 pen.DashStyle = oldStyle;
5129 CPDrawFocusRectangle(graphics, trace_rectangle, Color.Wheat, backColor);
5134 public override void CPDrawFocusRectangle (Graphics graphics, Rectangle rectangle, Color foreColor, Color backColor)
5136 Rectangle rect = rectangle;
5140 if (backColor.GetBrightness () >= 0.5) {
5141 foreColor = Color.Transparent;
5142 backColor = Color.Black;
5145 backColor = Color.FromArgb (Math.Abs (backColor.R-255), Math.Abs (backColor.G-255), Math.Abs (backColor.B-255));
5146 foreColor = Color.Black;
5149 brush = ResPool.GetHatchBrush (HatchStyle.Percent50, backColor, foreColor);
5150 pen = new Pen (brush, 1);
5155 graphics.DrawRectangle (pen, rect);
5159 public override void CPDrawGrabHandle (Graphics graphics, Rectangle rectangle, bool primary, bool enabled)
5164 if (primary == true) {
5166 if (enabled == true) {
5169 sb = SystemBrushes.Control;
5173 if (enabled == true) {
5176 sb = SystemBrushes.Control;
5179 graphics.FillRectangle (sb, rectangle);
5180 graphics.DrawRectangle (pen, rectangle);
5184 public override void CPDrawGrid (Graphics graphics, Rectangle area, Size pixelsBetweenDots, Color backColor) {
5190 ControlPaint.Color2HBS(backColor, out h, out b, out s);
5193 foreColor=Color.Black;
5195 foreColor=Color.White;
5198 // still not perfect. it seems that ms calculates the position of the first dot or line
5200 using (Pen pen = new Pen (foreColor)) {
5201 pen.DashPattern = new float [] {1.0f, pixelsBetweenDots.Width - 1};
5203 for (int y = area.Top; y < area.Bottom; y += pixelsBetweenDots.Height)
5204 graphics.DrawLine (pen, area.X, y, area.Right - 1, y);
5208 public override void CPDrawImageDisabled (Graphics graphics, Image image, int x, int y, Color background) {
5210 Microsoft seems to ignore the background and simply make
5211 the image grayscale. At least when having > 256 colors on
5215 if (imagedisabled_attributes == null) {
5216 imagedisabled_attributes = new ImageAttributes ();
5217 ColorMatrix colorMatrix=new ColorMatrix(new float[][] {
5218 // This table would create a perfect grayscale image, based on luminance
5219 // new float[]{0.3f,0.3f,0.3f,0,0},
5220 // new float[]{0.59f,0.59f,0.59f,0,0},
5221 // new float[]{0.11f,0.11f,0.11f,0,0},
5222 // new float[]{0,0,0,1,0,0},
5223 // new float[]{0,0,0,0,1,0},
5224 // new float[]{0,0,0,0,0,1}
5226 // This table generates a image that is grayscaled and then
5227 // brightened up. Seems to match MS close enough.
5228 new float[]{0.2f,0.2f,0.2f,0,0},
5229 new float[]{0.41f,0.41f,0.41f,0,0},
5230 new float[]{0.11f,0.11f,0.11f,0,0},
5231 new float[]{0.15f,0.15f,0.15f,1,0,0},
5232 new float[]{0.15f,0.15f,0.15f,0,1,0},
5233 new float[]{0.15f,0.15f,0.15f,0,0,1}
5236 imagedisabled_attributes.SetColorMatrix (colorMatrix);
5239 graphics.DrawImage(image, new Rectangle(x, y, image.Width, image.Height), 0, 0, image.Width, image.Height, GraphicsUnit.Pixel, imagedisabled_attributes);
5244 public override void CPDrawLockedFrame (Graphics graphics, Rectangle rectangle, bool primary) {
5249 penBorder = ResPool.GetSizedPen (Color.White, 2);
5250 penInside = ResPool.GetPen (Color.Black);
5252 penBorder = ResPool.GetSizedPen (Color.Black, 2);
5253 penInside = ResPool.GetPen (Color.White);
5255 penBorder.Alignment=PenAlignment.Inset;
5256 penInside.Alignment=PenAlignment.Inset;
5258 graphics.DrawRectangle(penBorder, rectangle);
5259 graphics.DrawRectangle(penInside, rectangle.X+2, rectangle.Y+2, rectangle.Width-5, rectangle.Height-5);
5263 public override void CPDrawMenuGlyph (Graphics graphics, Rectangle rectangle, MenuGlyph glyph, Color color) {
5267 Brush brush = ResPool.GetSolidBrush (color);
5270 case MenuGlyph.Arrow: {
5271 Point[] arrow = new Point[3];
5279 rect=new Rectangle(rectangle.X+rectangle.Width/4, rectangle.Y+rectangle.Height/4, rectangle.Width/2, rectangle.Height/2);
5280 centerX=rect.Left+rect.Width/2;
5281 centerY=rect.Top+rect.Height/2;
5282 shiftX=Math.Max(1, rect.Width/8);
5287 P1=new Point(centerX, rect.Top);
5288 P2=new Point(centerX, rect.Bottom);
5289 P3=new Point(rect.Right, centerY);
5295 graphics.FillPolygon(brush, arrow, FillMode.Winding);
5300 case MenuGlyph.Bullet: {
5302 lineWidth=Math.Max(2, rectangle.Width/3);
5303 rect=new Rectangle(rectangle.X+lineWidth, rectangle.Y+lineWidth, rectangle.Width-lineWidth*2, rectangle.Height-lineWidth*2);
5305 graphics.FillEllipse(brush, rect);
5310 case MenuGlyph.Checkmark: {
5312 Pen pen = ResPool.GetPen (color);
5314 lineWidth=Math.Max(2, rectangle.Width/6);
5315 Scale=Math.Max(1, rectangle.Width/12);
5317 rect=new Rectangle(rectangle.X+lineWidth, rectangle.Y+lineWidth, rectangle.Width-lineWidth*2, rectangle.Height-lineWidth*2);
5319 for (int i=0; i<lineWidth; i++) {
5320 graphics.DrawLine(pen, rect.Left+lineWidth/2, rect.Top+lineWidth+i, rect.Left+lineWidth/2+2*Scale, rect.Top+lineWidth+2*Scale+i);
5321 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);
5329 public override void CPDrawRadioButton (Graphics dc, Rectangle rectangle, ButtonState state)
5331 CPColor cpcolor = ResPool.GetCPColor (ColorControl);
5333 Color dot_color = Color.Black;
5335 Color top_left_outer = Color.Black;
5336 Color top_left_inner = Color.Black;
5337 Color bottom_right_outer = Color.Black;
5338 Color bottom_right_inner = Color.Black;
5340 int ellipse_diameter = (rectangle.Width > rectangle.Height) ? (int)(rectangle.Height * 0.9f) : (int)(rectangle.Width * 0.9f);
5341 int radius = ellipse_diameter / 2;
5343 Rectangle rb_rect = new Rectangle (rectangle.X + (rectangle.Width / 2) - radius, rectangle.Y + (rectangle.Height / 2) - radius, ellipse_diameter, ellipse_diameter);
5347 if ((state & ButtonState.All) == ButtonState.All) {
5348 brush = ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (ColorControl.R + 3, ColorControl.G, ColorControl.B), ColorControl);
5349 dot_color = cpcolor.Dark;
5351 if ((state & ButtonState.Flat) == ButtonState.Flat) {
5352 if (((state & ButtonState.Inactive) == ButtonState.Inactive) || ((state & ButtonState.Pushed) == ButtonState.Pushed))
5353 brush = ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (ColorControl.R + 3, ColorControl.G, ColorControl.B), ColorControl);
5355 brush = SystemBrushes.ControlLightLight;
5357 if (((state & ButtonState.Inactive) == ButtonState.Inactive) || ((state & ButtonState.Pushed) == ButtonState.Pushed))
5358 brush = ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (ColorControl.R + 3, ColorControl.G, ColorControl.B), ColorControl);
5360 brush = SystemBrushes.ControlLightLight;
5362 top_left_outer = cpcolor.Dark;
5363 top_left_inner = cpcolor.DarkDark;
5364 bottom_right_outer = cpcolor.Light;
5365 bottom_right_inner = Color.Transparent;
5367 if ((state & ButtonState.Inactive) == ButtonState.Inactive)
5368 dot_color = cpcolor.Dark;
5371 dc.FillEllipse (brush, rb_rect.X + 1, rb_rect.Y + 1, ellipse_diameter - 1, ellipse_diameter - 1);
5373 int line_width = Math.Max (1, (int)(ellipse_diameter * 0.08f));
5375 dc.DrawArc (ResPool.GetSizedPen (top_left_outer, line_width), rb_rect, 135.0f, 180.0f);
5376 dc.DrawArc (ResPool.GetSizedPen (top_left_inner, line_width), Rectangle.Inflate (rb_rect, -line_width, -line_width), 135.0f, 180.0f);
5377 dc.DrawArc (ResPool.GetSizedPen (bottom_right_outer, line_width), rb_rect, 315.0f, 180.0f);
5379 if (bottom_right_inner != Color.Transparent)
5380 dc.DrawArc (ResPool.GetSizedPen (bottom_right_inner, line_width), Rectangle.Inflate (rb_rect, -line_width, -line_width), 315.0f, 180.0f);
5382 using (Pen h_pen = new Pen (ResPool.GetHatchBrush (HatchStyle.Percent50, Color.FromArgb (ColorControl.R + 3, ColorControl.G, ColorControl.B), ColorControl), line_width)) {
5383 dc.DrawArc (h_pen, Rectangle.Inflate (rb_rect, -line_width, -line_width), 315.0f, 180.0f);
5386 if ((state & ButtonState.Checked) == ButtonState.Checked) {
5387 int inflate = line_width * 4;
5388 Rectangle tmp = Rectangle.Inflate (rb_rect, -inflate, -inflate);
5389 if (rectangle.Height > 13) {
5393 dc.FillEllipse (ResPool.GetSolidBrush (dot_color), tmp);
5395 Pen pen = ResPool.GetPen (dot_color);
5396 dc.DrawLine (pen, tmp.X, tmp.Y + (tmp.Height / 2), tmp.Right, tmp.Y + (tmp.Height / 2));
5397 dc.DrawLine (pen, tmp.X, tmp.Y + (tmp.Height / 2) + 1, tmp.Right, tmp.Y + (tmp.Height / 2) + 1);
5399 dc.DrawLine (pen, tmp.X + (tmp.Width / 2), tmp.Y, tmp.X + (tmp.Width / 2), tmp.Bottom);
5400 dc.DrawLine (pen, tmp.X + (tmp.Width / 2) + 1, tmp.Y, tmp.X + (tmp.Width / 2) + 1, tmp.Bottom);
5405 public override void CPDrawReversibleFrame (Rectangle rectangle, Color backColor, FrameStyle style) {
5410 public override void CPDrawReversibleLine (Point start, Point end, Color backColor) {
5415 /* Scroll button: regular button + direction arrow */
5416 public override void CPDrawScrollButton (Graphics dc, Rectangle area, ScrollButton type, ButtonState state)
5418 DrawScrollButtonPrimitive (dc, area, state);
5420 bool fill_rect = true;
5423 if ((state & ButtonState.Pushed) != 0)
5427 Rectangle rect = new Rectangle (area.X + 2 + offset, area.Y + 2 + offset, area.Width - 4, area.Height - 4);
5429 Point [] arrow = new Point [3];
5430 for (int i = 0; i < 3; i++)
5431 arrow [i] = new Point ();
5433 Pen pen = SystemPens.ControlText;
5435 if ((state & ButtonState.Inactive) != 0) {
5436 pen = SystemPens.ControlDark;
5441 case ScrollButton.Down:
5442 int x_middle = (int)Math.Round (rect.Width / 2.0f) - 1;
5443 int y_middle = (int)Math.Round (rect.Height / 2.0f) - 1;
5447 int triangle_height;
5449 if (rect.Height < 8) {
5450 triangle_height = 2;
5452 } else if (rect.Height == 11) {
5453 triangle_height = 3;
5455 triangle_height = (int)Math.Round (rect.Height / 3.0f);
5458 arrow [0].X = rect.X + x_middle;
5459 arrow [0].Y = rect.Y + y_middle + triangle_height / 2;
5461 arrow [1].X = arrow [0].X + triangle_height - 1;
5462 arrow [1].Y = arrow [0].Y - triangle_height + 1;
5463 arrow [2].X = arrow [0].X - triangle_height + 1;
5464 arrow [2].Y = arrow [1].Y;
5466 dc.DrawPolygon (pen, arrow);
5468 if ((state & ButtonState.Inactive) != 0) {
5469 dc.DrawLine (SystemPens.ControlLightLight, arrow [1].X + 1, arrow [1].Y + 1, arrow [0].X + 1, arrow [0].Y + 1);
5470 dc.DrawLine (SystemPens.ControlLightLight, arrow [1].X, arrow [1].Y + 1, arrow [0].X + 1, arrow [0].Y);
5474 for (int i = 0; i < arrow [0].Y - arrow [1].Y; i++) {
5475 dc.DrawLine (pen, arrow [1].X, arrow [1].Y + i, arrow [2].X, arrow [1].Y + i);
5482 case ScrollButton.Up:
5483 x_middle = (int)Math.Round (rect.Width / 2.0f) - 1;
5484 y_middle = (int)Math.Round (rect.Height / 2.0f);
5491 if (rect.Height < 8) {
5492 triangle_height = 2;
5494 } else if (rect.Height == 11) {
5495 triangle_height = 3;
5497 triangle_height = (int)Math.Round (rect.Height / 3.0f);
5500 arrow [0].X = rect.X + x_middle;
5501 arrow [0].Y = rect.Y + y_middle - triangle_height / 2;
5503 arrow [1].X = arrow [0].X + triangle_height - 1;
5504 arrow [1].Y = arrow [0].Y + triangle_height - 1;
5505 arrow [2].X = arrow [0].X - triangle_height + 1;
5506 arrow [2].Y = arrow [1].Y;
5508 dc.DrawPolygon (pen, arrow);
5510 if ((state & ButtonState.Inactive) != 0) {
5511 dc.DrawLine (SystemPens.ControlLightLight, arrow [1].X + 1, arrow [1].Y + 1, arrow [2].X + 1, arrow [1].Y + 1);
5515 for (int i = 0; i < arrow [1].Y - arrow [0].Y; i++) {
5516 dc.DrawLine (pen, arrow [2].X, arrow [1].Y - i, arrow [1].X, arrow [1].Y - i);
5523 case ScrollButton.Left:
5524 y_middle = (int)Math.Round (rect.Height / 2.0f) - 1;
5530 if (rect.Width < 8) {
5533 } else if (rect.Width == 11) {
5536 triangle_width = (int)Math.Round (rect.Width / 3.0f);
5539 arrow [0].X = rect.Left + triangle_width - 1;
5540 arrow [0].Y = rect.Y + y_middle;
5542 if (arrow [0].X - 1 == rect.X)
5545 arrow [1].X = arrow [0].X + triangle_width - 1;
5546 arrow [1].Y = arrow [0].Y - triangle_width + 1;
5547 arrow [2].X = arrow [1].X;
5548 arrow [2].Y = arrow [0].Y + triangle_width - 1;
5550 dc.DrawPolygon (pen, arrow);
5552 if ((state & ButtonState.Inactive) != 0) {
5553 dc.DrawLine (SystemPens.ControlLightLight, arrow [1].X + 1, arrow [1].Y + 1, arrow [2].X + 1, arrow [2].Y + 1);
5557 for (int i = 0; i < arrow [2].X - arrow [0].X; i++) {
5558 dc.DrawLine (pen, arrow [2].X - i, arrow [1].Y, arrow [2].X - i, arrow [2].Y);
5565 case ScrollButton.Right:
5566 y_middle = (int)Math.Round (rect.Height / 2.0f) - 1;
5570 if (rect.Width < 8) {
5573 } else if (rect.Width == 11) {
5576 triangle_width = (int)Math.Round (rect.Width / 3.0f);
5579 arrow [0].X = rect.Right - triangle_width - 1;
5580 arrow [0].Y = rect.Y + y_middle;
5582 if (arrow [0].X - 1 == rect.X)
5585 arrow [1].X = arrow [0].X - triangle_width + 1;
5586 arrow [1].Y = arrow [0].Y - triangle_width + 1;
5587 arrow [2].X = arrow [1].X;
5588 arrow [2].Y = arrow [0].Y + triangle_width - 1;
5590 dc.DrawPolygon (pen, arrow);
5592 if ((state & ButtonState.Inactive) != 0) {
5593 dc.DrawLine (SystemPens.ControlLightLight, arrow [0].X + 1, arrow [0].Y + 1, arrow [2].X + 1, arrow [2].Y + 1);
5594 dc.DrawLine (SystemPens.ControlLightLight, arrow [0].X, arrow [0].Y + 1, arrow [2].X + 1, arrow [2].Y);
5598 for (int i = 0; i < arrow [0].X - arrow [1].X; i++) {
5599 dc.DrawLine (pen, arrow [2].X + i, arrow [1].Y, arrow [2].X + i, arrow [2].Y);
5608 public override void CPDrawSelectionFrame (Graphics graphics, bool active, Rectangle outsideRect, Rectangle insideRect,
5614 public override void CPDrawSizeGrip (Graphics dc, Color backColor, Rectangle bounds)
5616 Pen pen_dark = ResPool.GetPen(ControlPaint.Dark(backColor));
5617 Pen pen_light_light = ResPool.GetPen(ControlPaint.LightLight(backColor));
5619 for (int i = 2; i < bounds.Width - 2; i += 4) {
5620 dc.DrawLine (pen_light_light, bounds.X + i, bounds.Bottom - 2, bounds.Right - 1, bounds.Y + i - 1);
5621 dc.DrawLine (pen_dark, bounds.X + i + 1, bounds.Bottom - 2, bounds.Right - 1, bounds.Y + i);
5622 dc.DrawLine (pen_dark, bounds.X + i + 2, bounds.Bottom - 2, bounds.Right - 1, bounds.Y + i + 1);
5626 public override void CPDrawStringDisabled (Graphics dc, string s, Font font, Color color, RectangleF layoutRectangle, StringFormat format)
5628 CPColor cpcolor = ResPool.GetCPColor (color);
5630 dc.DrawString (s, font, ResPool.GetSolidBrush(cpcolor.LightLight),
5631 new RectangleF(layoutRectangle.X + 1, layoutRectangle.Y + 1, layoutRectangle.Width, layoutRectangle.Height),
5633 dc.DrawString (s, font, ResPool.GetSolidBrush (cpcolor.Dark), layoutRectangle, format);
5636 private static void DrawBorderInternal(Graphics graphics, int startX, int startY, int endX, int endY,
5637 int width, Color color, ButtonBorderStyle style, Border3DSide side) {
5642 case ButtonBorderStyle.Solid:
5643 case ButtonBorderStyle.Inset:
5644 case ButtonBorderStyle.Outset:
5645 pen = ThemeEngine.Current.ResPool.GetDashPen (color, DashStyle.Solid);
5647 case ButtonBorderStyle.Dashed:
5648 pen = ThemeEngine.Current.ResPool.GetDashPen (color, DashStyle.Dash);
5650 case ButtonBorderStyle.Dotted:
5651 pen = ThemeEngine.Current.ResPool.GetDashPen (color, DashStyle.Dot);
5654 case ButtonBorderStyle.None:
5659 case ButtonBorderStyle.Outset: {
5661 int hue, brightness, saturation;
5662 int brightnessSteps;
5663 int brightnessDownSteps;
5665 ControlPaint.Color2HBS(color, out hue, out brightness, out saturation);
5667 brightnessDownSteps=brightness/width;
5668 if (brightness>127) {
5669 brightnessSteps=Math.Max(6, (160-brightness)/width);
5671 brightnessSteps=(127-brightness)/width;
5674 for (int i=0; i<width; i++) {
5676 case Border3DSide.Left: {
5677 colorGrade=ControlPaint.HBS2Color(hue, Math.Min(255, brightness+brightnessSteps*(width-i)), saturation);
5678 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
5679 graphics.DrawLine(pen, startX+i, startY+i, endX+i, endY-i);
5683 case Border3DSide.Right: {
5684 colorGrade=ControlPaint.HBS2Color(hue, Math.Max(0, brightness-brightnessDownSteps*(width-i)), saturation);
5685 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
5686 graphics.DrawLine(pen, startX-i, startY+i, endX-i, endY-i);
5690 case Border3DSide.Top: {
5691 colorGrade=ControlPaint.HBS2Color(hue, Math.Min(255, brightness+brightnessSteps*(width-i)), saturation);
5692 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
5693 graphics.DrawLine(pen, startX+i, startY+i, endX-i, endY+i);
5697 case Border3DSide.Bottom: {
5698 colorGrade=ControlPaint.HBS2Color(hue, Math.Max(0, brightness-brightnessDownSteps*(width-i)), saturation);
5699 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
5700 graphics.DrawLine(pen, startX+i, startY-i, endX-i, endY-i);
5708 case ButtonBorderStyle.Inset: {
5710 int hue, brightness, saturation;
5711 int brightnessSteps;
5712 int brightnessDownSteps;
5714 ControlPaint.Color2HBS(color, out hue, out brightness, out saturation);
5716 brightnessDownSteps=brightness/width;
5717 if (brightness>127) {
5718 brightnessSteps=Math.Max(6, (160-brightness)/width);
5720 brightnessSteps=(127-brightness)/width;
5723 for (int i=0; i<width; i++) {
5725 case Border3DSide.Left: {
5726 colorGrade=ControlPaint.HBS2Color(hue, Math.Max(0, brightness-brightnessDownSteps*(width-i)), saturation);
5727 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
5728 graphics.DrawLine(pen, startX+i, startY+i, endX+i, endY-i);
5732 case Border3DSide.Right: {
5733 colorGrade=ControlPaint.HBS2Color(hue, Math.Min(255, brightness+brightnessSteps*(width-i)), saturation);
5734 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
5735 graphics.DrawLine(pen, startX-i, startY+i, endX-i, endY-i);
5739 case Border3DSide.Top: {
5740 colorGrade=ControlPaint.HBS2Color(hue, Math.Max(0, brightness-brightnessDownSteps*(width-i)), saturation);
5741 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
5742 graphics.DrawLine(pen, startX+i, startY+i, endX-i, endY+i);
5746 case Border3DSide.Bottom: {
5747 colorGrade=ControlPaint.HBS2Color(hue, Math.Min(255, brightness+brightnessSteps*(width-i)), saturation);
5748 pen = ThemeEngine.Current.ResPool.GetPen (colorGrade);
5749 graphics.DrawLine(pen, startX+i, startY-i, endX-i, endY-i);
5758 I decided to have the for-loop duplicated for speed reasons;
5759 that way we only have to switch once (as opposed to have the
5760 for-loop around the switch)
5764 case Border3DSide.Left: {
5765 for (int i=0; i<width; i++) {
5766 graphics.DrawLine(pen, startX+i, startY+i, endX+i, endY-i);
5771 case Border3DSide.Right: {
5772 for (int i=0; i<width; i++) {
5773 graphics.DrawLine(pen, startX-i, startY+i, endX-i, endY-i);
5778 case Border3DSide.Top: {
5779 for (int i=0; i<width; i++) {
5780 graphics.DrawLine(pen, startX+i, startY+i, endX-i, endY+i);
5785 case Border3DSide.Bottom: {
5786 for (int i=0; i<width; i++) {
5787 graphics.DrawLine(pen, startX+i, startY-i, endX-i, endY-i);
5798 This function actually draws the various caption elements.
5799 This way we can scale them nicely, no matter what size, and they
5800 still look like MS's scaled caption buttons. (as opposed to scaling a bitmap)
5803 private void DrawCaptionHelper(Graphics graphics, Color color, Pen pen, int lineWidth, int shift, Rectangle captionRect, CaptionButton button) {
5805 case CaptionButton.Close: {
5807 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);
5808 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);
5811 graphics.DrawLine(pen, captionRect.Left+2*lineWidth+shift, captionRect.Top+2*lineWidth+shift, captionRect.Right-2*lineWidth+shift, captionRect.Bottom-2*lineWidth+shift);
5812 graphics.DrawLine(pen, captionRect.Right-2*lineWidth+shift, captionRect.Top+2*lineWidth+shift, captionRect.Left+2*lineWidth+shift, captionRect.Bottom-2*lineWidth+shift);
5816 case CaptionButton.Help: {
5817 StringFormat sf = new StringFormat();
5818 Font font = new Font("Microsoft Sans Serif", captionRect.Height, FontStyle.Bold, GraphicsUnit.Pixel);
5820 sf.Alignment=StringAlignment.Center;
5821 sf.LineAlignment=StringAlignment.Center;
5824 graphics.DrawString("?", font, ResPool.GetSolidBrush (color), captionRect.X+captionRect.Width/2+shift, captionRect.Y+captionRect.Height/2+shift+lineWidth/2, sf);
5832 case CaptionButton.Maximize: {
5833 /* Top 'caption bar' line */
5834 for (int i=0; i<Math.Max(2, lineWidth); i++) {
5835 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);
5838 /* Left side line */
5839 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
5840 graphics.DrawLine(pen, captionRect.Left+lineWidth+shift+i, captionRect.Top+2*lineWidth+shift, captionRect.Left+lineWidth+shift+i, captionRect.Bottom-lineWidth+shift);
5843 /* Right side line */
5844 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
5845 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);
5849 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
5850 graphics.DrawLine(pen, captionRect.Left+lineWidth+shift, captionRect.Bottom-lineWidth+shift-i, captionRect.Right-lineWidth-lineWidth/2+shift, captionRect.Bottom-lineWidth+shift-i);
5855 case CaptionButton.Minimize: {
5857 for (int i=0; i<Math.Max(2, lineWidth); i++) {
5858 graphics.DrawLine(pen, captionRect.Left+lineWidth+shift, captionRect.Bottom-lineWidth+shift-i, captionRect.Right-3*lineWidth+shift, captionRect.Bottom-lineWidth+shift-i);
5863 case CaptionButton.Restore: {
5864 /** First 'window' **/
5865 /* Top 'caption bar' line */
5866 for (int i=0; i<Math.Max(2, lineWidth); i++) {
5867 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);
5870 /* Left side line */
5871 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
5872 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);
5875 /* Right side line */
5876 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
5877 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);
5881 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
5882 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);
5885 /** Second 'window' **/
5886 /* Top 'caption bar' line */
5887 for (int i=0; i<Math.Max(2, lineWidth); i++) {
5888 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);
5891 /* Left side line */
5892 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
5893 graphics.DrawLine(pen, captionRect.Left+lineWidth+shift+i, captionRect.Top+4*lineWidth+shift+1, captionRect.Left+lineWidth+shift+i, captionRect.Bottom-lineWidth+shift);
5896 /* Right side line */
5897 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
5898 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);
5902 for (int i=0; i<Math.Max(1, lineWidth/2); i++) {
5903 graphics.DrawLine(pen, captionRect.Left+lineWidth+shift, captionRect.Bottom-lineWidth+shift-i, captionRect.Right-3*lineWidth-lineWidth/2+shift, captionRect.Bottom-lineWidth+shift-i);
5912 /* Generic scroll button */
5913 public void DrawScrollButtonPrimitive (Graphics dc, Rectangle area, ButtonState state) {
5914 if ((state & ButtonState.Pushed) == ButtonState.Pushed) {
5915 dc.FillRectangle (SystemBrushes.Control, area.X + 1,
5916 area.Y + 1, area.Width - 2 , area.Height - 2);
5918 dc.DrawRectangle (SystemPens.ControlDark, area.X,
5919 area.Y, area.Width, area.Height);
5924 Brush sb_control = SystemBrushes.Control;
5925 Brush sb_lightlight = SystemBrushes.ControlLightLight;
5926 Brush sb_dark = SystemBrushes.ControlDark;
5927 Brush sb_darkdark = SystemBrushes.ControlDarkDark;
5929 dc.FillRectangle (sb_control, area.X, area.Y, area.Width, 1);
5930 dc.FillRectangle (sb_control, area.X, area.Y, 1, area.Height);
5932 dc.FillRectangle (sb_lightlight, area.X + 1, area.Y + 1, area.Width - 1, 1);
5933 dc.FillRectangle (sb_lightlight, area.X + 1, area.Y + 2, 1,
5936 dc.FillRectangle (sb_dark, area.X + 1, area.Y + area.Height - 2,
5939 dc.FillRectangle (sb_darkdark, area.X, area.Y + area.Height -1,
5942 dc.FillRectangle (sb_dark, area.X + area.Width - 2,
5943 area.Y + 1, 1, area.Height -3);
5945 dc.FillRectangle (sb_darkdark, area.X + area.Width -1,
5946 area.Y, 1, area.Height - 1);
5948 dc.FillRectangle (sb_control, area.X + 2,
5949 area.Y + 2, area.Width - 4, area.Height - 4);
5953 public override void CPDrawBorderStyle (Graphics dc, Rectangle area, BorderStyle border_style) {
5954 switch (border_style){
5955 case BorderStyle.Fixed3D:
5956 dc.DrawLine (ResPool.GetPen (ColorControlDark), area.X, area.Y, area.X +area.Width, area.Y);
5957 dc.DrawLine (ResPool.GetPen (ColorControlDark), area.X, area.Y, area.X, area.Y + area.Height);
5958 dc.DrawLine (ResPool.GetPen (ColorControlLight), area.X , area.Y + area.Height - 1, area.X + area.Width ,
5959 area.Y + area.Height - 1);
5960 dc.DrawLine (ResPool.GetPen (ColorControlLight), area.X + area.Width -1 , area.Y, area.X + area.Width -1,
5961 area.Y + area.Height);
5963 dc.DrawLine (ResPool.GetPen (ColorActiveBorder), area.X + 1, area.Bottom - 2, area.Right - 2, area.Bottom - 2);
5964 dc.DrawLine (ResPool.GetPen (ColorActiveBorder), area.Right - 2, area.Top + 1, area.Right - 2, area.Bottom - 2);
5965 dc.DrawLine (ResPool.GetPen (ColorControlDarkDark), area.X + 1, area.Top + 1, area.X + 1, area.Bottom - 3);
5966 dc.DrawLine (ResPool.GetPen (ColorControlDarkDark), area.X + 1, area.Top + 1, area.Right - 3, area.Top + 1);
5968 case BorderStyle.FixedSingle:
5969 dc.DrawRectangle (ResPool.GetPen (ColorWindowFrame), area.X, area.Y, area.Width - 1, area.Height - 1);
5971 case BorderStyle.None:
5977 #endregion // ControlPaint