Merge pull request #17 from MichaelTheShifter/shiftui_integration

Shiftui integration

1 files changed, 8348 insertions, 0 deletions

diff --git a/source/ShiftUI/Theming/ThemeSkinnable.cs b/source/ShiftUI/Theming/ThemeSkinnable.cs
new file mode 100644
index 0000000..5ea8a4d
--- /dev/null
+++ b/source/ShiftUI/Theming/ThemeSkinnable.cs
@@ -0,0 +1,8348 @@
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+// Copyright (c) 2004-2006 Novell, Inc.
+//
+// Authors:
+//	Jordi Mas i Hernandez, [email protected]
+//	Peter Bartok, [email protected]
+//	John BouAntoun, [email protected]
+//	Marek Safar, [email protected]
+//	Alexander Olk, [email protected]
+//
+
+using System.ComponentModel;
+using System.Data;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Drawing.Imaging;
+using System.Drawing.Printing;
+using System.Drawing.Text;
+using System.Text;
+using ShiftUI.Theming;
+using System;
+
+namespace ShiftUI
+{
+
+    internal class ThemeSkinnable : Theme
+    {
+        public void LoadSkin(ShiftOS.Skin skin)
+        {
+            Application.LoadSkin(skin);
+            MemphisThemeElements.Init();
+        }
+
+        public override Version Version
+        {
+            get
+            {
+                return new Version("0.0.1.alpha1");
+            }
+        }
+
+        /* Hardcoded colour values not exposed in the API constants in all configurations */
+        protected static readonly Color arrow_color = Color.Black;
+        protected static readonly Color pen_ticks_color = Color.Black;
+        protected static StringFormat string_format_menu_text;
+        protected static StringFormat string_format_menu_shortcut;
+        protected static StringFormat string_format_menu_menubar_text;
+        static ImageAttributes imagedisabled_attributes;
+        Font window_border_font;
+        const int SEPARATOR_HEIGHT = 6;
+        const int SEPARATOR_MIN_WIDTH = 20;
+        const int SM_CXBORDER = 1;
+        const int SM_CYBORDER = 1;
+        const int MENU_TAB_SPACE = 8;       // Pixels added to the width of an item because of a tabd
+        const int MENU_BAR_ITEMS_SPACE = 8; // Space between menu bar items
+        const int CheckSize = 13;
+
+        #region	Principal Theme Methods
+        public ThemeSkinnable()
+        {
+            if (Application.CurrentSkin == null)
+                Application.LoadSkin(new ShiftOS.DefaultSkin());
+            ResetDefaults();
+        }
+
+        public override void ResetDefaults()
+        {
+            defaultWindowBackColor = Application.CurrentSkin.WindowBackColor;
+            defaultWindowForeColor = Application.CurrentSkin.DefaultForeColor;
+            window_border_font = new Font("Microsoft Sans Serif", 9, FontStyle.Bold);
+
+            /* Menu string formats */
+            string_format_menu_text = new StringFormat();
+            string_format_menu_text.LineAlignment = StringAlignment.Center;
+            string_format_menu_text.Alignment = StringAlignment.Near;
+            string_format_menu_text.HotkeyPrefix = HotkeyPrefix.Show;
+            string_format_menu_text.SetTabStops(0f, new float[] { 50f });
+            string_format_menu_text.FormatFlags |= StringFormatFlags.NoWrap;
+
+            string_format_menu_shortcut = new StringFormat();
+            string_format_menu_shortcut.LineAlignment = StringAlignment.Center;
+            string_format_menu_shortcut.Alignment = StringAlignment.Far;
+
+            string_format_menu_menubar_text = new StringFormat();
+            string_format_menu_menubar_text.LineAlignment = StringAlignment.Center;
+            string_format_menu_menubar_text.Alignment = StringAlignment.Center;
+            string_format_menu_menubar_text.HotkeyPrefix = HotkeyPrefix.Show;
+        }
+
+        public override bool DoubleBufferingSupported
+        {
+            get { return true; }
+        }
+
+        public override int HorizontalScrollBarHeight
+        {
+            get
+            {
+                return Application.CurrentSkin.ScrollbarWidth;
+            }
+        }
+
+        public override int VerticalScrollBarWidth
+        {
+            get
+            {
+                return Application.CurrentSkin.ScrollbarWidth;
+            }
+        }
+
+        public override Font WindowBorderFont
+        {
+            get
+            {
+                return window_border_font ?? (window_border_font = new Font(FontFamily.GenericSansSerif, 8.25f, FontStyle.Bold));
+            }
+        }
+
+        #endregion // Principal Theme Methods
+
+        #region	Internal Methods
+        protected Brush GetControlBackBrush(Color c)
+        {
+            if (c.ToArgb() == DefaultControlBackColor.ToArgb())
+                return SystemBrushes.Control;
+            return ResPool.GetSolidBrush(c);
+        }
+
+        protected Brush GetControlForeBrush(Color c)
+        {
+            if (c.ToArgb() == DefaultControlForeColor.ToArgb())
+                return SystemBrushes.ControlText;
+            return ResPool.GetSolidBrush(c);
+        }
+        #endregion // Internal Methods
+
+        #region Widget
+        public override Font GetLinkFont(Widget control)
+        {
+            return new Font(control.Font.FontFamily, control.Font.Size, control.Font.Style | FontStyle.Underline, control.Font.Unit);
+        }
+        #endregion // Widget
+
+        #region OwnerDraw Support
+        public override void DrawOwnerDrawBackground(DrawItemEventArgs e)
+        {
+            if ((e.State & DrawItemState.Selected) == DrawItemState.Selected)
+            {
+                e.Graphics.FillRectangle(SystemBrushes.Highlight, e.Bounds);
+                return;
+            }
+
+            e.Graphics.FillRectangle(ResPool.GetSolidBrush(e.BackColor), e.Bounds);
+        }
+
+        public override void DrawOwnerDrawFocusRectangle(DrawItemEventArgs e)
+        {
+            if (e.State == DrawItemState.Focus)
+                CPDrawFocusRectangle(e.Graphics, e.Bounds, e.ForeColor, e.BackColor);
+        }
+        #endregion // OwnerDraw Support
+
+        #region Button
+        #region Standard Button Style
+        public override void DrawButton(Graphics g, Button b, Rectangle textBounds, Rectangle imageBounds, Rectangle clipRectangle)
+        {
+            // Draw Button Background
+            DrawButtonBackground(g, b, clipRectangle);
+
+            // If we have an image, draw it
+            if (imageBounds.Size != Size.Empty)
+                DrawButtonImage(g, b, imageBounds);
+
+            // If we're focused, draw a focus rectangle
+            if (b.Focused && b.Enabled && b.ShowFocusCues)
+                DrawButtonFocus(g, b);
+
+            // If we have text, draw it
+            if (textBounds != Rectangle.Empty)
+                DrawButtonText(g, b, textBounds);
+        }
+
+        public virtual void DrawButtonBackground(Graphics g, Button button, Rectangle clipArea)
+        {
+            var fc = button.ForeColor;
+            if (fc == null)
+                fc = Application.CurrentSkin.DefaultForeColor;
+
+            if (button.Pressed)
+                MemphisThemeElements.DrawButton(g, button.ClientRectangle, ButtonThemeState.Pressed, Application.CurrentSkin.ButtonBackColor_Pressed, fc);
+            else if (button.InternalSelected)
+                MemphisThemeElements.DrawButton(g, button.ClientRectangle, ButtonThemeState.Default, Application.CurrentSkin.ButtonBackColor, fc);
+            else if (button.Entered)
+                MemphisThemeElements.DrawButton(g, button.ClientRectangle, ButtonThemeState.Entered, Application.CurrentSkin.ButtonBackColor, fc);
+            else if (!button.Enabled)
+                MemphisThemeElements.DrawButton(g, button.ClientRectangle, ButtonThemeState.Disabled, Application.CurrentSkin.ButtonBackColor, fc);
+            else
+                MemphisThemeElements.DrawButton(g, button.ClientRectangle, ButtonThemeState.Normal, Application.CurrentSkin.ButtonBackColor, fc);
+        }
+
+        public virtual void DrawButtonFocus(Graphics g, Button button)
+        {
+            WidgetPaint.DrawFocusRectangle(g, Rectangle.Inflate(button.ClientRectangle, -4, -4));
+        }
+
+        public virtual void DrawButtonImage(Graphics g, ButtonBase button, Rectangle imageBounds)
+        {
+            if (button.Enabled)
+                g.DrawImage(button.Image, imageBounds);
+            else
+                CPDrawImageDisabled(g, button.Image, imageBounds.Left, imageBounds.Top, ColorControl);
+        }
+
+        public virtual void DrawButtonText(Graphics g, ButtonBase button, Rectangle textBounds)
+        {
+            // Ensure that at least one line is going to get displayed.
+            // Line limit does not ensure that despite its description.
+            if (button.Font != null && button.Font.Height > 0)
+                textBounds.Height = Math.Max(textBounds.Height, button.Font.Height);
+
+            if (button.Enabled)
+                TextRenderer.DrawTextInternal(g, button.Text, button.Font, textBounds, button.ForeColor, button.TextFormatFlags, button.UseCompatibleTextRendering);
+            else
+                DrawStringDisabled20(g, button.Text, button.Font, textBounds, button.BackColor, button.TextFormatFlags, button.UseCompatibleTextRendering);
+        }
+        #endregion
+
+        #region FlatStyle Button Style
+        public override void DrawFlatButton(Graphics g, ButtonBase b, Rectangle textBounds, Rectangle imageBounds, Rectangle clipRectangle)
+        {
+            // Draw Button Background
+            if (b.BackgroundImage == null)
+                DrawFlatButtonBackground(g, b, clipRectangle);
+
+            // If we have an image, draw it
+            if (imageBounds.Size != Size.Empty)
+                DrawFlatButtonImage(g, b, imageBounds);
+
+            // If we're focused, draw a focus rectangle
+            if (b.Focused && b.Enabled && b.ShowFocusCues)
+                DrawFlatButtonFocus(g, b);
+
+            // If we have text, draw it
+            if (textBounds != Rectangle.Empty)
+                DrawFlatButtonText(g, b, textBounds);
+        }
+
+        public virtual void DrawFlatButtonBackground(Graphics g, ButtonBase button, Rectangle clipArea)
+        {
+            if (button.Pressed)
+                MemphisThemeElements.DrawFlatButton(g, button.ClientRectangle, ButtonThemeState.Pressed, button.BackColor, button.ForeColor, button.FlatAppearance);
+            else if (button.InternalSelected)
+            {
+                if (button.Entered)
+                    MemphisThemeElements.DrawFlatButton(g, button.ClientRectangle, ButtonThemeState.Default | ButtonThemeState.Entered, button.BackColor, button.ForeColor, button.FlatAppearance);
+                else
+                    MemphisThemeElements.DrawFlatButton(g, button.ClientRectangle, ButtonThemeState.Default, button.BackColor, button.ForeColor, button.FlatAppearance);
+            }
+            else if (button.Entered)
+                MemphisThemeElements.DrawFlatButton(g, button.ClientRectangle, ButtonThemeState.Entered, button.BackColor, button.ForeColor, button.FlatAppearance);
+            else if (!button.Enabled)
+                MemphisThemeElements.DrawFlatButton(g, button.ClientRectangle, ButtonThemeState.Disabled, button.BackColor, button.ForeColor, button.FlatAppearance);
+            else
+                MemphisThemeElements.DrawFlatButton(g, button.ClientRectangle, ButtonThemeState.Normal, button.BackColor, button.ForeColor, button.FlatAppearance);
+        }
+
+        public virtual void DrawFlatButtonFocus(Graphics g, ButtonBase button)
+        {
+            if (!button.Pressed)
+            {
+                Color focus_color = WidgetPaint.Dark(button.BackColor);
+                g.DrawRectangle(ResPool.GetPen(focus_color), new Rectangle(button.ClientRectangle.Left + 4, button.ClientRectangle.Top + 4, button.ClientRectangle.Width - 9, button.ClientRectangle.Height - 9));
+            }
+        }
+
+        public virtual void DrawFlatButtonImage(Graphics g, ButtonBase button, Rectangle imageBounds)
+        {
+            // No changes from Standard for image for this theme
+            DrawButtonImage(g, button, imageBounds);
+        }
+
+        public virtual void DrawFlatButtonText(Graphics g, ButtonBase button, Rectangle textBounds)
+        {
+            // No changes from Standard for text for this theme
+            DrawButtonText(g, button, textBounds);
+        }
+        #endregion
+
+        #region Popup Button Style
+        public override void DrawPopupButton(Graphics g, Button b, Rectangle textBounds, Rectangle imageBounds, Rectangle clipRectangle)
+        {
+            // Draw Button Background
+            DrawPopupButtonBackground(g, b, clipRectangle);
+
+            // If we have an image, draw it
+            if (imageBounds.Size != Size.Empty)
+                DrawPopupButtonImage(g, b, imageBounds);
+
+            // If we're focused, draw a focus rectangle
+            if (b.Focused && b.Enabled && b.ShowFocusCues)
+                DrawPopupButtonFocus(g, b);
+
+            // If we have text, draw it
+            if (textBounds != Rectangle.Empty)
+                DrawPopupButtonText(g, b, textBounds);
+        }
+
+        public virtual void DrawPopupButtonBackground(Graphics g, Button button, Rectangle clipArea)
+        {
+            if (button.Pressed)
+                MemphisThemeElements.DrawPopupButton(g, button.ClientRectangle, ButtonThemeState.Pressed, button.BackColor, button.ForeColor);
+            else if (button.Entered)
+                MemphisThemeElements.DrawPopupButton(g, button.ClientRectangle, ButtonThemeState.Entered, button.BackColor, button.ForeColor);
+            else if (button.InternalSelected)
+                MemphisThemeElements.DrawPopupButton(g, button.ClientRectangle, ButtonThemeState.Default, button.BackColor, button.ForeColor);
+            else if (!button.Enabled)
+                MemphisThemeElements.DrawPopupButton(g, button.ClientRectangle, ButtonThemeState.Disabled, button.BackColor, button.ForeColor);
+            else
+                MemphisThemeElements.DrawPopupButton(g, button.ClientRectangle, ButtonThemeState.Normal, button.BackColor, button.ForeColor);
+        }
+
+        public virtual void DrawPopupButtonFocus(Graphics g, Button button)
+        {
+            // No changes from Standard for image for this theme
+            DrawButtonFocus(g, button);
+        }
+
+        public virtual void DrawPopupButtonImage(Graphics g, Button button, Rectangle imageBounds)
+        {
+            // No changes from Standard for image for this theme
+            DrawButtonImage(g, button, imageBounds);
+        }
+
+        public virtual void DrawPopupButtonText(Graphics g, Button button, Rectangle textBounds)
+        {
+            // No changes from Standard for image for this theme
+            DrawButtonText(g, button, textBounds);
+        }
+        #endregion
+
+        #region Button Layout Calculations
+        public override Size CalculateButtonAutoSize(Button button)
+        {
+            Size ret_size = Size.Empty;
+            Size text_size = TextRenderer.MeasureTextInternal(button.Text, button.Font, button.UseCompatibleTextRendering);
+            Size image_size = button.Image == null ? Size.Empty : button.Image.Size;
+
+            // Pad the text size
+            if (button.Text.Length != 0)
+            {
+                text_size.Height += 4;
+                text_size.Width += 4;
+            }
+
+            switch (button.TextImageRelation)
+            {
+                case TextImageRelation.Overlay:
+                    ret_size.Height = Math.Max(button.Text.Length == 0 ? 0 : text_size.Height, image_size.Height);
+                    ret_size.Width = Math.Max(text_size.Width, image_size.Width);
+                    break;
+                case TextImageRelation.ImageAboveText:
+                case TextImageRelation.TextAboveImage:
+                    ret_size.Height = text_size.Height + image_size.Height;
+                    ret_size.Width = Math.Max(text_size.Width, image_size.Width);
+                    break;
+                case TextImageRelation.ImageBeforeText:
+                case TextImageRelation.TextBeforeImage:
+                    ret_size.Height = Math.Max(text_size.Height, image_size.Height);
+                    ret_size.Width = text_size.Width + image_size.Width;
+                    break;
+            }
+
+            // Pad the result
+            ret_size.Height += (button.Padding.Vertical + 6);
+            ret_size.Width += (button.Padding.Horizontal + 6);
+
+            return ret_size;
+        }
+
+        public override void CalculateButtonTextAndImageLayout(Graphics g, ButtonBase button, out Rectangle textRectangle, out Rectangle imageRectangle)
+        {
+            Image image = button.Image;
+            string text = button.Text;
+            Rectangle content_rect = button.PaddingClientRectangle;
+            Size text_size = TextRenderer.MeasureTextInternal(g, text, button.Font, content_rect.Size, button.TextFormatFlags, button.UseCompatibleTextRendering);
+            Size image_size = image == null ? Size.Empty : image.Size;
+
+            textRectangle = Rectangle.Inflate(content_rect, -4, -4);
+            imageRectangle = Rectangle.Empty;
+
+            bool displayEllipsis = (button.TextFormatFlags & (TextFormatFlags.EndEllipsis | TextFormatFlags.PathEllipsis | TextFormatFlags.WordEllipsis)) != 0;
+
+            switch (button.TextImageRelation)
+            {
+                case TextImageRelation.Overlay:
+                    // Overlay is easy, text always goes here
+
+                    // Image is dependent on ImageAlign
+                    if (image == null)
+                    {
+                        if (button.Pressed)
+                            textRectangle.Offset(1, 1);
+                        return;
+                    }
+
+                    int image_x = 0;
+                    int image_y = 0;
+                    int image_height = image.Height;
+                    int image_width = image.Width;
+
+                    switch (button.ImageAlign)
+                    {
+                        case System.Drawing.ContentAlignment.TopLeft:
+                            image_x = 5;
+                            image_y = 5;
+                            break;
+                        case System.Drawing.ContentAlignment.TopCenter:
+                            image_x = (content_rect.Width - image_width) / 2;
+                            image_y = 5;
+                            break;
+                        case System.Drawing.ContentAlignment.TopRight:
+                            image_x = content_rect.Width - image_width - 5;
+                            image_y = 5;
+                            break;
+                        case System.Drawing.ContentAlignment.MiddleLeft:
+                            image_x = 5;
+                            image_y = (content_rect.Height - image_height) / 2;
+                            break;
+                        case System.Drawing.ContentAlignment.MiddleCenter:
+                            image_x = (content_rect.Width - image_width) / 2;
+                            image_y = (content_rect.Height - image_height) / 2;
+                            break;
+                        case System.Drawing.ContentAlignment.MiddleRight:
+                            image_x = content_rect.Width - image_width - 4;
+                            image_y = (content_rect.Height - image_height) / 2;
+                            break;
+                        case System.Drawing.ContentAlignment.BottomLeft:
+                            image_x = 5;
+                            image_y = content_rect.Height - image_height - 4;
+                            break;
+                        case System.Drawing.ContentAlignment.BottomCenter:
+                            image_x = (content_rect.Width - image_width) / 2;
+                            image_y = content_rect.Height - image_height - 4;
+                            break;
+                        case System.Drawing.ContentAlignment.BottomRight:
+                            image_x = content_rect.Width - image_width - 4;
+                            image_y = content_rect.Height - image_height - 4;
+                            break;
+                        default:
+                            image_x = 5;
+                            image_y = 5;
+                            break;
+                    }
+
+                    imageRectangle = new Rectangle(image_x, image_y, image_width, image_height);
+                    break;
+                case TextImageRelation.ImageAboveText:
+                    LayoutTextAboveOrBelowImage(textRectangle, false, text_size, image_size, button.TextAlign, button.ImageAlign, displayEllipsis, out textRectangle, out imageRectangle);
+                    break;
+                case TextImageRelation.TextAboveImage:
+                    LayoutTextAboveOrBelowImage(textRectangle, true, text_size, image_size, button.TextAlign, button.ImageAlign, displayEllipsis, out textRectangle, out imageRectangle);
+                    break;
+                case TextImageRelation.ImageBeforeText:
+                    LayoutTextBeforeOrAfterImage(textRectangle, false, text_size, image_size, button.TextAlign, button.ImageAlign, out textRectangle, out imageRectangle);
+                    break;
+                case TextImageRelation.TextBeforeImage:
+                    LayoutTextBeforeOrAfterImage(textRectangle, true, text_size, image_size, button.TextAlign, button.ImageAlign, out textRectangle, out imageRectangle);
+                    break;
+            }
+            if (button.Pressed)
+                textRectangle.Offset(1, 1);
+        }
+
+        private void LayoutTextBeforeOrAfterImage(Rectangle totalArea, bool textFirst, Size textSize, Size imageSize, System.Drawing.ContentAlignment textAlign, System.Drawing.ContentAlignment imageAlign, out Rectangle textRect, out Rectangle imageRect)
+        {
+            int element_spacing = 0;    // Spacing between the Text and the Image
+            int total_width = textSize.Width + element_spacing + imageSize.Width;
+
+            if (!textFirst)
+                element_spacing += 2;
+
+            // If the text is too big, chop it down to the size we have available to it
+            if (total_width > totalArea.Width)
+            {
+                textSize.Width = totalArea.Width - element_spacing - imageSize.Width;
+                total_width = totalArea.Width;
+            }
+
+            int excess_width = totalArea.Width - total_width;
+            int offset = 0;
+
+            Rectangle final_text_rect;
+            Rectangle final_image_rect;
+
+            HorizontalAlignment h_text = GetHorizontalAlignment(textAlign);
+            HorizontalAlignment h_image = GetHorizontalAlignment(imageAlign);
+
+            if (h_image == HorizontalAlignment.Left)
+                offset = 0;
+            else if (h_image == HorizontalAlignment.Right && h_text == HorizontalAlignment.Right)
+                offset = excess_width;
+            else if (h_image == HorizontalAlignment.Center && (h_text == HorizontalAlignment.Left || h_text == HorizontalAlignment.Center))
+                offset += (int)(excess_width / 3);
+            else
+                offset += (int)(2 * (excess_width / 3));
+
+            if (textFirst)
+            {
+                final_text_rect = new Rectangle(totalArea.Left + offset, AlignInRectangle(totalArea, textSize, textAlign).Top, textSize.Width, textSize.Height);
+                final_image_rect = new Rectangle(final_text_rect.Right + element_spacing, AlignInRectangle(totalArea, imageSize, imageAlign).Top, imageSize.Width, imageSize.Height);
+            }
+            else
+            {
+                final_image_rect = new Rectangle(totalArea.Left + offset, AlignInRectangle(totalArea, imageSize, imageAlign).Top, imageSize.Width, imageSize.Height);
+                final_text_rect = new Rectangle(final_image_rect.Right + element_spacing, AlignInRectangle(totalArea, textSize, textAlign).Top, textSize.Width, textSize.Height);
+            }
+
+            textRect = final_text_rect;
+            imageRect = final_image_rect;
+        }
+
+        private void LayoutTextAboveOrBelowImage(Rectangle totalArea, bool textFirst, Size textSize, Size imageSize, System.Drawing.ContentAlignment textAlign, System.Drawing.ContentAlignment imageAlign, bool displayEllipsis, out Rectangle textRect, out Rectangle imageRect)
+        {
+            int element_spacing = 0;    // Spacing between the Text and the Image
+            int total_height = textSize.Height + element_spacing + imageSize.Height;
+
+            if (textFirst)
+                element_spacing += 2;
+
+            if (textSize.Width > totalArea.Width)
+                textSize.Width = totalArea.Width;
+
+            // If the there isn't enough room and we're text first, cut out the image
+            if (total_height > totalArea.Height && textFirst)
+            {
+                imageSize = Size.Empty;
+                total_height = totalArea.Height;
+            }
+
+            int excess_height = totalArea.Height - total_height;
+            int offset = 0;
+
+            Rectangle final_text_rect;
+            Rectangle final_image_rect;
+
+            VerticalAlignment v_text = GetVerticalAlignment(textAlign);
+            VerticalAlignment v_image = GetVerticalAlignment(imageAlign);
+
+            if (v_image == VerticalAlignment.Top)
+                offset = 0;
+            else if (v_image == VerticalAlignment.Bottom && v_text == VerticalAlignment.Bottom)
+                offset = excess_height;
+            else if (v_image == VerticalAlignment.Center && (v_text == VerticalAlignment.Top || v_text == VerticalAlignment.Center))
+                offset += (int)(excess_height / 3);
+            else
+                offset += (int)(2 * (excess_height / 3));
+
+            if (textFirst)
+            {
+                var textHeight = excess_height >= 0 ? totalArea.Height - imageSize.Height - element_spacing : textSize.Height;
+                final_text_rect = new Rectangle(AlignInRectangle(totalArea, textSize, textAlign).Left, totalArea.Top + offset, textSize.Width, textHeight);
+                final_image_rect = new Rectangle(AlignInRectangle(totalArea, imageSize, imageAlign).Left, final_text_rect.Bottom + element_spacing, imageSize.Width, imageSize.Height);
+            }
+            else
+            {
+                final_image_rect = new Rectangle(AlignInRectangle(totalArea, imageSize, imageAlign).Left, totalArea.Top + offset, imageSize.Width, imageSize.Height);
+                var textHeight = excess_height >= 0 ? totalArea.Height - final_image_rect.Height : textSize.Height;
+                final_text_rect = new Rectangle(AlignInRectangle(totalArea, textSize, textAlign).Left, final_image_rect.Bottom + element_spacing, textSize.Width, textHeight);
+
+                if (final_text_rect.Bottom > totalArea.Bottom)
+                {
+                    final_text_rect.Y -= (final_text_rect.Bottom - totalArea.Bottom);
+                    if (final_text_rect.Y < totalArea.Top)
+                        final_text_rect.Y = totalArea.Top;
+                }
+            }
+
+            if (displayEllipsis)
+            {
+                // Don't use more space than is available otherwise ellipsis won't show
+                if (final_text_rect.Height > totalArea.Bottom)
+                    final_text_rect.Height = totalArea.Bottom - final_text_rect.Top;
+            }
+
+            textRect = final_text_rect;
+            imageRect = final_image_rect;
+        }
+
+        private HorizontalAlignment GetHorizontalAlignment(System.Drawing.ContentAlignment align)
+        {
+            switch (align)
+            {
+                case System.Drawing.ContentAlignment.BottomLeft:
+                case System.Drawing.ContentAlignment.MiddleLeft:
+                case System.Drawing.ContentAlignment.TopLeft:
+                    return HorizontalAlignment.Left;
+                case System.Drawing.ContentAlignment.BottomCenter:
+                case System.Drawing.ContentAlignment.MiddleCenter:
+                case System.Drawing.ContentAlignment.TopCenter:
+                    return HorizontalAlignment.Center;
+                case System.Drawing.ContentAlignment.BottomRight:
+                case System.Drawing.ContentAlignment.MiddleRight:
+                case System.Drawing.ContentAlignment.TopRight:
+                    return HorizontalAlignment.Right;
+            }
+
+            return HorizontalAlignment.Left;
+        }
+
+        private enum VerticalAlignment
+        {
+            Top = 0,
+            Center = 1,
+            Bottom = 2
+        }
+
+        private VerticalAlignment GetVerticalAlignment(System.Drawing.ContentAlignment align)
+        {
+            switch (align)
+            {
+                case System.Drawing.ContentAlignment.TopLeft:
+                case System.Drawing.ContentAlignment.TopCenter:
+                case System.Drawing.ContentAlignment.TopRight:
+                    return VerticalAlignment.Top;
+                case System.Drawing.ContentAlignment.MiddleLeft:
+                case System.Drawing.ContentAlignment.MiddleCenter:
+                case System.Drawing.ContentAlignment.MiddleRight:
+                    return VerticalAlignment.Center;
+                case System.Drawing.ContentAlignment.BottomLeft:
+                case System.Drawing.ContentAlignment.BottomCenter:
+                case System.Drawing.ContentAlignment.BottomRight:
+                    return VerticalAlignment.Bottom;
+            }
+
+            return VerticalAlignment.Top;
+        }
+
+        internal Rectangle AlignInRectangle(Rectangle outer, Size inner, System.Drawing.ContentAlignment align)
+        {
+            int x = 0;
+            int y = 0;
+
+            if (align == System.Drawing.ContentAlignment.BottomLeft || align == System.Drawing.ContentAlignment.MiddleLeft || align == System.Drawing.ContentAlignment.TopLeft)
+                x = outer.X;
+            else if (align == System.Drawing.ContentAlignment.BottomCenter || align == System.Drawing.ContentAlignment.MiddleCenter || align == System.Drawing.ContentAlignment.TopCenter)
+                x = Math.Max(outer.X + ((outer.Width - inner.Width) / 2), outer.Left);
+            else if (align == System.Drawing.ContentAlignment.BottomRight || align == System.Drawing.ContentAlignment.MiddleRight || align == System.Drawing.ContentAlignment.TopRight)
+                x = outer.Right - inner.Width;
+            if (align == System.Drawing.ContentAlignment.TopCenter || align == System.Drawing.ContentAlignment.TopLeft || align == System.Drawing.ContentAlignment.TopRight)
+                y = outer.Y;
+            else if (align == System.Drawing.ContentAlignment.MiddleCenter || align == System.Drawing.ContentAlignment.MiddleLeft || align == System.Drawing.ContentAlignment.MiddleRight)
+                y = outer.Y + (outer.Height - inner.Height) / 2;
+            else if (align == System.Drawing.ContentAlignment.BottomCenter || align == System.Drawing.ContentAlignment.BottomRight || align == System.Drawing.ContentAlignment.BottomLeft)
+                y = outer.Bottom - inner.Height;
+
+            return new Rectangle(x, y, Math.Min(inner.Width, outer.Width), Math.Min(inner.Height, outer.Height));
+        }
+        #endregion
+        #endregion
+
+        #region ButtonBase
+        public override void DrawButtonBase(Graphics dc, Rectangle clip_area, ButtonBase button)
+        {
+            // Draw the button: Draw border, etc.
+            ButtonBase_DrawButton(button, dc);
+
+            // Draw the image
+            if (button.FlatStyle != FlatStyle.System && ((button.image != null) || (button.image_list != null)))
+                ButtonBase_DrawImage(button, dc);
+
+            // Draw the focus rectangle
+            if (ShouldPaintFocusRectagle(button))
+                ButtonBase_DrawFocus(button, dc);
+
+            // Now the text
+            if (button.Text != null && button.Text != String.Empty)
+                ButtonBase_DrawText(button, dc);
+        }
+
+        protected static bool ShouldPaintFocusRectagle(ButtonBase button)
+        {
+            return (button.Focused || button.paint_as_acceptbutton) && button.Enabled && button.ShowFocusCues;
+        }
+
+        protected virtual void ButtonBase_DrawButton(ButtonBase button, Graphics dc)
+        {
+            Rectangle borderRectangle;
+            bool check_or_radio = false;
+            bool check_or_radio_checked = false;
+
+            bool is_ColorControl = button.BackColor.ToArgb() == ColorControl.ToArgb() ? true : false;
+
+            CPColor cpcolor = is_ColorControl ? CPColor.Empty : ResPool.GetCPColor(button.BackColor);
+
+            if (button is CheckBox)
+            {
+                check_or_radio = true;
+                check_or_radio_checked = ((CheckBox)button).Checked;
+            }
+            else if (button is RadioButton)
+            {
+                check_or_radio = true;
+                check_or_radio_checked = ((RadioButton)button).Checked;
+            }
+
+            if (button.Focused && button.Enabled && !check_or_radio)
+            {
+                // shrink the rectangle for the normal button drawing inside the focus rectangle
+                borderRectangle = Rectangle.Inflate(button.ClientRectangle, -1, -1);
+            }
+            else
+            {
+                borderRectangle = button.ClientRectangle;
+            }
+
+            if (button.FlatStyle == FlatStyle.Popup)
+            {
+                if (!button.is_pressed && !button.is_entered && !check_or_radio_checked)
+                    Internal_DrawButton(dc, borderRectangle, 1, cpcolor, is_ColorControl, button.BackColor);
+                else if (!button.is_pressed && button.is_entered && !check_or_radio_checked)
+                    Internal_DrawButton(dc, borderRectangle, 2, cpcolor, is_ColorControl, button.BackColor);
+                else if (button.is_pressed || check_or_radio_checked)
+                    Internal_DrawButton(dc, borderRectangle, 1, cpcolor, is_ColorControl, button.BackColor);
+            }
+            else if (button.FlatStyle == FlatStyle.Flat)
+            {
+                if (button.is_entered && !button.is_pressed && !check_or_radio_checked)
+                {
+                    if ((button.image == null) && (button.image_list == null))
+                    {
+                        Brush brush = is_ColorControl ? SystemBrushes.ControlDark : ResPool.GetSolidBrush(cpcolor.Dark);
+                        dc.FillRectangle(brush, borderRectangle);
+                    }
+                }
+                else if (button.is_pressed || check_or_radio_checked)
+                {
+                    if ((button.image == null) && (button.image_list == null))
+                    {
+                        Brush brush = is_ColorControl ? SystemBrushes.ControlLightLight : ResPool.GetSolidBrush(cpcolor.LightLight);
+                        dc.FillRectangle(brush, borderRectangle);
+                    }
+
+                    Pen pen = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen(cpcolor.Dark);
+                    dc.DrawRectangle(pen, borderRectangle.X + 4, borderRectangle.Y + 4,
+                              borderRectangle.Width - 9, borderRectangle.Height - 9);
+                }
+
+                Internal_DrawButton(dc, borderRectangle, 3, cpcolor, is_ColorControl, button.BackColor);
+            }
+            else
+            {
+                if ((!button.is_pressed || !button.Enabled) && !check_or_radio_checked)
+                    Internal_DrawButton(dc, borderRectangle, 0, cpcolor, is_ColorControl, button.BackColor);
+                else
+                    Internal_DrawButton(dc, borderRectangle, 1, cpcolor, is_ColorControl, button.BackColor);
+            }
+        }
+
+        private void Internal_DrawButton(Graphics dc, Rectangle rect, int state, CPColor cpcolor, bool is_ColorControl, Color backcolor)
+        {
+            switch (state)
+            {
+                case 0: // normal or normal disabled button
+                    Pen pen = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen(cpcolor.LightLight);
+                    dc.DrawLine(pen, rect.X, rect.Y, rect.X, rect.Bottom - 2);
+                    dc.DrawLine(pen, rect.X + 1, rect.Y, rect.Right - 2, rect.Y);
+
+                    pen = is_ColorControl ? SystemPens.Control : ResPool.GetPen(backcolor);
+                    dc.DrawLine(pen, rect.X + 1, rect.Y + 1, rect.X + 1, rect.Bottom - 3);
+                    dc.DrawLine(pen, rect.X + 2, rect.Y + 1, rect.Right - 3, rect.Y + 1);
+
+                    pen = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen(cpcolor.Dark);
+                    dc.DrawLine(pen, rect.X + 1, rect.Bottom - 2, rect.Right - 2, rect.Bottom - 2);
+                    dc.DrawLine(pen, rect.Right - 2, rect.Y + 1, rect.Right - 2, rect.Bottom - 3);
+
+                    pen = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen(cpcolor.DarkDark);
+                    dc.DrawLine(pen, rect.X, rect.Bottom - 1, rect.Right - 1, rect.Bottom - 1);
+                    dc.DrawLine(pen, rect.Right - 1, rect.Y, rect.Right - 1, rect.Bottom - 2);
+                    break;
+                case 1: // popup button normal (or pressed normal or popup button)
+                    pen = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen(cpcolor.Dark);
+                    dc.DrawRectangle(pen, rect.X, rect.Y, rect.Width - 1, rect.Height - 1);
+                    break;
+                case 2: // popup button poped up
+                    pen = is_ColorControl ? SystemPens.ControlLightLight : ResPool.GetPen(cpcolor.LightLight);
+                    dc.DrawLine(pen, rect.X, rect.Y, rect.X, rect.Bottom - 2);
+                    dc.DrawLine(pen, rect.X + 1, rect.Y, rect.Right - 2, rect.Y);
+
+                    pen = is_ColorControl ? SystemPens.ControlDark : ResPool.GetPen(cpcolor.Dark);
+                    dc.DrawLine(pen, rect.X, rect.Bottom - 1, rect.Right - 1, rect.Bottom - 1);
+                    dc.DrawLine(pen, rect.Right - 1, rect.Y, rect.Right - 1, rect.Bottom - 2);
+                    break;
+                case 3: // flat button not entered
+                    pen = is_ColorControl ? SystemPens.ControlDarkDark : ResPool.GetPen(cpcolor.DarkDark);
+                    dc.DrawRectangle(pen, rect.X, rect.Y, rect.Width - 1, rect.Height - 1);
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        protected virtual void ButtonBase_DrawImage(ButtonBase button, Graphics dc)
+        {
+            // Need to draw a picture
+            Image i;
+            int image_x;
+            int image_y;
+            int image_width;
+            int image_height;
+
+            int width = button.ClientSize.Width;
+            int height = button.ClientSize.Height;
+
+            if (button.ImageIndex != -1)
+            {    // We use ImageIndex instead of image_index since it will return -1 if image_list is null
+                i = button.image_list.Images[button.ImageIndex];
+            }
+            else
+            {
+                i = button.image;
+            }
+
+            image_width = i.Width;
+            image_height = i.Height;
+
+            switch (button.ImageAlign)
+            {
+                case ContentAlignment.TopLeft:
+                    {
+                        image_x = 5;
+                        image_y = 5;
+                        break;
+                    }
+
+                case ContentAlignment.TopCenter:
+                    {
+                        image_x = (width - image_width) / 2;
+                        image_y = 5;
+                        break;
+                    }
+
+                case ContentAlignment.TopRight:
+                    {
+                        image_x = width - image_width - 5;
+                        image_y = 5;
+                        break;
+                    }
+
+                case ContentAlignment.MiddleLeft:
+                    {
+                        image_x = 5;
+                        image_y = (height - image_height) / 2;
+                        break;
+                    }
+
+                case ContentAlignment.MiddleCenter:
+                    {
+                        image_x = (width - image_width) / 2;
+                        image_y = (height - image_height) / 2;
+                        break;
+                    }
+
+                case ContentAlignment.MiddleRight:
+                    {
+                        image_x = width - image_width - 4;
+                        image_y = (height - image_height) / 2;
+                        break;
+                    }
+
+                case ContentAlignment.BottomLeft:
+                    {
+                        image_x = 5;
+                        image_y = height - image_height - 4;
+                        break;
+                    }
+
+                case ContentAlignment.BottomCenter:
+                    {
+                        image_x = (width - image_width) / 2;
+                        image_y = height - image_height - 4;
+                        break;
+                    }
+
+                case ContentAlignment.BottomRight:
+                    {
+                        image_x = width - image_width - 4;
+                        image_y = height - image_height - 4;
+                        break;
+                    }
+
+                default:
+                    {
+                        image_x = 5;
+                        image_y = 5;
+                        break;
+                    }
+            }
+
+            dc.SetClip(new Rectangle(3, 3, width - 5, height - 5));
+
+            if (button.Enabled)
+                dc.DrawImage(i, image_x, image_y, image_width, image_height);
+            else
+                CPDrawImageDisabled(dc, i, image_x, image_y, ColorControl);
+
+            dc.ResetClip();
+        }
+
+        protected virtual void ButtonBase_DrawFocus(ButtonBase button, Graphics dc)
+        {
+            Color focus_color = button.ForeColor;
+
+            int inflate_value = -3;
+
+            if (!(button is CheckBox) && !(button is RadioButton))
+            {
+                inflate_value = -4;
+
+                if (button.FlatStyle == FlatStyle.Popup && !button.is_pressed)
+                    focus_color = WidgetPaint.Dark(button.BackColor);
+
+                dc.DrawRectangle(ResPool.GetPen(focus_color), button.ClientRectangle.X, button.ClientRectangle.Y,
+                          button.ClientRectangle.Width - 1, button.ClientRectangle.Height - 1);
+            }
+
+            if (button.Focused)
+            {
+                Rectangle rect = Rectangle.Inflate(button.ClientRectangle, inflate_value, inflate_value);
+                WidgetPaint.DrawFocusRectangle(dc, rect);
+            }
+        }
+
+        protected virtual void ButtonBase_DrawText(ButtonBase button, Graphics dc)
+        {
+            Rectangle buttonRectangle = button.ClientRectangle;
+            Rectangle text_rect = Rectangle.Inflate(buttonRectangle, -4, -4);
+
+            if (button.is_pressed)
+            {
+                text_rect.X++;
+                text_rect.Y++;
+            }
+
+            // Ensure that at least one line is going to get displayed.
+            // Line limit does not ensure that despite its description.
+            text_rect.Height = Math.Max(button.Font.Height, text_rect.Height);
+
+            if (button.Enabled)
+            {
+                dc.DrawString(button.Text, button.Font, ResPool.GetSolidBrush(button.ForeColor), text_rect, button.text_format);
+            }
+            else
+            {
+                if (button.FlatStyle == FlatStyle.Flat || button.FlatStyle == FlatStyle.Popup)
+                {
+                    dc.DrawString(button.Text, button.Font, ResPool.GetSolidBrush(ColorGrayText), text_rect, button.text_format);
+                }
+                else
+                {
+                    CPDrawStringDisabled(dc, button.Text, button.Font, button.BackColor, text_rect, button.text_format);
+                }
+            }
+        }
+
+        public override Size ButtonBaseDefaultSize
+        {
+            get
+            {
+                return new Size(75, 23);
+            }
+        }
+        #endregion // ButtonBase
+
+        #region CheckBox
+        public override void DrawCheckBox(Graphics g, CheckBox cb, Rectangle glyphArea, Rectangle textBounds, Rectangle imageBounds, Rectangle clipRectangle)
+        {
+            // Draw Button Background
+            if (cb.Appearance == Appearance.Button && cb.FlatStyle != FlatStyle.Flat)
+                ButtonBase_DrawButton(cb, g);
+            else if (cb.Appearance != Appearance.Button)
+                DrawCheckBoxGlyph(g, cb, glyphArea);
+
+            // Draw the borders and such for a Flat CheckBox Button
+            if (cb.Appearance == Appearance.Button && cb.FlatStyle == FlatStyle.Flat)
+                DrawFlatButton(g, cb, textBounds, imageBounds, clipRectangle);
+
+            // If we have an image, draw it
+            if (imageBounds.Size != Size.Empty)
+                DrawCheckBoxImage(g, cb, imageBounds);
+
+            if (cb.Focused && cb.Enabled && cb.ShowFocusCues && textBounds != Rectangle.Empty)
+                DrawCheckBoxFocus(g, cb, textBounds);
+
+            // If we have text, draw it
+            if (textBounds != Rectangle.Empty)
+                DrawCheckBoxText(g, cb, textBounds);
+        }
+
+        public virtual void DrawCheckBoxGlyph(Graphics g, CheckBox cb, Rectangle glyphArea)
+        {
+            if (cb.Pressed)
+                MemphisThemeElements.CurrentTheme.CheckBoxPainter.PaintCheckBox(g, glyphArea, cb.BackColor, cb.ForeColor, ElementState.Pressed, cb.FlatStyle, cb.CheckState);
+            else if (cb.InternalSelected)
+                MemphisThemeElements.CurrentTheme.CheckBoxPainter.PaintCheckBox(g, glyphArea, cb.BackColor, cb.ForeColor, ElementState.Normal, cb.FlatStyle, cb.CheckState);
+            else if (cb.Entered)
+                MemphisThemeElements.CurrentTheme.CheckBoxPainter.PaintCheckBox(g, glyphArea, cb.BackColor, cb.ForeColor, ElementState.Hot, cb.FlatStyle, cb.CheckState);
+            else if (!cb.Enabled)
+                MemphisThemeElements.CurrentTheme.CheckBoxPainter.PaintCheckBox(g, glyphArea, cb.BackColor, cb.ForeColor, ElementState.Disabled, cb.FlatStyle, cb.CheckState);
+            else
+                MemphisThemeElements.CurrentTheme.CheckBoxPainter.PaintCheckBox(g, glyphArea, cb.BackColor, cb.ForeColor, ElementState.Normal, cb.FlatStyle, cb.CheckState);
+        }
+
+        public virtual void DrawCheckBoxFocus(Graphics g, CheckBox cb, Rectangle focusArea)
+        {
+            WidgetPaint.DrawFocusRectangle(g, focusArea);
+        }
+
+        public virtual void DrawCheckBoxImage(Graphics g, CheckBox cb, Rectangle imageBounds)
+        {
+            if (cb.Enabled)
+                g.DrawImage(cb.Image, imageBounds);
+            else
+                CPDrawImageDisabled(g, cb.Image, imageBounds.Left, imageBounds.Top, ColorControl);
+        }
+
+        public virtual void DrawCheckBoxText(Graphics g, CheckBox cb, Rectangle textBounds)
+        {
+            if (cb.Enabled)
+                TextRenderer.DrawTextInternal(g, cb.Text, cb.Font, textBounds, cb.ForeColor, cb.TextFormatFlags, cb.UseCompatibleTextRendering);
+            else
+                DrawStringDisabled20(g, cb.Text, cb.Font, textBounds, cb.BackColor, cb.TextFormatFlags, cb.UseCompatibleTextRendering);
+        }
+
+        public override void CalculateCheckBoxTextAndImageLayout(ButtonBase button, Point p, out Rectangle glyphArea, out Rectangle textRectangle, out Rectangle imageRectangle)
+        {
+            int check_size = CheckSize;
+
+            if (button is CheckBox)
+                check_size = (button as CheckBox).Appearance == Appearance.Normal ? check_size : 0;
+
+            glyphArea = new Rectangle(button.Padding.Left, button.Padding.Top, check_size, check_size);
+
+            Rectangle content_rect = button.PaddingClientRectangle;
+            ContentAlignment align = ContentAlignment.TopLeft;
+
+            if (button is CheckBox)
+                align = (button as CheckBox).CheckAlign;
+            else if (button is RadioButton)
+                align = (button as RadioButton).CheckAlign;
+
+            switch (align)
+            {
+                case ContentAlignment.BottomCenter:
+                    glyphArea.Y += content_rect.Height - check_size - 2;
+                    glyphArea.X += (content_rect.Width - check_size) / 2;
+                    break;
+                case ContentAlignment.BottomLeft:
+                    glyphArea.Y += content_rect.Height - check_size - 2;
+                    content_rect.Width -= check_size;
+                    content_rect.Offset(check_size, 0);
+                    break;
+                case ContentAlignment.BottomRight:
+                    glyphArea.Y += content_rect.Height - check_size - 2;
+                    glyphArea.X += content_rect.Width - check_size;
+                    content_rect.Width -= check_size;
+                    break;
+                case ContentAlignment.MiddleCenter:
+                    glyphArea.Y += (content_rect.Height - check_size) / 2;
+                    glyphArea.X += (content_rect.Width - check_size) / 2;
+                    break;
+                case ContentAlignment.MiddleLeft:
+                    glyphArea.Y += (content_rect.Height - check_size) / 2;
+                    content_rect.Width -= check_size;
+                    content_rect.Offset(check_size, 0);
+                    break;
+                case ContentAlignment.MiddleRight:
+                    glyphArea.Y += (content_rect.Height - check_size) / 2;
+                    glyphArea.X += content_rect.Width - check_size;
+                    content_rect.Width -= check_size;
+                    break;
+                case ContentAlignment.TopCenter:
+                    glyphArea.X += (content_rect.Width - check_size) / 2;
+                    break;
+                case ContentAlignment.TopLeft:
+                    content_rect.Width -= check_size;
+                    content_rect.Offset(check_size, 0);
+                    break;
+                case ContentAlignment.TopRight:
+                    glyphArea.X += content_rect.Width - check_size;
+                    content_rect.Width -= check_size;
+                    break;
+            }
+
+            Image image = button.Image;
+            string text = button.Text;
+
+            Size proposed = Size.Empty;
+
+            // Force wrapping if we aren't AutoSize and our text is too long
+            if (!button.AutoSize)
+                proposed.Width = button.PaddingClientRectangle.Width - glyphArea.Width - 2;
+
+            Size text_size = TextRenderer.MeasureTextInternal(text, button.Font, proposed, button.TextFormatFlags, button.UseCompatibleTextRendering);
+
+            // Text can't be bigger than the content rectangle
+            text_size.Height = Math.Min(text_size.Height, content_rect.Height);
+            text_size.Width = Math.Min(text_size.Width, content_rect.Width);
+
+            Size image_size = image == null ? Size.Empty : image.Size;
+
+            textRectangle = Rectangle.Empty;
+            imageRectangle = Rectangle.Empty;
+
+            switch (button.TextImageRelation)
+            {
+                case TextImageRelation.Overlay:
+                    // Text is centered vertically, and 2 pixels to the right
+                    textRectangle.X = content_rect.Left + 2;
+                    textRectangle.Y = button.PaddingClientRectangle.Top + ((content_rect.Height - text_size.Height) / 2) - 1;
+                    textRectangle.Size = text_size;
+
+                    // Image is dependent on ImageAlign
+                    if (image == null)
+                        return;
+
+                    int image_x = button.PaddingClientRectangle.Left;
+                    int image_y = button.PaddingClientRectangle.Top;
+                    int image_height = image.Height;
+                    int image_width = image.Width;
+
+                    switch (button.ImageAlign)
+                    {
+                        case System.Drawing.ContentAlignment.TopLeft:
+                            image_x += 5;
+                            image_y += 5;
+                            break;
+                        case System.Drawing.ContentAlignment.TopCenter:
+                            image_x += (content_rect.Width - image_width) / 2;
+                            image_y += 5;
+                            break;
+                        case System.Drawing.ContentAlignment.TopRight:
+                            image_x += content_rect.Width - image_width - 5;
+                            image_y += 5;
+                            break;
+                        case System.Drawing.ContentAlignment.MiddleLeft:
+                            image_x += 5;
+                            image_y += (content_rect.Height - image_height) / 2;
+                            break;
+                        case System.Drawing.ContentAlignment.MiddleCenter:
+                            image_x += (content_rect.Width - image_width) / 2;
+                            image_y += (content_rect.Height - image_height) / 2;
+                            break;
+                        case System.Drawing.ContentAlignment.MiddleRight:
+                            image_x += content_rect.Width - image_width - 4;
+                            image_y += (content_rect.Height - image_height) / 2;
+                            break;
+                        case System.Drawing.ContentAlignment.BottomLeft:
+                            image_x += 5;
+                            image_y += content_rect.Height - image_height - 4;
+                            break;
+                        case System.Drawing.ContentAlignment.BottomCenter:
+                            image_x += (content_rect.Width - image_width) / 2;
+                            image_y += content_rect.Height - image_height - 4;
+                            break;
+                        case System.Drawing.ContentAlignment.BottomRight:
+                            image_x += content_rect.Width - image_width - 4;
+                            image_y += content_rect.Height - image_height - 4;
+                            break;
+                        default:
+                            image_x += 5;
+                            image_y += 5;
+                            break;
+                    }
+
+                    imageRectangle = new Rectangle(image_x + check_size, image_y, image_width, image_height);
+                    break;
+                case TextImageRelation.ImageAboveText:
+                    content_rect.Inflate(-4, -4);
+                    LayoutTextAboveOrBelowImage(content_rect, false, text_size, image_size, button.TextAlign, button.ImageAlign, false, out textRectangle, out imageRectangle);
+                    break;
+                case TextImageRelation.TextAboveImage:
+                    content_rect.Inflate(-4, -4);
+                    LayoutTextAboveOrBelowImage(content_rect, true, text_size, image_size, button.TextAlign, button.ImageAlign, false, out textRectangle, out imageRectangle);
+                    break;
+                case TextImageRelation.ImageBeforeText:
+                    content_rect.Inflate(-4, -4);
+                    LayoutTextBeforeOrAfterImage(content_rect, false, text_size, image_size, button.TextAlign, button.ImageAlign, out textRectangle, out imageRectangle);
+                    break;
+                case TextImageRelation.TextBeforeImage:
+                    content_rect.Inflate(-4, -4);
+                    LayoutTextBeforeOrAfterImage(content_rect, true, text_size, image_size, button.TextAlign, button.ImageAlign, out textRectangle, out imageRectangle);
+                    break;
+            }
+        }
+
+        public override Size CalculateCheckBoxAutoSize(CheckBox checkBox)
+        {
+            Size ret_size = Size.Empty;
+            Size text_size = TextRenderer.MeasureTextInternal(checkBox.Text, checkBox.Font, checkBox.UseCompatibleTextRendering);
+            Size image_size = checkBox.Image == null ? Size.Empty : checkBox.Image.Size;
+
+            // Pad the text size
+            if (checkBox.Text.Length != 0)
+            {
+                text_size.Height += 4;
+                text_size.Width += 4;
+            }
+
+            switch (checkBox.TextImageRelation)
+            {
+                case TextImageRelation.Overlay:
+                    ret_size.Height = Math.Max(checkBox.Text.Length == 0 ? 0 : text_size.Height, image_size.Height);
+                    ret_size.Width = Math.Max(text_size.Width, image_size.Width);
+                    break;
+                case TextImageRelation.ImageAboveText:
+                case TextImageRelation.TextAboveImage:
+                    ret_size.Height = text_size.Height + image_size.Height;
+                    ret_size.Width = Math.Max(text_size.Width, image_size.Width);
+                    break;
+                case TextImageRelation.ImageBeforeText:
+                case TextImageRelation.TextBeforeImage:
+                    ret_size.Height = Math.Max(text_size.Height, image_size.Height);
+                    ret_size.Width = text_size.Width + image_size.Width;
+                    break;
+            }
+
+            // Pad the result
+            ret_size.Height += (checkBox.Padding.Vertical);
+            ret_size.Width += (checkBox.Padding.Horizontal) + 15;
+
+            // There seems to be a minimum height
+            if (ret_size.Height == checkBox.Padding.Vertical)
+                ret_size.Height += 14;
+
+            return ret_size;
+        }
+
+        public override void DrawCheckBox(Graphics dc, Rectangle clip_area, CheckBox checkbox)
+        {
+            StringFormat text_format;
+            Rectangle client_rectangle;
+            Rectangle text_rectangle;
+            Rectangle checkbox_rectangle;
+            int checkmark_size = CheckSize;
+            int checkmark_space = 4;
+
+            client_rectangle = checkbox.ClientRectangle;
+            text_rectangle = client_rectangle;
+            checkbox_rectangle = new Rectangle(text_rectangle.X, text_rectangle.Y, checkmark_size, checkmark_size);
+
+            text_format = new StringFormat();
+            text_format.Alignment = StringAlignment.Near;
+            text_format.LineAlignment = StringAlignment.Center;
+            if (checkbox.ShowKeyboardCuesInternal)
+                text_format.HotkeyPrefix = HotkeyPrefix.Show;
+            else
+                text_format.HotkeyPrefix = HotkeyPrefix.Hide;
+
+            /* Calculate the position of text and checkbox rectangle */
+            if (checkbox.appearance != Appearance.Button)
+            {
+                switch (checkbox.check_alignment)
+                {
+                    case ContentAlignment.BottomCenter:
+                        {
+                            checkbox_rectangle.X = (client_rectangle.Right - client_rectangle.Left) / 2 - checkmark_size / 2;
+                            checkbox_rectangle.Y = client_rectangle.Bottom - checkmark_size;
+                            text_rectangle.X = client_rectangle.X;
+                            text_rectangle.Width = client_rectangle.Width;
+                            text_rectangle.Height = client_rectangle.Height - checkbox_rectangle.Y - checkmark_space;
+                            break;
+                        }
+
+                    case ContentAlignment.BottomLeft:
+                        {
+                            checkbox_rectangle.X = client_rectangle.Left;
+                            checkbox_rectangle.Y = client_rectangle.Bottom - checkmark_size;
+                            text_rectangle.X = client_rectangle.X + checkmark_size + checkmark_space;
+                            text_rectangle.Width = client_rectangle.Width - checkmark_size - checkmark_space;
+                            break;
+                        }
+
+                    case ContentAlignment.BottomRight:
+                        {
+                            checkbox_rectangle.X = client_rectangle.Right - checkmark_size;
+                            checkbox_rectangle.Y = client_rectangle.Bottom - checkmark_size;
+                            text_rectangle.X = client_rectangle.X;
+                            text_rectangle.Width = client_rectangle.Width - checkmark_size - checkmark_space;
+                            break;
+                        }
+
+                    case ContentAlignment.MiddleCenter:
+                        {
+                            checkbox_rectangle.X = (client_rectangle.Right - client_rectangle.Left) / 2 - checkmark_size / 2;
+                            checkbox_rectangle.Y = (client_rectangle.Bottom - client_rectangle.Top) / 2 - checkmark_size / 2;
+                            text_rectangle.X = client_rectangle.X;
+                            text_rectangle.Width = client_rectangle.Width;
+                            break;
+                        }
+
+                    default:
+                    case ContentAlignment.MiddleLeft:
+                        {
+                            checkbox_rectangle.X = client_rectangle.Left;
+                            checkbox_rectangle.Y = (client_rectangle.Bottom - client_rectangle.Top) / 2 - checkmark_size / 2;
+                            text_rectangle.X = client_rectangle.X + checkmark_size + checkmark_space;
+                            text_rectangle.Width = client_rectangle.Width - checkmark_size - checkmark_space;
+                            break;
+                        }
+
+                    case ContentAlignment.MiddleRight:
+                        {
+                            checkbox_rectangle.X = client_rectangle.Right - checkmark_size;
+                            checkbox_rectangle.Y = (client_rectangle.Bottom - client_rectangle.Top) / 2 - checkmark_size / 2;
+                            text_rectangle.X = client_rectangle.X;
+                            text_rectangle.Width = client_rectangle.Width - checkmark_size - checkmark_space;
+                            break;
+                        }
+
+                    case ContentAlignment.TopCenter:
+                        {
+                            checkbox_rectangle.X = (client_rectangle.Right - client_rectangle.Left) / 2 - checkmark_size / 2;
+                            checkbox_rectangle.Y = client_rectangle.Top;
+                            text_rectangle.X = client_rectangle.X;
+                            text_rectangle.Width = client_rectangle.Width;
+                            text_rectangle.Y = checkmark_size + checkmark_space;
+                            text_rectangle.Height = client_rectangle.Height - checkmark_size - checkmark_space;
+                            break;
+                        }
+
+                    case ContentAlignment.TopLeft:
+                        {
+                            checkbox_rectangle.X = client_rectangle.Left;
+                            text_rectangle.X = client_rectangle.X + checkmark_size + checkmark_space;
+                            text_rectangle.Width = client_rectangle.Width - checkmark_size - checkmark_space;
+                            break;
+                        }
+
+                    case ContentAlignment.TopRight:
+                        {
+                            checkbox_rectangle.X = client_rectangle.Right - checkmark_size;
+                            text_rectangle.X = client_rectangle.X;
+                            text_rectangle.Width = client_rectangle.Width - checkmark_size - checkmark_space;
+                            break;
+                        }
+                }
+            }
+            else
+            {
+                text_rectangle.X = client_rectangle.X;
+                text_rectangle.Width = client_rectangle.Width;
+            }
+
+            /* Set the horizontal alignment of our text */
+            switch (checkbox.text_alignment)
+            {
+                case ContentAlignment.BottomLeft:
+                case ContentAlignment.MiddleLeft:
+                case ContentAlignment.TopLeft:
+                    {
+                        text_format.Alignment = StringAlignment.Near;
+                        break;
+                    }
+
+                case ContentAlignment.BottomCenter:
+                case ContentAlignment.MiddleCenter:
+                case ContentAlignment.TopCenter:
+                    {
+                        text_format.Alignment = StringAlignment.Center;
+                        break;
+                    }
+
+                case ContentAlignment.BottomRight:
+                case ContentAlignment.MiddleRight:
+                case ContentAlignment.TopRight:
+                    {
+                        text_format.Alignment = StringAlignment.Far;
+                        break;
+                    }
+            }
+
+            /* Set the vertical alignment of our text */
+            switch (checkbox.text_alignment)
+            {
+                case ContentAlignment.TopLeft:
+                case ContentAlignment.TopCenter:
+                case ContentAlignment.TopRight:
+                    {
+                        text_format.LineAlignment = StringAlignment.Near;
+                        break;
+                    }
+
+                case ContentAlignment.BottomLeft:
+                case ContentAlignment.BottomCenter:
+                case ContentAlignment.BottomRight:
+                    {
+                        text_format.LineAlignment = StringAlignment.Far;
+                        break;
+                    }
+
+                case ContentAlignment.MiddleLeft:
+                case ContentAlignment.MiddleCenter:
+                case ContentAlignment.MiddleRight:
+                    {
+                        text_format.LineAlignment = StringAlignment.Center;
+                        break;
+                    }
+            }
+
+            ButtonState state = ButtonState.Normal;
+            if (checkbox.FlatStyle == FlatStyle.Flat)
+            {
+                state |= ButtonState.Flat;
+            }
+
+            if (checkbox.Checked)
+            {
+                state |= ButtonState.Checked;
+            }
+
+            if (checkbox.ThreeState && (checkbox.CheckState == CheckState.Indeterminate))
+            {
+                state |= ButtonState.Checked;
+                state |= ButtonState.Pushed;
+            }
+
+            // finally make sure the pushed and inavtive states are rendered
+            if (!checkbox.Enabled)
+            {
+                state |= ButtonState.Inactive;
+            }
+            else if (checkbox.is_pressed)
+            {
+                state |= ButtonState.Pushed;
+            }
+
+            // Start drawing
+
+            CheckBox_DrawCheckBox(dc, checkbox, state, checkbox_rectangle);
+
+            if ((checkbox.image != null) || (checkbox.image_list != null))
+                ButtonBase_DrawImage(checkbox, dc);
+
+            CheckBox_DrawText(checkbox, text_rectangle, dc, text_format);
+
+            if (checkbox.Focused && checkbox.Enabled && checkbox.appearance != Appearance.Button && checkbox.Text != String.Empty && checkbox.ShowFocusCues)
+            {
+                SizeF text_size = dc.MeasureString(checkbox.Text, checkbox.Font);
+
+                Rectangle focus_rect = Rectangle.Empty;
+                focus_rect.X = text_rectangle.X;
+                focus_rect.Y = (int)((text_rectangle.Height - text_size.Height) / 2);
+                focus_rect.Size = text_size.ToSize();
+                CheckBox_DrawFocus(checkbox, dc, focus_rect);
+            }
+
+            text_format.Dispose();
+        }
+
+        protected virtual void CheckBox_DrawCheckBox(Graphics dc, CheckBox checkbox, ButtonState state, Rectangle checkbox_rectangle)
+        {
+            Brush brush = checkbox.BackColor.ToArgb() == ColorControl.ToArgb() ? SystemBrushes.Control : ResPool.GetSolidBrush(checkbox.BackColor);
+            dc.FillRectangle(brush, checkbox.ClientRectangle);
+            // render as per normal button
+            if (checkbox.appearance == Appearance.Button)
+            {
+                ButtonBase_DrawButton(checkbox, dc);
+
+                if ((checkbox.Focused) && checkbox.Enabled)
+                    ButtonBase_DrawFocus(checkbox, dc);
+            }
+            else
+            {
+                // establish if we are rendering a flat style of some sort
+                if (checkbox.FlatStyle == FlatStyle.Flat || checkbox.FlatStyle == FlatStyle.Popup)
+                {
+                    DrawFlatStyleCheckBox(dc, checkbox_rectangle, checkbox);
+                }
+                else
+                {
+                    CPDrawCheckBox(dc, checkbox_rectangle, state);
+                }
+            }
+        }
+
+        protected virtual void CheckBox_DrawText(CheckBox checkbox, Rectangle text_rectangle, Graphics dc, StringFormat text_format)
+        {
+            DrawCheckBox_and_RadioButtonText(checkbox, text_rectangle, dc,
+                              text_format, checkbox.Appearance, checkbox.Checked);
+        }
+
+        protected virtual void CheckBox_DrawFocus(CheckBox checkbox, Graphics dc, Rectangle text_rectangle)
+        {
+            DrawInnerFocusRectangle(dc, text_rectangle, checkbox.BackColor);
+        }
+
+        // renders a checkBox with the Flat and Popup FlatStyle
+        protected virtual void DrawFlatStyleCheckBox(Graphics graphics, Rectangle rectangle, CheckBox checkbox)
+        {
+            Pen pen;
+            Rectangle rect;
+            Rectangle checkbox_rectangle;
+            Rectangle fill_rectangle;
+            int lineWidth;
+            int Scale;
+
+            // set up our rectangles first
+            if (checkbox.FlatStyle == FlatStyle.Popup && checkbox.is_entered)
+            {
+                // clip one pixel from bottom right for non popup rendered checkboxes
+                checkbox_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max(rectangle.Width - 1, 0), Math.Max(rectangle.Height - 1, 0));
+                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));
+            }
+            else
+            {
+                // clip two pixels from bottom right for non popup rendered checkboxes
+                checkbox_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max(rectangle.Width - 2, 0), Math.Max(rectangle.Height - 2, 0));
+                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));
+            }
+
+
+            // if disabled render in disabled state
+            if (checkbox.Enabled)
+            {
+                // process the state of the checkbox
+                if (checkbox.is_entered || checkbox.Capture)
+                {
+                    // decide on which background color to use
+                    if (checkbox.FlatStyle == FlatStyle.Popup && checkbox.is_entered && checkbox.Capture)
+                    {
+                        graphics.FillRectangle(ResPool.GetSolidBrush(checkbox.BackColor), fill_rectangle);
+                    }
+                    else if (checkbox.FlatStyle == FlatStyle.Flat)
+                    {
+                        if (!checkbox.is_pressed)
+                        {
+                            graphics.FillRectangle(ResPool.GetSolidBrush(checkbox.BackColor), fill_rectangle);
+                        }
+                        else
+                            graphics.FillRectangle(ResPool.GetSolidBrush(WidgetPaint.LightLight(checkbox.BackColor)), fill_rectangle);
+                    }
+                    else
+                    {
+                        // use regular window background color
+                        graphics.FillRectangle(ResPool.GetSolidBrush(WidgetPaint.LightLight(checkbox.BackColor)), fill_rectangle);
+                    }
+
+                    // render the outer border
+                    if (checkbox.FlatStyle == FlatStyle.Flat)
+                    {
+                        WidgetPaint.DrawBorder(graphics, checkbox_rectangle, checkbox.ForeColor, ButtonBorderStyle.Solid);
+                    }
+                    else
+                    {
+                        // draw sunken effect
+                        CPDrawBorder3D(graphics, checkbox_rectangle, Border3DStyle.SunkenInner, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, checkbox.BackColor);
+                    }
+                }
+                else
+                {
+                    graphics.FillRectangle(ResPool.GetSolidBrush(WidgetPaint.LightLight(checkbox.BackColor)), fill_rectangle);
+
+                    if (checkbox.FlatStyle == FlatStyle.Flat)
+                    {
+                        WidgetPaint.DrawBorder(graphics, checkbox_rectangle, checkbox.ForeColor, ButtonBorderStyle.Solid);
+                    }
+                    else
+                    {
+                        // draw the outer border
+                        WidgetPaint.DrawBorder(graphics, checkbox_rectangle, WidgetPaint.DarkDark(checkbox.BackColor), ButtonBorderStyle.Solid);
+                    }
+                }
+            }
+            else
+            {
+                if (checkbox.FlatStyle == FlatStyle.Popup)
+                {
+                    graphics.FillRectangle(SystemBrushes.Control, fill_rectangle);
+                }
+
+                // draw disabled state,
+                WidgetPaint.DrawBorder(graphics, checkbox_rectangle, ColorControlDark, ButtonBorderStyle.Solid);
+            }
+
+            if (checkbox.Checked)
+            {
+                /* Need to draw a check-mark */
+
+                /* Make sure we've got at least a line width of 1 */
+                lineWidth = Math.Max(3, fill_rectangle.Width / 3);
+                Scale = Math.Max(1, fill_rectangle.Width / 9);
+
+                // flat style check box is rendered inside a rectangle shifted down by one
+                rect = new Rectangle(fill_rectangle.X, fill_rectangle.Y + 1, fill_rectangle.Width, fill_rectangle.Height);
+                if (checkbox.Enabled)
+                {
+                    pen = ResPool.GetPen(checkbox.ForeColor);
+                }
+                else
+                {
+                    pen = SystemPens.ControlDark;
+                }
+
+                for (int i = 0; i < lineWidth; i++)
+                {
+                    graphics.DrawLine(pen, rect.Left + lineWidth / 2, rect.Top + lineWidth + i, rect.Left + lineWidth / 2 + 2 * Scale, rect.Top + lineWidth + 2 * Scale + i);
+                    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);
+                }
+            }
+        }
+
+        private void DrawCheckBox_and_RadioButtonText(ButtonBase button_base, Rectangle text_rectangle, Graphics dc,
+                                   StringFormat text_format, Appearance appearance, bool ischecked)
+        {
+            // offset the text if it's pressed and a button
+            if (appearance == Appearance.Button)
+            {
+                if (ischecked || (button_base.Capture && button_base.FlatStyle != FlatStyle.Flat))
+                {
+                    text_rectangle.X++;
+                    text_rectangle.Y++;
+                }
+
+                text_rectangle.Inflate(-4, -4);
+            }
+
+            /* Place the text; to be compatible with Windows place it after the checkbox has been drawn */
+
+            // Windows seems to not wrap text in certain situations, this matches as close as I could get it
+            if ((float)(button_base.Font.Height * 1.5f) > text_rectangle.Height)
+            {
+                text_format.FormatFlags |= StringFormatFlags.NoWrap;
+            }
+            if (button_base.Enabled)
+            {
+                dc.DrawString(button_base.Text, button_base.Font, ResPool.GetSolidBrush(button_base.ForeColor), text_rectangle, text_format);
+            }
+            else if (button_base.FlatStyle == FlatStyle.Flat || button_base.FlatStyle == FlatStyle.Popup)
+            {
+                dc.DrawString(button_base.Text, button_base.Font, SystemBrushes.ControlDarkDark, text_rectangle, text_format);
+            }
+            else
+            {
+                CPDrawStringDisabled(dc, button_base.Text, button_base.Font, button_base.BackColor, text_rectangle, text_format);
+            }
+        }
+        #endregion // CheckBox
+
+        #region CheckedListBox
+
+        public override void DrawCheckedListBoxItem(CheckedListBox ctrl, DrawItemEventArgs e)
+        {
+            Color back_color, fore_color;
+            Rectangle item_rect = e.Bounds;
+            ButtonState state;
+
+            /* Draw checkbox */
+
+            if ((e.State & DrawItemState.Checked) == DrawItemState.Checked)
+            {
+                state = ButtonState.Checked;
+                if ((e.State & DrawItemState.Inactive) == DrawItemState.Inactive)
+                    state |= ButtonState.Inactive;
+            }
+            else
+                state = ButtonState.Normal;
+
+            if (ctrl.ThreeDCheckBoxes == false)
+                state |= ButtonState.Flat;
+
+            Rectangle checkbox_rect = new Rectangle(2, (item_rect.Height - 11) / 2, CheckSize, CheckSize);
+            WidgetPaint.DrawCheckBox(e.Graphics,
+                item_rect.X + checkbox_rect.X, item_rect.Y + checkbox_rect.Y,
+                checkbox_rect.Width, checkbox_rect.Height,
+                state);
+
+            item_rect.X += checkbox_rect.Right;
+            item_rect.Width -= checkbox_rect.Right;
+
+            /* Draw text*/
+            if ((e.State & DrawItemState.Selected) == DrawItemState.Selected)
+            {
+                back_color = ColorHighlight;
+                fore_color = ColorHighlightText;
+            }
+            else
+            {
+                back_color = e.BackColor;
+                fore_color = e.ForeColor;
+            }
+
+            e.Graphics.FillRectangle(ResPool.GetSolidBrush
+                (back_color), item_rect);
+
+            e.Graphics.DrawString(ctrl.GetItemText(ctrl.Items[e.Index]), e.Font,
+                ResPool.GetSolidBrush(fore_color),
+                item_rect, ctrl.StringFormat);
+
+            if ((e.State & DrawItemState.Focus) == DrawItemState.Focus)
+            {
+                CPDrawFocusRectangle(e.Graphics, item_rect,
+                    fore_color, back_color);
+            }
+        }
+
+        #endregion // CheckedListBox
+
+        #region ComboBox		
+        public override void DrawComboBoxItem(ComboBox ctrl, DrawItemEventArgs e)
+        {
+            Color back_color, fore_color;
+            Rectangle text_draw = e.Bounds;
+            StringFormat string_format = new StringFormat();
+            string_format.FormatFlags = StringFormatFlags.LineLimit;
+
+            if ((e.State & DrawItemState.Selected) == DrawItemState.Selected)
+            {
+                back_color = ColorHighlight;
+                fore_color = ColorHighlightText;
+            }
+            else
+            {
+                back_color = e.BackColor;
+                fore_color = e.ForeColor;
+            }
+
+            if (!ctrl.Enabled)
+                fore_color = ColorInactiveCaptionText;
+
+            e.Graphics.FillRectangle(ResPool.GetSolidBrush(back_color), e.Bounds);
+
+            if (e.Index != -1)
+            {
+                e.Graphics.DrawString(ctrl.GetItemText(ctrl.Items[e.Index]), e.Font,
+                    ResPool.GetSolidBrush(fore_color),
+                    text_draw, string_format);
+            }
+
+            if ((e.State & DrawItemState.Focus) == DrawItemState.Focus)
+            {
+                CPDrawFocusRectangle(e.Graphics, e.Bounds, fore_color, back_color);
+            }
+
+            string_format.Dispose();
+        }
+
+        public override void DrawFlatStyleComboButton(Graphics graphics, Rectangle rectangle, ButtonState state)
+        {
+            Point[] arrow = new Point[3];
+            Point P1;
+            Point P2;
+            Point P3;
+            int centerX;
+            int centerY;
+            int shiftX;
+            int shiftY;
+            Rectangle rect;
+
+            rect = new Rectangle(rectangle.X + rectangle.Width / 4, rectangle.Y + rectangle.Height / 4, rectangle.Width / 2, rectangle.Height / 2);
+            centerX = rect.Left + rect.Width / 2;
+            centerY = rect.Top + rect.Height / 2;
+            shiftX = Math.Max(1, rect.Width / 8);
+            shiftY = Math.Max(1, rect.Height / 8);
+
+            if ((state & ButtonState.Pushed) != 0)
+            {
+                shiftX++;
+                shiftY++;
+            }
+
+            rect.Y -= shiftY;
+            centerY -= shiftY;
+            P1 = new Point(rect.Left + 1, centerY);
+            P2 = new Point(rect.Right - 1, centerY);
+            P3 = new Point(centerX, rect.Bottom - 1);
+
+            arrow[0] = P1;
+            arrow[1] = P2;
+            arrow[2] = P3;
+
+            /* Draw the arrow */
+            if ((state & ButtonState.Inactive) != 0)
+            {
+                /* Move away from the shadow */
+                arrow[0].X += 1; arrow[0].Y += 1;
+                arrow[1].X += 1; arrow[1].Y += 1;
+                arrow[2].X += 1; arrow[2].Y += 1;
+
+                graphics.FillPolygon(SystemBrushes.ControlLightLight, arrow, FillMode.Winding);
+
+                arrow[0] = P1;
+                arrow[1] = P2;
+                arrow[2] = P3;
+
+                graphics.FillPolygon(SystemBrushes.ControlDark, arrow, FillMode.Winding);
+            }
+            else
+            {
+                graphics.FillPolygon(SystemBrushes.ControlText, arrow, FillMode.Winding);
+            }
+        }
+        public override void ComboBoxDrawNormalDropDownButton(ComboBox comboBox, Graphics g, Rectangle clippingArea, Rectangle area, ButtonState state)
+        {
+            CPDrawComboButton(g, area, state);
+        }
+        public override bool ComboBoxNormalDropDownButtonHasTransparentBackground(ComboBox comboBox, ButtonState state)
+        {
+            return true;
+        }
+        public override bool ComboBoxDropDownButtonHasHotElementStyle(ComboBox comboBox)
+        {
+            return false;
+        }
+        public override void ComboBoxDrawBackground(ComboBox comboBox, Graphics g, Rectangle clippingArea, FlatStyle style)
+        {
+            if (!comboBox.Enabled)
+                g.FillRectangle(ResPool.GetSolidBrush(ColorControl), comboBox.ClientRectangle);
+
+            if (comboBox.DropDownStyle == ComboBoxStyle.Simple)
+                g.FillRectangle(ResPool.GetSolidBrush(comboBox.Parent.BackColor), comboBox.ClientRectangle);
+
+            if (style == FlatStyle.Popup && (comboBox.Entered || comboBox.Focused))
+            {
+                Rectangle area = comboBox.TextArea;
+                area.Height -= 1;
+                area.Width -= 1;
+                g.DrawRectangle(ResPool.GetPen(SystemColors.ControlDark), area);
+                g.DrawLine(ResPool.GetPen(SystemColors.ControlDark), comboBox.ButtonArea.X - 1, comboBox.ButtonArea.Top, comboBox.ButtonArea.X - 1, comboBox.ButtonArea.Bottom);
+            }
+            bool is_flat = style == FlatStyle.Flat || style == FlatStyle.Popup;
+            if (!is_flat && clippingArea.IntersectsWith(comboBox.TextArea))
+                WidgetPaint.DrawBorder3D(g, comboBox.TextArea, Border3DStyle.Sunken);
+        }
+        public override bool CombBoxBackgroundHasHotElementStyle(ComboBox comboBox)
+        {
+            return false;
+        }
+        #endregion ComboBox
+
+        /* FIXME: NEIN. I will NOT port DataGrids over.
+		#region Datagrid
+		public override int DataGridPreferredColumnWidth { get { return 75;} }
+		public override int DataGridMinimumColumnCheckBoxHeight { get { return 16;} }
+		public override int DataGridMinimumColumnCheckBoxWidth { get { return 16;} }
+		public override Color DataGridAlternatingBackColor { get { return ColorWindow;} }
+		public override Color DataGridBackColor { get  { return  ColorWindow;} }		
+		public override Color DataGridBackgroundColor { get  { return  ColorAppWorkspace;} }
+		public override Color DataGridCaptionBackColor { get  { return ColorActiveCaption;} }
+		public override Color DataGridCaptionForeColor { get  { return ColorActiveCaptionText;} }
+		public override Color DataGridGridLineColor { get { return ColorControl;} }
+		public override Color DataGridHeaderBackColor { get  { return ColorControl;} }
+		public override Color DataGridHeaderForeColor { get  { return ColorControlText;} }
+		public override Color DataGridLinkColor { get  { return ColorHotTrack;} }
+		public override Color DataGridLinkHoverColor { get  { return ColorHotTrack;} }
+		public override Color DataGridParentRowsBackColor { get  { return ColorControl;} }
+		public override Color DataGridParentRowsForeColor { get  { return ColorWindowText;} }
+		public override Color DataGridSelectionBackColor { get  { return ColorActiveCaption;} }
+		public override Color DataGridSelectionForeColor { get  { return ColorActiveCaptionText;} }
+		
+		public override void DataGridPaint (PaintEventArgs pe, DataGrid grid)
+		{
+			DataGridPaintCaption (pe.Graphics, pe.ClipRectangle, grid);
+			DataGridPaintParentRows (pe.Graphics, pe.ClipRectangle, grid);
+			DataGridPaintColumnHeaders (pe.Graphics, pe.ClipRectangle, grid);
+			DataGridPaintRows (pe.Graphics, grid.cells_area, pe.ClipRectangle, grid);
+
+			// Paint scrollBar corner
+			if (grid.VScrollBar.Visible && grid.HScrollBar.Visible) {
+
+				Rectangle corner = new Rectangle (grid.ClientRectangle.X + grid.ClientRectangle.Width - grid.VScrollBar.Width,
+								  grid.ClientRectangle.Y + grid.ClientRectangle.Height - grid.HScrollBar.Height,
+								  grid.VScrollBar.Width, grid.HScrollBar.Height);
+
+				if (pe.ClipRectangle.IntersectsWith (corner)) {
+					pe.Graphics.FillRectangle (ResPool.GetSolidBrush (grid.ParentRowsBackColor),
+								   corner);
+				}
+			}
+		}
+
+		public override void DataGridPaintCaption (Graphics g, Rectangle clip, DataGrid grid)
+		{
+			Rectangle bounds = clip;
+			bounds.Intersect (grid.caption_area);
+
+			// Background
+			g.FillRectangle (ResPool.GetSolidBrush (grid.CaptionBackColor), bounds);
+
+			// Bottom line
+    		g.DrawLine (ResPool.GetPen (grid.CurrentTableStyle.CurrentHeaderForeColor),
+					bounds.X, bounds.Y + bounds.Height -1, 
+                    bounds.X + bounds.Width, bounds.Y + bounds.Height -1);
+
+			// Caption text
+			if (grid.CaptionText != String.Empty) {
+				Rectangle text_rect = grid.caption_area;
+				text_rect.Y += text_rect.Height / 2 - grid.CaptionFont.Height / 2;
+				text_rect.Height = grid.CaptionFont.Height;
+
+				g.DrawString (grid.CaptionText, grid.CaptionFont,
+					      ResPool.GetSolidBrush (grid.CaptionForeColor),
+					      text_rect);
+			}
+
+			// Back button
+			if (bounds.IntersectsWith (grid.back_button_rect)) {
+				g.DrawImage (grid.back_button_image, grid.back_button_rect);
+				if (grid.back_button_mouseover) {
+					CPDrawBorder3D (g, grid.back_button_rect, grid.back_button_active ? Border3DStyle.Sunken : Border3DStyle.Raised, all_sides);
+				}
+			}
+
+			// Rows button
+			if (bounds.IntersectsWith (grid.parent_rows_button_rect)) {
+				g.DrawImage (grid.parent_rows_button_image, grid.parent_rows_button_rect);
+				if (grid.parent_rows_button_mouseover) {
+					CPDrawBorder3D (g, grid.parent_rows_button_rect, grid.parent_rows_button_active ? Border3DStyle.Sunken : Border3DStyle.Raised, all_sides);
+				}
+			}
+		}
+
+		public override void DataGridPaintColumnHeaders (Graphics g, Rectangle clip, DataGrid grid)
+		{
+			if (!grid.CurrentTableStyle.ColumnHeadersVisible)
+				return;
+
+			Rectangle columns_area = grid.column_headers_area;
+
+			// Paint corner shared between row and column header
+			if (grid.CurrentTableStyle.CurrentRowHeadersVisible) {
+				Rectangle rect_bloc = grid.column_headers_area;
+				rect_bloc.Width = grid.RowHeaderWidth;
+				if (clip.IntersectsWith (rect_bloc)) {
+					if (grid.FlatMode)
+						g.FillRectangle (ResPool.GetSolidBrush (grid.CurrentTableStyle.CurrentHeaderBackColor), rect_bloc);
+					else
+						CPDrawBorder3D (g, rect_bloc, Border3DStyle.RaisedInner, 
+							Border3DSide.Left | Border3DSide.Right | 
+							Border3DSide.Top | Border3DSide.Bottom | Border3DSide.Middle, 
+							grid.CurrentTableStyle.CurrentHeaderBackColor);
+				}
+
+				columns_area.X += grid.RowHeaderWidth;
+				columns_area.Width -= grid.RowHeaderWidth;
+			}
+
+			// Set column painting
+			Rectangle rect_columnhdr = new Rectangle ();
+			int col_pixel;
+			Region current_clip;
+			Region prev_clip = g.Clip;
+			rect_columnhdr.Y = columns_area.Y;
+			rect_columnhdr.Height = columns_area.Height;
+
+			int column_cnt = grid.FirstVisibleColumn + grid.VisibleColumnCount;
+			for (int column = grid.FirstVisibleColumn; column < column_cnt; column++) {
+				if (grid.CurrentTableStyle.GridColumnStyles[column].bound == false)
+					continue;
+				
+				col_pixel = grid.GetColumnStartingPixel (column);
+				rect_columnhdr.X = columns_area.X + col_pixel - grid.HorizPixelOffset;
+				rect_columnhdr.Width = grid.CurrentTableStyle.GridColumnStyles[column].Width;
+
+				if (clip.IntersectsWith (rect_columnhdr) == false)
+					continue;
+
+				current_clip = new Region (rect_columnhdr);
+				current_clip.Intersect (columns_area);
+				current_clip.Intersect (prev_clip);
+				g.Clip = current_clip;
+
+				DataGridPaintColumnHeader (g, rect_columnhdr, grid, column);
+
+				current_clip.Dispose ();
+			}
+
+			g.Clip = prev_clip;
+				
+			Rectangle not_usedarea = grid.column_headers_area;
+			not_usedarea.X = (column_cnt == 0) ? grid.RowHeaderWidth : rect_columnhdr.X + rect_columnhdr.Width;
+			not_usedarea.Width = grid.ClientRectangle.X + grid.ClientRectangle.Width - not_usedarea.X;
+			g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor), not_usedarea);
+		}
+
+		public override void DataGridPaintColumnHeader (Graphics g, Rectangle bounds, DataGrid grid, int col)
+		{
+			// Background
+			g.FillRectangle (ResPool.GetSolidBrush (grid.CurrentTableStyle.HeaderBackColor), bounds);
+
+			// Paint Borders
+			if (!grid.FlatMode) {
+				g.DrawLine (ResPool.GetPen (ColorControlLightLight),
+					bounds.X, bounds.Y, bounds.X + bounds.Width, bounds.Y);
+				
+				if (col == 0) {
+					g.DrawLine (ResPool.GetPen (ColorControlLightLight),
+						bounds.X, bounds.Y, bounds.X, bounds.Y + bounds.Height);
+				} else {
+					g.DrawLine (ResPool.GetPen (ColorControlLightLight),
+						bounds.X, bounds.Y + 2, bounds.X, bounds.Y + bounds.Height - 3);
+				}
+				
+				if (col == (grid.VisibleColumnCount -1)) {
+					g.DrawLine (ResPool.GetPen (ColorControlDark),
+						bounds.X + bounds.Width - 1, bounds.Y, 
+						bounds.X + bounds.Width - 1, bounds.Y + bounds.Height);
+				} else {
+					g.DrawLine (ResPool.GetPen (ColorControlDark),
+						bounds.X + bounds.Width - 1, bounds.Y + 2, 
+						bounds.X + bounds.Width - 1, bounds.Y + bounds.Height - 3);
+				}
+
+				g.DrawLine (ResPool.GetPen (ColorControlDark),
+					bounds.X, bounds.Y + bounds.Height - 1, 
+					bounds.X + bounds.Width, bounds.Y + bounds.Height - 1);
+			}
+
+			bounds.X += 2;
+			bounds.Width -= 2;
+
+			DataGridColumnStyle style = grid.CurrentTableStyle.GridColumnStyles[col];
+
+			if (style.ArrowDrawingMode != DataGridColumnStyle.ArrowDrawing.No)
+				bounds.Width -= 16;
+
+			// Caption
+			StringFormat format = new StringFormat ();
+			format.FormatFlags |= StringFormatFlags.NoWrap;
+			format.LineAlignment = StringAlignment.Center;
+			format.Trimming = StringTrimming.Character;
+
+			g.DrawString (style.HeaderText, grid.CurrentTableStyle.HeaderFont, 
+				ResPool.GetSolidBrush (grid.CurrentTableStyle.CurrentHeaderForeColor), 
+				bounds, format);
+
+			// Arrow (6 x 6)
+			if (style.ArrowDrawingMode != DataGridColumnStyle.ArrowDrawing.No) {
+				Point pnt = new Point (bounds.X + bounds.Width + 4, bounds.Y + ((bounds.Height - 6)/2));
+				
+				if (style.ArrowDrawingMode == DataGridColumnStyle.ArrowDrawing.Ascending) {
+					g.DrawLine (SystemPens.ControlLightLight, pnt.X + 6, pnt.Y + 6, pnt.X + 3, pnt.Y);
+					g.DrawLine (SystemPens.ControlDark, pnt.X, pnt.Y + 6, pnt.X + 6, pnt.Y + 6);
+					g.DrawLine (SystemPens.ControlDark, pnt.X, pnt.Y + 6, pnt.X + 3, pnt.Y);
+				} else {
+					g.DrawLine (SystemPens.ControlLightLight, pnt.X + 6, pnt.Y, pnt.X + 3, pnt.Y + 6);
+					g.DrawLine (SystemPens.ControlDark, pnt.X, pnt.Y, pnt.X + 6, pnt.Y);
+					g.DrawLine (SystemPens.ControlDark, pnt.X, pnt.Y, pnt.X + 3, pnt.Y + 6);
+				}
+			}
+		}
+
+		public override void DataGridPaintParentRows (Graphics g, Rectangle clip, DataGrid grid)
+		{
+			Rectangle rect_row = new Rectangle ();
+
+			rect_row.X = grid.ParentRowsArea.X;
+			rect_row.Width = grid.ParentRowsArea.Width;
+			rect_row.Height = (grid.CaptionFont.Height + 3);
+
+			object[] parentRows = grid.data_source_stack.ToArray();
+			
+			Region current_clip;
+			Region prev_clip = g.Clip;
+			for (int row = 0; row < parentRows.Length; row++) {
+				rect_row.Y = grid.ParentRowsArea.Y + row * rect_row.Height;
+
+				if (clip.IntersectsWith (rect_row) == false)
+					continue;
+
+				current_clip = new Region (rect_row);
+				current_clip.Intersect (prev_clip);
+				g.Clip = current_clip;
+
+				DataGridPaintParentRow (g, rect_row, (DataGridDataSource)parentRows[parentRows.Length - row - 1], grid);
+
+				current_clip.Dispose ();
+			}
+			
+			g.Clip = prev_clip;
+		}
+
+		public override void DataGridPaintParentRow (Graphics g, Rectangle bounds, DataGridDataSource row, DataGrid grid)
+		{
+			// Background
+			g.FillRectangle (ResPool.GetSolidBrush (grid.ParentRowsBackColor),
+					 bounds);
+
+			Font bold_font = new Font (grid.Font.FontFamily, grid.Font.Size, grid.Font.Style | FontStyle.Bold);
+			// set up some standard string formating variables
+			StringFormat text_format = new StringFormat();
+			text_format.LineAlignment = StringAlignment.Center;
+			text_format.Alignment = StringAlignment.Near;
+
+			string table_name = "";
+			if (row.view is DataRowView)
+				table_name = ((ITypedList)((DataRowView)row.view).DataView).GetListName (null) + ": ";
+			// XXX else?
+
+			Rectangle	text_rect;
+			Size		text_size;
+
+			text_size = g.MeasureString (table_name, bold_font).ToSize();
+			text_rect = new Rectangle(new Point(bounds.X + 3, bounds.Y + bounds.Height - text_size.Height), text_size);
+
+			g.DrawString (table_name,
+				      bold_font, ResPool.GetSolidBrush (grid.ParentRowsForeColor), text_rect, text_format);
+
+			foreach (PropertyDescriptor pd in ((ICustomTypeDescriptor)row.view).GetProperties()) {
+				if (typeof(IBindingList).IsAssignableFrom (pd.PropertyType))
+					continue;
+
+				text_rect.X += text_rect.Size.Width + 5;
+
+				string text = String.Format ("{0}: {1}",
+							     pd.Name,
+							     pd.GetValue (row.view));
+
+				text_rect.Size = g.MeasureString (text, grid.Font).ToSize();
+				text_rect.Y = bounds.Y + bounds.Height - text_rect.Height; // XXX
+
+				g.DrawString (text,
+					      grid.Font, ResPool.GetSolidBrush (grid.ParentRowsForeColor), text_rect, text_format);
+			}
+
+            // Paint Borders
+			if (!grid.FlatMode) {
+                CPDrawBorder3D (g, bounds, Border3DStyle.RaisedInner, 
+                    Border3DSide.Left | Border3DSide.Right | 
+                    Border3DSide.Top | Border3DSide.Bottom);
+			}
+		}
+
+		public override void DataGridPaintRowHeaderArrow (Graphics g, Rectangle bounds, DataGrid grid) 
+		{		
+			Point[] arrow = new Point[3];
+			Point P1, P2, P3;
+			int centerX, centerY, shiftX;			
+			Rectangle rect;
+			
+			rect = new Rectangle (bounds.X + bounds.Width /4, 
+				bounds.Y + bounds.Height/4, bounds.Width / 2, bounds.Height / 2);
+			
+			centerX = rect.Left + rect.Width / 2;
+			centerY = rect.Top + rect.Height / 2;
+			shiftX = Math.Max (1, rect.Width / 8);			
+			rect.X -= shiftX;
+			centerX -= shiftX;			
+			P1 = new Point (centerX, rect.Top - 1);
+			P2 = new Point (centerX, rect.Bottom);
+			P3 = new Point (rect.Right, centerY);			
+			arrow[0] = P1;
+			arrow[1] = P2;
+			arrow[2] = P3;
+			
+			g.FillPolygon (ResPool.GetSolidBrush 
+				(grid.CurrentTableStyle.CurrentHeaderForeColor), arrow, FillMode.Winding);
+		}
+
+		public override void DataGridPaintRowHeaderStar (Graphics g, Rectangle bounds, DataGrid grid) 
+		{
+			int x = bounds.X + 4;
+			int y = bounds.Y + 3;
+			Pen pen = ResPool.GetPen (grid.CurrentTableStyle.CurrentHeaderForeColor);
+
+			g.DrawLine (pen, x + 4, y, x + 4, y + 8);
+			g.DrawLine (pen, x, y + 4, x + 8, y + 4);
+			g.DrawLine (pen, x + 1, y + 1, x + 7, y + 7);
+			g.DrawLine (pen, x + 7, y + 1, x + 1, y + 7);
+		}		
+
+		public override void DataGridPaintRowHeader (Graphics g, Rectangle bounds, int row, DataGrid grid)
+		{
+			bool is_add_row = grid.ShowEditRow && row == grid.DataGridRows.Length - 1;
+			bool is_current_row = row == grid.CurrentCell.RowNumber;
+
+			// Background
+			g.FillRectangle (ResPool.GetSolidBrush (grid.CurrentTableStyle.CurrentHeaderBackColor), bounds);
+
+			// Draw arrow
+			if (is_current_row) {
+				if (grid.IsChanging) {
+					g.DrawString ("..", grid.Font,
+						      ResPool.GetSolidBrush (grid.CurrentTableStyle.CurrentHeaderForeColor),
+						      bounds);
+				} else {
+					Rectangle rect = new Rectangle (bounds.X - 2, bounds.Y, 18, 18);
+					DataGridPaintRowHeaderArrow (g, rect, grid);
+				}
+			}
+			else if (is_add_row) {
+				DataGridPaintRowHeaderStar (g, bounds, grid);
+			}
+
+			if (!grid.FlatMode && !is_add_row) {
+				CPDrawBorder3D (g, bounds, Border3DStyle.RaisedInner, 
+					Border3DSide.Left | Border3DSide.Right | 
+					Border3DSide.Top | Border3DSide.Bottom);
+			}
+		}
+		
+		public override void DataGridPaintRows (Graphics g, Rectangle cells, Rectangle clip, DataGrid grid)
+		{
+			Rectangle rect_row = new Rectangle ();
+			Rectangle not_usedarea = new Rectangle ();
+
+			int rowcnt = grid.VisibleRowCount;
+			
+			bool showing_add_row = false;
+
+			if (grid.RowsCount < grid.DataGridRows.Length) {
+				/* the table has an add row 
+
+				if (grid.FirstVisibleRow + grid.VisibleRowCount >= grid.DataGridRows.Length) {
+					showing_add_row = true;
+				}
+			}
+
+			rect_row.Width = cells.Width + grid.RowHeadersArea.Width;
+			for (int r = 0; r < rowcnt; r++) {
+				int row = grid.FirstVisibleRow + r;
+				if (row == grid.DataGridRows.Length - 1)
+					rect_row.Height = grid.DataGridRows[row].Height;
+				else
+					rect_row.Height = grid.DataGridRows[row + 1].VerticalOffset - grid.DataGridRows[row].VerticalOffset;
+				rect_row.Y = cells.Y + grid.DataGridRows[row].VerticalOffset - grid.DataGridRows[grid.FirstVisibleRow].VerticalOffset;
+				if (clip.IntersectsWith (rect_row)) {
+					if (grid.CurrentTableStyle.HasRelations
+					    && !(showing_add_row && row == grid.DataGridRows.Length - 1))
+						DataGridPaintRelationRow (g, row, rect_row, false, clip, grid);
+					else
+						DataGridPaintRow (g, row, rect_row, showing_add_row && row == grid.DataGridRows.Length - 1, clip, grid);
+				}
+			}
+
+			not_usedarea.X = 0;
+			// the rowcnt == 0 check is needed because
+			// otherwise we'd draw over the caption on
+			// empty datasources (since rect_row would be
+			// Empty)
+			if (rowcnt == 0)
+				not_usedarea.Y = cells.Y;
+			else
+				not_usedarea.Y = rect_row.Y + rect_row.Height;
+			not_usedarea.Height = cells.Y + cells.Height - rect_row.Y - rect_row.Height;
+			not_usedarea.Width = cells.Width + grid.RowHeadersArea.Width;
+
+			g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor), not_usedarea);
+		}
+
+		public override void DataGridPaintRelationRow (Graphics g, int row, Rectangle row_rect, bool is_newrow,
+							       Rectangle clip, DataGrid grid)
+		{
+			Rectangle rect_header;
+			Rectangle icon_bounds = new Rectangle ();
+			Pen pen = ThemeEngine.Current.ResPool.GetPen (grid.CurrentTableStyle.ForeColor);
+
+			/* paint the header if it's visible and intersects the clip
+			if (grid.CurrentTableStyle.CurrentRowHeadersVisible) {
+				rect_header = row_rect;
+				rect_header.Width = grid.RowHeaderWidth;
+				row_rect.X += grid.RowHeaderWidth;
+				if (clip.IntersectsWith (rect_header)) {
+					DataGridPaintRowHeader (g, rect_header, row, grid);
+				}
+
+				icon_bounds = rect_header;
+				icon_bounds.X += icon_bounds.Width / 2;
+				icon_bounds.Y += 3;
+				icon_bounds.Width = 8;
+				icon_bounds.Height = 8;
+
+				g.DrawRectangle (pen, icon_bounds);
+
+				/* the - part of the icon
+				g.DrawLine (pen,
+					    icon_bounds.X + 2, icon_bounds.Y + icon_bounds.Height / 2,
+					    icon_bounds.X + icon_bounds.Width - 2, icon_bounds.Y + icon_bounds.Height / 2);
+					    
+				if (!grid.IsExpanded (row)) {
+					/* the | part of the icon
+					g.DrawLine (pen,
+						    icon_bounds.X + icon_bounds.Width / 2, icon_bounds.Y + 2,
+						    icon_bounds.X + icon_bounds.Width / 2, icon_bounds.Y + icon_bounds.Height - 2);
+				}
+			}
+
+			Rectangle nested_rect = row_rect;
+
+			if (grid.DataGridRows[row].IsExpanded)
+				nested_rect.Height -= grid.DataGridRows[row].RelationHeight;
+
+			DataGridPaintRowContents (g, row, nested_rect, is_newrow, clip, grid);
+
+			if (grid.DataGridRows[row].IsExpanded) {
+				// XXX we should create this in the
+				// datagrid and cache it for use by
+				// the theme instead of doing it each
+				// time through here
+				string[] relations = grid.CurrentTableStyle.Relations;
+				StringBuilder relation_builder = new StringBuilder ("");
+
+				for (int i = 0; i < relations.Length; i ++) {
+					if (i > 0)
+						relation_builder.Append ("\n");
+
+					relation_builder.Append (relations[i]);
+				}
+				string relation_text = relation_builder.ToString ();
+
+				StringFormat string_format = new StringFormat ();
+				string_format.FormatFlags |= StringFormatFlags.NoWrap;
+
+
+				//Region prev_clip = g.Clip;
+				//Region current_clip;
+				Rectangle rect_cell = row_rect;
+
+				rect_cell.X = nested_rect.X + grid.GetColumnStartingPixel (grid.FirstVisibleColumn) - grid.HorizPixelOffset;
+				rect_cell.Y += nested_rect.Height;
+				rect_cell.Height = grid.DataGridRows[row].RelationHeight;
+
+				rect_cell.Width = 0;
+				int column_cnt = grid.FirstVisibleColumn + grid.VisibleColumnCount;
+				for (int column = grid.FirstVisibleColumn; column < column_cnt; column++) {
+					if (grid.CurrentTableStyle.GridColumnStyles[column].bound == false)
+						continue;
+					rect_cell.Width += grid.CurrentTableStyle.GridColumnStyles[column].Width;
+				}
+				rect_cell.Width = Math.Max (rect_cell.Width, grid.DataGridRows[row].relation_area.Width);
+
+				g.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (grid.CurrentTableStyle.BackColor),
+						 rect_cell);
+
+
+				/* draw the line leading from the +/- to the relation area
+				Rectangle outline = grid.DataGridRows[row].relation_area;
+				outline.Y = rect_cell.Y;
+				outline.Height --;
+
+				g.DrawLine (pen,
+					    icon_bounds.X + icon_bounds.Width / 2, icon_bounds.Y + icon_bounds.Height,
+					    icon_bounds.X + icon_bounds.Width / 2, outline.Y + outline.Height / 2);
+
+				g.DrawLine (pen,
+					    icon_bounds.X + icon_bounds.Width / 2, outline.Y + outline.Height / 2,
+					    outline.X, outline.Y + outline.Height / 2);
+
+				g.DrawRectangle (pen, outline);
+
+				g.DrawString (relation_text, grid.LinkFont, ResPool.GetSolidBrush (grid.LinkColor),
+					      outline, string_format);
+
+				if (row_rect.X + row_rect.Width > rect_cell.X + rect_cell.Width) {
+					Rectangle not_usedarea = new Rectangle ();
+					not_usedarea.X = rect_cell.X + rect_cell.Width;
+					not_usedarea.Width = row_rect.X + row_rect.Width - rect_cell.X - rect_cell.Width;
+					not_usedarea.Y = row_rect.Y;
+					not_usedarea.Height = row_rect.Height;
+					if (clip.IntersectsWith (not_usedarea))
+						g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor),
+								 not_usedarea);
+				}
+			}
+		}
+
+		public override void DataGridPaintRowContents (Graphics g, int row, Rectangle row_rect, bool is_newrow,
+							       Rectangle clip, DataGrid grid)
+		{
+			Rectangle rect_cell = new Rectangle ();
+			int col_pixel;
+			Color backcolor, forecolor;
+			Brush backBrush, foreBrush;
+			Rectangle not_usedarea = Rectangle.Empty;
+
+			rect_cell.Y = row_rect.Y;
+			rect_cell.Height = row_rect.Height;
+
+			if (grid.IsSelected (row)) {
+				backcolor =  grid.SelectionBackColor;
+				forecolor =  grid.SelectionForeColor;
+			} else {
+				if (row % 2 == 0) {
+					backcolor =  grid.BackColor;
+				} else {
+					backcolor =  grid.AlternatingBackColor;
+				}
+
+				forecolor =  grid.ForeColor;
+			}			
+
+
+			backBrush = ResPool.GetSolidBrush (backcolor);
+			foreBrush = ResPool.GetSolidBrush (forecolor);
+
+			// PaintCells at row, column
+			int column_cnt = grid.FirstVisibleColumn + grid.VisibleColumnCount;
+			DataGridCell current_cell = grid.CurrentCell;
+
+			if (column_cnt > 0) {
+				Region prev_clip = g.Clip;
+				Region current_clip;
+
+				for (int column = grid.FirstVisibleColumn; column < column_cnt; column++) {
+					if (grid.CurrentTableStyle.GridColumnStyles[column].bound == false)
+						continue;
+
+					col_pixel = grid.GetColumnStartingPixel (column);
+
+					rect_cell.X = row_rect.X + col_pixel - grid.HorizPixelOffset;
+					rect_cell.Width = grid.CurrentTableStyle.GridColumnStyles[column].Width;
+
+					if (clip.IntersectsWith (rect_cell)) {
+						current_clip = new Region (rect_cell);
+						current_clip.Intersect (row_rect);
+						current_clip.Intersect (prev_clip);
+						g.Clip = current_clip;
+
+						Brush colBackBrush = backBrush;
+						Brush colForeBrush = foreBrush;
+
+						// If we are in the precise cell we are editing, then use the normal colors
+						// even if we are selected.
+						if (grid.is_editing && column == current_cell.ColumnNumber && row == current_cell.RowNumber) {
+							colBackBrush = ResPool.GetSolidBrush (grid.BackColor);
+							colForeBrush = ResPool.GetSolidBrush (grid.ForeColor);
+						}
+
+						if (is_newrow) {
+							grid.CurrentTableStyle.GridColumnStyles[column].PaintNewRow (g, rect_cell, 
+														     colBackBrush,
+														     colForeBrush);
+						} else {
+							grid.CurrentTableStyle.GridColumnStyles[column].Paint (g, rect_cell, grid.ListManager, row,
+													       colBackBrush,
+													       colForeBrush,
+													       grid.RightToLeft == RightToLeft.Yes);
+						}
+
+						current_clip.Dispose ();
+					}
+				}
+
+				g.Clip = prev_clip;
+			
+				if (row_rect.X + row_rect.Width > rect_cell.X + rect_cell.Width) {
+					not_usedarea.X = rect_cell.X + rect_cell.Width;
+					not_usedarea.Width = row_rect.X + row_rect.Width - rect_cell.X - rect_cell.Width;
+					not_usedarea.Y = row_rect.Y;
+					not_usedarea.Height = row_rect.Height;
+				}
+			}
+			else {
+				not_usedarea = row_rect;
+			}
+
+			if (!not_usedarea.IsEmpty && clip.IntersectsWith (not_usedarea))
+				g.FillRectangle (ResPool.GetSolidBrush (grid.BackgroundColor),
+						 not_usedarea);
+		}
+
+		public override void DataGridPaintRow (Graphics g, int row, Rectangle row_rect, bool is_newrow,
+						       Rectangle clip, DataGrid grid)
+		{			
+			/* paint the header if it's visible and intersects the clip
+			if (grid.CurrentTableStyle.CurrentRowHeadersVisible) {
+				Rectangle rect_header = row_rect;
+				rect_header.Width = grid.RowHeaderWidth;
+				row_rect.X += grid.RowHeaderWidth;
+				if (clip.IntersectsWith (rect_header)) {
+					DataGridPaintRowHeader (g, rect_header, row, grid);
+				}
+			}
+
+			DataGridPaintRowContents (g, row, row_rect, is_newrow, clip, grid);
+		}
+		
+		#endregion // Datagrid
+
+		#region DataGridView
+		#region DataGridViewHeaderCell
+		#region DataGridViewRowHeaderCell
+		public override bool DataGridViewRowHeaderCellDrawBackground (DataGridViewRowHeaderCell cell, Graphics g, Rectangle bounds)
+		{
+			return false;
+		}
+
+		public override bool DataGridViewRowHeaderCellDrawSelectionBackground (DataGridViewRowHeaderCell cell)
+		{
+			return false;
+		}
+
+		public override bool DataGridViewRowHeaderCellDrawBorder (DataGridViewRowHeaderCell cell, Graphics g, Rectangle bounds)
+		{
+			return false;
+		}
+		#endregion
+
+		#region DataGridViewColumnHeaderCell
+		public override bool DataGridViewColumnHeaderCellDrawBackground (DataGridViewColumnHeaderCell cell, Graphics g, Rectangle bounds)
+		{
+			return false;
+		}
+
+		public override bool DataGridViewColumnHeaderCellDrawBorder (DataGridViewColumnHeaderCell cell, Graphics g, Rectangle bounds)
+		{
+			return false;
+		}
+		#endregion
+
+		public override bool DataGridViewHeaderCellHasPressedStyle  (DataGridView dataGridView)
+		{
+			return false;
+		}
+
+		public override bool DataGridViewHeaderCellHasHotStyle (DataGridView dataGridView)
+		{
+			return false;
+		}
+		#endregion
+		#endregion
+*/
+
+        #region DateTimePicker
+        protected virtual void DateTimePickerDrawBorder(DateTimePicker dateTimePicker, Graphics g, Rectangle clippingArea)
+        {
+            this.CPDrawBorder3D(g, dateTimePicker.ClientRectangle, Border3DStyle.Sunken, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, dateTimePicker.BackColor);
+        }
+
+        protected virtual void DateTimePickerDrawDropDownButton(DateTimePicker dateTimePicker, Graphics g, Rectangle clippingArea)
+        {
+            ButtonState state = dateTimePicker.is_drop_down_visible ? ButtonState.Pushed : ButtonState.Normal;
+            g.FillRectangle(ResPool.GetSolidBrush(ColorControl), dateTimePicker.drop_down_arrow_rect);
+            this.CPDrawComboButton(
+              g,
+              dateTimePicker.drop_down_arrow_rect,
+              state);
+        }
+
+        public override void DrawDateTimePicker(Graphics dc, Rectangle clip_rectangle, DateTimePicker dtp)
+        {
+
+            if (!clip_rectangle.IntersectsWith(dtp.ClientRectangle))
+                return;
+
+            // draw the outer border
+            Rectangle button_bounds = dtp.ClientRectangle;
+            DateTimePickerDrawBorder(dtp, dc, clip_rectangle);
+
+            // deflate by the border width
+            if (clip_rectangle.IntersectsWith(dtp.drop_down_arrow_rect))
+            {
+                button_bounds.Inflate(-2, -2);
+                if (!dtp.ShowUpDown)
+                {
+                    DateTimePickerDrawDropDownButton(dtp, dc, clip_rectangle);
+                }
+                else
+                {
+                    ButtonState up_state = dtp.is_up_pressed ? ButtonState.Pushed : ButtonState.Normal;
+                    ButtonState down_state = dtp.is_down_pressed ? ButtonState.Pushed : ButtonState.Normal;
+                    Rectangle up_bounds = dtp.drop_down_arrow_rect;
+                    Rectangle down_bounds = dtp.drop_down_arrow_rect;
+
+                    up_bounds.Height = up_bounds.Height / 2;
+                    down_bounds.Y = up_bounds.Height;
+                    down_bounds.Height = dtp.Height - up_bounds.Height;
+                    if (down_bounds.Height > up_bounds.Height)
+                    {
+                        down_bounds.Y += 1;
+                        down_bounds.Height -= 1;
+                    }
+
+                    up_bounds.Inflate(-1, -1);
+                    down_bounds.Inflate(-1, -1);
+
+                    WidgetPaint.DrawScrollButton(dc, up_bounds, ScrollButton.Up, up_state);
+                    WidgetPaint.DrawScrollButton(dc, down_bounds, ScrollButton.Down, down_state);
+                }
+            }
+
+            // render the date part
+            if (!clip_rectangle.IntersectsWith(dtp.date_area_rect))
+                return;
+
+            // fill the background
+            dc.FillRectangle(SystemBrushes.Window, dtp.date_area_rect);
+
+            // Update date_area_rect if we are drawing the checkbox
+            Rectangle date_area_rect = dtp.date_area_rect;
+            if (dtp.ShowCheckBox)
+            {
+                Rectangle check_box_rect = dtp.CheckBoxRect;
+                date_area_rect.X = date_area_rect.X + check_box_rect.Width + DateTimePicker.check_box_space * 2;
+                date_area_rect.Width = date_area_rect.Width - check_box_rect.Width - DateTimePicker.check_box_space * 2;
+
+                ButtonState bs = dtp.Checked ? ButtonState.Checked : ButtonState.Normal;
+                CPDrawCheckBox(dc, check_box_rect, bs);
+
+                if (dtp.is_checkbox_selected)
+                    CPDrawFocusRectangle(dc, check_box_rect, dtp.foreground_color, dtp.background_color);
+            }
+
+            // render each text part
+            using (StringFormat text_format = StringFormat.GenericTypographic)
+            {
+                text_format.LineAlignment = StringAlignment.Near;
+                text_format.Alignment = StringAlignment.Near;
+                text_format.FormatFlags = text_format.FormatFlags | StringFormatFlags.MeasureTrailingSpaces | StringFormatFlags.NoWrap | StringFormatFlags.FitBlackBox;
+                text_format.FormatFlags &= ~StringFormatFlags.NoClip;
+
+                // Calculate the rectangles for each part 
+                if (dtp.part_data.Length > 0 && dtp.part_data[0].drawing_rectangle.IsEmpty)
+                {
+                    Graphics gr = dc;
+                    for (int i = 0; i < dtp.part_data.Length; i++)
+                    {
+                        DateTimePicker.PartData fd = dtp.part_data[i];
+                        RectangleF text_rect = new RectangleF();
+                        string text = fd.GetText(dtp.Value);
+                        text_rect.Size = gr.MeasureString(text, dtp.Font, 250, text_format);
+                        if (!fd.is_literal)
+                            text_rect.Width = Math.Max(dtp.CalculateMaxWidth(fd.value, gr, text_format), text_rect.Width);
+
+                        if (i > 0)
+                        {
+                            text_rect.X = dtp.part_data[i - 1].drawing_rectangle.Right;
+                        }
+                        else
+                        {
+                            text_rect.X = date_area_rect.X;
+                        }
+                        text_rect.Y = 2;
+                        text_rect.Inflate(1, 0);
+                        fd.drawing_rectangle = text_rect;
+                    }
+                }
+
+                // draw the text part
+                Brush text_brush = ResPool.GetSolidBrush(dtp.ShowCheckBox && dtp.Checked == false ?
+                        SystemColors.GrayText : dtp.ForeColor); // Use GrayText if Checked is false
+                RectangleF clip_rectangleF = clip_rectangle;
+
+                for (int i = 0; i < dtp.part_data.Length; i++)
+                {
+                    DateTimePicker.PartData fd = dtp.part_data[i];
+                    string text;
+
+                    if (!clip_rectangleF.IntersectsWith(fd.drawing_rectangle))
+                        continue;
+
+                    text = dtp.editing_part_index == i ? dtp.editing_text : fd.GetText(dtp.Value);
+
+                    PointF text_position = new PointF();
+                    SizeF text_size;
+                    RectangleF text_rect;
+
+                    text_size = dc.MeasureString(text, dtp.Font, 250, text_format);
+                    text_position.X = (fd.drawing_rectangle.Left + fd.drawing_rectangle.Width / 2) - text_size.Width / 2;
+                    text_position.Y = (fd.drawing_rectangle.Top + fd.drawing_rectangle.Height / 2) - text_size.Height / 2;
+                    text_rect = new RectangleF(text_position, text_size);
+                    text_rect = RectangleF.Intersect(text_rect, date_area_rect);
+
+                    if (text_rect.IsEmpty)
+                        break;
+
+                    if (text_rect.Right >= date_area_rect.Right)
+                        text_format.FormatFlags &= ~StringFormatFlags.NoClip;
+                    else
+                        text_format.FormatFlags |= StringFormatFlags.NoClip;
+
+                    if (fd.Selected)
+                    {
+                        dc.FillRectangle(SystemBrushes.Highlight, text_rect);
+                        dc.DrawString(text, dtp.Font, SystemBrushes.HighlightText, text_rect, text_format);
+
+                    }
+                    else
+                    {
+                        dc.DrawString(text, dtp.Font, text_brush, text_rect, text_format);
+                    }
+
+                    if (fd.drawing_rectangle.Right > date_area_rect.Right)
+                        break; // the next part would be not be visible, so don't draw anything more.
+                }
+            }
+        }
+
+        public override bool DateTimePickerBorderHasHotElementStyle
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        public override Rectangle DateTimePickerGetDropDownButtonArea(DateTimePicker dateTimePicker)
+        {
+            Rectangle rect = dateTimePicker.ClientRectangle;
+            rect.X = rect.Right - SystemInformation.VerticalScrollBarWidth - 2;
+            if (rect.Width > (SystemInformation.VerticalScrollBarWidth + 2))
+            {
+                rect.Width = SystemInformation.VerticalScrollBarWidth;
+            }
+            else
+            {
+                rect.Width = Math.Max(rect.Width - 2, 0);
+            }
+
+            rect.Inflate(0, -2);
+            return rect;
+        }
+
+        public override Rectangle DateTimePickerGetDateArea(DateTimePicker dateTimePicker)
+        {
+            Rectangle rect = dateTimePicker.ClientRectangle;
+            if (dateTimePicker.ShowUpDown)
+            {
+                // set the space to the left of the up/down button
+                if (rect.Width > (DateTimePicker.up_down_width + 4))
+                {
+                    rect.Width -= (DateTimePicker.up_down_width + 4);
+                }
+                else
+                {
+                    rect.Width = 0;
+                }
+            }
+            else
+            {
+                // set the space to the left of the up/down button
+                // TODO make this use up down button
+                if (rect.Width > (SystemInformation.VerticalScrollBarWidth + 4))
+                {
+                    rect.Width -= SystemInformation.VerticalScrollBarWidth;
+                }
+                else
+                {
+                    rect.Width = 0;
+                }
+            }
+
+            rect.Inflate(-2, -2);
+            return rect;
+        }
+        public override bool DateTimePickerDropDownButtonHasHotElementStyle
+        {
+            get
+            {
+                return false;
+            }
+        }
+        #endregion // DateTimePicker
+
+        #region GroupBox
+        public override void DrawGroupBox(Graphics dc, Rectangle area, GroupBox box)
+        {
+            StringFormat text_format;
+            SizeF size;
+            int width;
+            int y;
+
+            dc.FillRectangle(GetControlBackBrush(box.BackColor), box.ClientRectangle);
+
+            text_format = new StringFormat();
+            text_format.HotkeyPrefix = HotkeyPrefix.Show;
+
+            size = dc.MeasureString(box.Text, box.Font);
+            width = 0;
+
+            if (size.Width > 0)
+            {
+                width = ((int)size.Width) + 7;
+
+                if (width > box.Width - 16)
+                    width = box.Width - 16;
+            }
+
+            y = box.Font.Height / 2;
+
+            // Clip the are that the text will be in
+            Region prev_clip = dc.Clip;
+            dc.SetClip(new Rectangle(10, 0, width, box.Font.Height), CombineMode.Exclude);
+            /* Draw group box*/
+            CPDrawBorder3D(dc, new Rectangle(0, y, box.Width, box.Height - y), Border3DStyle.Etched, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, box.BackColor);
+            dc.Clip = prev_clip;
+
+            /* Text */
+            if (box.Text.Length != 0)
+            {
+                if (box.Enabled)
+                {
+                    dc.DrawString(box.Text, box.Font, ResPool.GetSolidBrush(box.ForeColor), 10, 0, text_format);
+                }
+                else
+                {
+                    CPDrawStringDisabled(dc, box.Text, box.Font, box.BackColor,
+                                  new RectangleF(10, 0, width, box.Font.Height), text_format);
+                }
+            }
+
+            text_format.Dispose();
+        }
+
+        public override Size GroupBoxDefaultSize
+        {
+            get
+            {
+                return new Size(200, 100);
+            }
+        }
+        #endregion
+
+        #region HScrollBar
+        public override Size HScrollBarDefaultSize
+        {
+            get
+            {
+                return new Size(80, this.ScrollBarButtonSize);
+            }
+        }
+
+        #endregion // HScrollBar
+
+        #region ListBox
+
+        public override void DrawListBoxItem(ListBox ctrl, DrawItemEventArgs e)
+        {
+            Color back_color, fore_color;
+
+            if ((e.State & DrawItemState.Selected) == DrawItemState.Selected)
+            {
+                back_color = ColorHighlight;
+                fore_color = ColorHighlightText;
+            }
+            else
+            {
+                back_color = e.BackColor;
+                fore_color = e.ForeColor;
+            }
+
+            e.Graphics.FillRectangle(ResPool.GetSolidBrush(back_color), e.Bounds);
+
+            e.Graphics.DrawString(ctrl.GetItemText(ctrl.Items[e.Index]), e.Font,
+                           ResPool.GetSolidBrush(fore_color),
+                           e.Bounds, ctrl.StringFormat);
+
+            if ((e.State & DrawItemState.Focus) == DrawItemState.Focus)
+                CPDrawFocusRectangle(e.Graphics, e.Bounds, fore_color, back_color);
+        }
+
+        #endregion ListBox
+
+        #region ListView
+        // Drawing
+        public override void DrawListViewItems(Graphics dc, Rectangle clip, ListView control)
+        {
+            bool details = control.View == View.Details;
+            int first = control.FirstVisibleIndex;
+            int lastvisibleindex = control.LastVisibleIndex;
+
+            if (control.VirtualMode)
+                control.OnCacheVirtualItems(new CacheVirtualItemsEventArgs(first, lastvisibleindex));
+
+            for (int i = first; i <= lastvisibleindex; i++)
+            {
+                ListViewItem item = control.GetItemAtDisplayIndex(i);
+                if (clip.IntersectsWith(item.Bounds))
+                {
+                    bool owner_draw = false;
+                    if (control.OwnerDraw)
+                        owner_draw = DrawListViewItemOwnerDraw(dc, item, i);
+                    if (!owner_draw)
+                    {
+                        DrawListViewItem(dc, control, item);
+                        if (control.View == View.Details)
+                            DrawListViewSubItems(dc, control, item);
+                    }
+                }
+            }
+
+            if (control.UsingGroups)
+            {
+                // Use InternalCount instead of Count to take into account Default Group as needed
+                for (int i = 0; i < control.Groups.InternalCount; i++)
+                {
+                    ListViewGroup group = control.Groups.GetInternalGroup(i);
+                    if (group.ItemCount > 0 && clip.IntersectsWith(group.HeaderBounds))
+                        DrawListViewGroupHeader(dc, control, group);
+                }
+            }
+
+            ListViewInsertionMark insertion_mark = control.InsertionMark;
+            int insertion_mark_index = insertion_mark.Index;
+            if (Application.VisualStylesEnabled && insertion_mark.Bounds != Rectangle.Empty &&
+                    (control.View != View.Details && control.View != View.List) &&
+                    insertion_mark_index > -1 && insertion_mark_index < control.Items.Count)
+            {
+
+                Brush brush = ResPool.GetSolidBrush(insertion_mark.Color);
+                dc.FillRectangle(brush, insertion_mark.Line);
+                dc.FillPolygon(brush, insertion_mark.TopTriangle);
+                dc.FillPolygon(brush, insertion_mark.BottomTriangle);
+            }
+
+            // draw the gridlines
+            if (details && control.GridLines && !control.UsingGroups)
+            {
+                Size control_size = control.ClientSize;
+                int top = (control.HeaderStyle == ColumnHeaderStyle.None) ?
+                    0 : control.header_control.Height;
+
+                // draw vertical gridlines
+                foreach (ColumnHeader col in control.Columns)
+                {
+                    int column_right = col.Rect.Right - control.h_marker;
+                    dc.DrawLine(SystemPens.Control,
+                             column_right, top,
+                             column_right, control_size.Height);
+                }
+
+                // draw horizontal gridlines
+                int item_height = control.ItemSize.Height;
+                if (item_height == 0)
+                    item_height = control.Font.Height + 2;
+
+                int y = top + item_height - (control.v_marker % item_height); // scroll bar offset
+                while (y < control_size.Height)
+                {
+                    dc.DrawLine(SystemPens.Control, 0, y, control_size.Width, y);
+                    y += item_height;
+                }
+            }
+
+            // Draw corner between the two scrollbars
+            if (control.h_scroll.Visible == true && control.v_scroll.Visible == true)
+            {
+                Rectangle rect = new Rectangle();
+                rect.X = control.h_scroll.Location.X + control.h_scroll.Width;
+                rect.Width = control.v_scroll.Width;
+                rect.Y = control.v_scroll.Location.Y + control.v_scroll.Height;
+                rect.Height = control.h_scroll.Height;
+                dc.FillRectangle(SystemBrushes.Control, rect);
+            }
+
+            Rectangle box_select_rect = control.item_control.BoxSelectRectangle;
+            if (!box_select_rect.Size.IsEmpty)
+                dc.DrawRectangle(ResPool.GetDashPen(ColorControlText, DashStyle.Dot), box_select_rect);
+
+        }
+
+        public override void DrawListViewHeader(Graphics dc, Rectangle clip, ListView control)
+        {
+            bool details = (control.View == View.Details);
+
+            // border is drawn directly in the Paint method
+            if (details && control.HeaderStyle != ColumnHeaderStyle.None)
+            {
+                dc.FillRectangle(new SolidBrush(Application.CurrentSkin.ListViewBackground),
+                          0, 0, control.TotalWidth, control.Font.Height + 5);
+                if (control.Columns.Count > 0)
+                {
+                    foreach (ColumnHeader col in control.Columns)
+                    {
+                        Rectangle rect = col.Rect;
+                        rect.X -= control.h_marker;
+
+                        bool owner_draw = false;
+                        if (control.OwnerDraw)
+                            owner_draw = DrawListViewColumnHeaderOwnerDraw(dc, control, col, rect);
+                        if (owner_draw)
+                            continue;
+
+                        ListViewDrawColumnHeaderBackground(control, col, dc, rect, clip);
+                        rect.X += 5;
+                        rect.Width -= 10;
+                        if (rect.Width <= 0)
+                            continue;
+
+                        int image_index;
+                        if (control.SmallImageList == null)
+                            image_index = -1;
+                        else
+                            image_index = col.ImageKey == String.Empty ? col.ImageIndex : control.SmallImageList.Images.IndexOfKey(col.ImageKey);
+
+                        if (image_index > -1 && image_index < control.SmallImageList.Images.Count)
+                        {
+                            int image_width = control.SmallImageList.ImageSize.Width + 5;
+                            int text_width = (int)dc.MeasureString(col.Text, control.Font).Width;
+                            int x_origin = rect.X;
+                            int y_origin = rect.Y + ((rect.Height - control.SmallImageList.ImageSize.Height) / 2);
+
+                            switch (col.TextAlign)
+                            {
+                                case HorizontalAlignment.Left:
+                                    break;
+                                case HorizontalAlignment.Right:
+                                    x_origin = rect.Right - (text_width + image_width);
+                                    break;
+                                case HorizontalAlignment.Center:
+                                    x_origin = (rect.Width - (text_width + image_width)) / 2 + rect.X;
+                                    break;
+                            }
+
+                            if (x_origin < rect.X)
+                                x_origin = rect.X;
+
+                            control.SmallImageList.Draw(dc, new Point(x_origin, y_origin), image_index);
+                            rect.X += image_width;
+                            rect.Width -= image_width;
+                        }
+
+                        dc.DrawString(col.Text, control.Font, SystemBrushes.ControlText, rect, col.Format);
+                    }
+                    int right = control.GetReorderedColumn(control.Columns.Count - 1).Rect.Right - control.h_marker;
+                    if (right < control.Right)
+                    {
+                        Rectangle rect = control.Columns[0].Rect;
+                        rect.X = right;
+                        rect.Width = control.Right - right;
+                        ListViewDrawUnusedHeaderBackground(control, dc, rect, clip);
+                    }
+                }
+            }
+        }
+
+        protected virtual void ListViewDrawColumnHeaderBackground(ListView listView, ColumnHeader columnHeader, Graphics g, Rectangle area, Rectangle clippingArea)
+        {
+            ButtonState state;
+            if (listView.HeaderStyle == ColumnHeaderStyle.Clickable)
+                state = columnHeader.Pressed ? ButtonState.Pushed : ButtonState.Normal;
+            else
+                state = ButtonState.Flat;
+            CPDrawButton(g, area, state);
+        }
+
+        protected virtual void ListViewDrawUnusedHeaderBackground(ListView listView, Graphics g, Rectangle area, Rectangle clippingArea)
+        {
+            ButtonState state;
+            if (listView.HeaderStyle == ColumnHeaderStyle.Clickable)
+                state = ButtonState.Normal;
+            else
+                state = ButtonState.Flat;
+            CPDrawButton(g, area, state);
+        }
+
+        public override void DrawListViewHeaderDragDetails(Graphics dc, ListView view, ColumnHeader col, int target_x)
+        {
+            Rectangle rect = col.Rect;
+            rect.X -= view.h_marker;
+            Color color = Color.FromArgb(0x7f, ColorControlDark.R, ColorControlDark.G, ColorControlDark.B);
+            dc.FillRectangle(ResPool.GetSolidBrush(color), rect);
+            rect.X += 3;
+            rect.Width -= 8;
+            if (rect.Width <= 0)
+                return;
+            color = Color.FromArgb(0x7f, ColorControlText.R, ColorControlText.G, ColorControlText.B);
+            dc.DrawString(col.Text, view.Font, ResPool.GetSolidBrush(color), rect, col.Format);
+            dc.DrawLine(ResPool.GetSizedPen(ColorHighlight, 2), target_x, 0, target_x, col.Rect.Height);
+        }
+
+        protected virtual bool DrawListViewColumnHeaderOwnerDraw(Graphics dc, ListView control, ColumnHeader column, Rectangle bounds)
+        {
+            ListViewItemStates state = ListViewItemStates.ShowKeyboardCues;
+            if (column.Pressed)
+                state |= ListViewItemStates.Selected;
+
+            DrawListViewColumnHeaderEventArgs args = new DrawListViewColumnHeaderEventArgs(dc,
+                    bounds, column.Index, column, state, SystemColors.ControlText, ThemeEngine.Current.ColorControl, DefaultFont);
+            control.OnDrawColumnHeader(args);
+
+            return !args.DrawDefault;
+        }
+
+        protected virtual bool DrawListViewItemOwnerDraw(Graphics dc, ListViewItem item, int index)
+        {
+            ListViewItemStates item_state = ListViewItemStates.ShowKeyboardCues;
+            if (item.Selected)
+                item_state |= ListViewItemStates.Selected;
+            if (item.Focused)
+                item_state |= ListViewItemStates.Focused;
+
+            DrawListViewItemEventArgs args = new DrawListViewItemEventArgs(dc,
+                    item, item.Bounds, index, item_state);
+            item.ListView.OnDrawItem(args);
+
+            if (args.DrawDefault)
+                return false;
+
+            if (item.ListView.View == View.Details)
+            {
+                int count = Math.Min(item.ListView.Columns.Count, item.SubItems.Count);
+
+                // Do system drawing for subitems if no owner draw is done
+                for (int j = 0; j < count; j++)
+                {
+                    if (!DrawListViewSubItemOwnerDraw(dc, item, item_state, j))
+                    {
+                        if (j == 0) // The first sub item contains the main item semantics
+                            DrawListViewItem(dc, item.ListView, item);
+                        else
+                            DrawListViewSubItem(dc, item.ListView, item, j);
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        protected virtual void DrawListViewItem(Graphics dc, ListView control, ListViewItem item)
+        {
+            Rectangle rect_checkrect = item.CheckRectReal;
+            Rectangle icon_rect = item.GetBounds(ItemBoundsPortion.Icon);
+            Rectangle full_rect = item.GetBounds(ItemBoundsPortion.Entire);
+            Rectangle text_rect = item.GetBounds(ItemBoundsPortion.Label);
+
+            // Tile view doesn't support CheckBoxes
+            if (control.CheckBoxes && control.View != View.Tile)
+            {
+                if (control.StateImageList == null)
+                {
+                    // Make sure we've got at least a line width of 1
+                    int check_wd = Math.Max(3, rect_checkrect.Width / 6);
+                    int scale = Math.Max(1, rect_checkrect.Width / 12);
+
+                    // set the checkbox background
+                    dc.FillRectangle(new SolidBrush(Application.CurrentSkin.CheckBoxBackgroundColor),
+                              rect_checkrect);
+                    // define a rectangle inside the border area
+                    Rectangle rect = new Rectangle(rect_checkrect.X + 2,
+                                    rect_checkrect.Y + 2,
+                                    rect_checkrect.Width - 4,
+                                    rect_checkrect.Height - 4);
+                    Pen pen = new Pen(new SolidBrush(Application.CurrentSkin.CheckBoxBorderColor), Application.CurrentSkin.CheckBoxBorderWidth);
+                    dc.DrawRectangle(pen, rect);
+
+                    // Need to draw a check-mark
+                    if (item.Checked)
+                    {
+                        Pen check_pen = new Pen(new SolidBrush(Application.CurrentSkin.CheckBoxCheckColor), 1);
+                        // adjustments to get the check-mark at the right place
+                        rect.X++; rect.Y++;
+                        // following logic is taken from DrawFrameControl method
+                        int x_offset = rect.Width / 5;
+                        int y_offset = rect.Height / 3;
+                        for (int i = 0; i < check_wd; i++)
+                        {
+                            dc.DrawLine(check_pen, rect.Left + x_offset,
+                                     rect.Top + y_offset + i,
+                                     rect.Left + x_offset + 2 * scale,
+                                     rect.Top + y_offset + 2 * scale + i);
+                            dc.DrawLine(check_pen,
+                                     rect.Left + x_offset + 2 * scale,
+                                     rect.Top + y_offset + 2 * scale + i,
+                                     rect.Left + x_offset + 6 * scale,
+                                     rect.Top + y_offset - 2 * scale + i);
+                        }
+                    }
+                }
+                else
+                {
+                    int simage_idx;
+                    if (item.Checked)
+                        simage_idx = control.StateImageList.Images.Count > 1 ? 1 : -1;
+                    else
+                        simage_idx = control.StateImageList.Images.Count > 0 ? 0 : -1;
+
+                    if (simage_idx > -1)
+                        control.StateImageList.Draw(dc, rect_checkrect.Location, simage_idx);
+                }
+            }
+
+            ImageList image_list = control.View == View.LargeIcon || control.View == View.Tile ? control.LargeImageList : control.SmallImageList;
+            if (image_list != null)
+            {
+                int idx;
+
+                if (item.ImageKey != String.Empty)
+                    idx = image_list.Images.IndexOfKey(item.ImageKey);
+                else
+                    idx = item.ImageIndex;
+
+                if (idx > -1 && idx < image_list.Images.Count)
+                {
+                    // Draw a thumbnail image if it exists for a FileViewListViewItem, otherwise draw
+                    // the standard icon.  See https://bugzilla.xamarin.com/show_bug.cgi?id=28025.
+                    image_list.Draw(dc, icon_rect.Location, idx);
+                }
+            }
+
+            // draw the item text			
+            // format for the item text
+            StringFormat format = new StringFormat();
+            if (control.View == View.SmallIcon || control.View == View.LargeIcon)
+                format.LineAlignment = StringAlignment.Near;
+            else
+                format.LineAlignment = StringAlignment.Center;
+            if (control.View == View.LargeIcon)
+                format.Alignment = StringAlignment.Center;
+            else
+                format.Alignment = StringAlignment.Near;
+
+            if (control.LabelWrap && control.View != View.Details && control.View != View.Tile)
+                format.FormatFlags = StringFormatFlags.LineLimit;
+            else
+                format.FormatFlags = StringFormatFlags.NoWrap;
+
+            if ((control.View == View.LargeIcon && !item.Focused) || control.View == View.Details || control.View == View.Tile)
+                format.Trimming = StringTrimming.EllipsisCharacter;
+
+            Rectangle highlight_rect = text_rect;
+            if (control.View == View.Details)
+            { // Adjustments for Details view
+                Size text_size = Size.Ceiling(dc.MeasureString(item.Text, item.Font));
+
+                if (!control.FullRowSelect) // Selection shouldn't be outside the item bounds
+                    highlight_rect.Width = Math.Min(text_size.Width + 4, text_rect.Width);
+            }
+
+            if (item.Selected && control.Focused)
+                dc.FillRectangle(new SolidBrush(Application.CurrentSkin.SelectionHighlight), highlight_rect);
+            else if (item.Selected && !control.HideSelection)
+                dc.FillRectangle(SystemBrushes.Control, highlight_rect);
+            else
+                dc.FillRectangle(ResPool.GetSolidBrush(item.BackColor), text_rect);
+
+            Brush textBrush =
+                !control.Enabled ? SystemBrushes.ControlLight :
+                (item.Selected && control.Focused) ? SystemBrushes.HighlightText :
+                this.ResPool.GetSolidBrush(item.ForeColor);
+
+            // Tile view renders its Text in a different fashion
+            if (control.View == View.Tile && Application.VisualStylesEnabled)
+            {
+                // Item.Text is drawn using its first subitem's bounds
+                dc.DrawString(item.Text, item.Font, textBrush, item.SubItems[0].Bounds, format);
+
+                int count = Math.Min(control.Columns.Count, item.SubItems.Count);
+                for (int i = 1; i < count; i++)
+                {
+                    ListViewItem.ListViewSubItem sub_item = item.SubItems[i];
+                    if (sub_item.Text == null || sub_item.Text.Length == 0)
+                        continue;
+
+                    Brush itemBrush = item.Selected && control.Focused ?
+                        SystemBrushes.HighlightText : GetControlForeBrush(sub_item.ForeColor);
+                    dc.DrawString(sub_item.Text, sub_item.Font, itemBrush, sub_item.Bounds, format);
+                }
+            }
+            else
+
+            if (item.Text != null && item.Text.Length > 0)
+            {
+                Font font = item.Font;
+
+                if (control.HotTracking && item.Hot)
+                    font = item.HotFont;
+
+                if (item.Selected && control.Focused)
+                    dc.DrawString(item.Text, font, textBrush, highlight_rect, format);
+                else
+                    dc.DrawString(item.Text, font, textBrush, text_rect, format);
+            }
+
+            if (item.Focused && control.Focused)
+            {
+                Rectangle focus_rect = highlight_rect;
+                if (control.FullRowSelect && control.View == View.Details)
+                {
+                    int width = 0;
+                    foreach (ColumnHeader col in control.Columns)
+                        width += col.Width;
+                    focus_rect = new Rectangle(0, full_rect.Y, width, full_rect.Height);
+                }
+                if (control.ShowFocusCues)
+                {
+                    if (item.Selected)
+                        CPDrawFocusRectangle(dc, focus_rect, ColorHighlightText, ColorHighlight);
+                    else
+                        CPDrawFocusRectangle(dc, focus_rect, control.ForeColor, control.BackColor);
+                }
+            }
+
+            format.Dispose();
+        }
+
+        protected virtual void DrawListViewSubItems(Graphics dc, ListView control, ListViewItem item)
+        {
+            int columns_count = control.Columns.Count;
+            int count = Math.Min(item.SubItems.Count, columns_count);
+            // 0th item already done (in this case)
+            for (int i = 1; i < count; i++)
+                DrawListViewSubItem(dc, control, item, i);
+
+            // Fill in selection for remaining columns if Column.Count > SubItems.Count
+            Rectangle sub_item_rect = item.GetBounds(ItemBoundsPortion.Label);
+            if (item.Selected && (control.Focused || !control.HideSelection) && control.FullRowSelect)
+            {
+                for (int index = count; index < columns_count; index++)
+                {
+                    ColumnHeader col = control.Columns[index];
+                    sub_item_rect.X = col.Rect.X - control.h_marker;
+                    sub_item_rect.Width = col.Wd;
+                    dc.FillRectangle(control.Focused ? SystemBrushes.Highlight : SystemBrushes.Control,
+                            sub_item_rect);
+                }
+            }
+        }
+
+        protected virtual void DrawListViewSubItem(Graphics dc, ListView control, ListViewItem item, int index)
+        {
+            ListViewItem.ListViewSubItem subItem = item.SubItems[index];
+            ColumnHeader col = control.Columns[index];
+            StringFormat format = new StringFormat();
+            format.Alignment = col.Format.Alignment;
+            format.LineAlignment = StringAlignment.Center;
+            format.FormatFlags = StringFormatFlags.NoWrap;
+            format.Trimming = StringTrimming.EllipsisCharacter;
+
+            Rectangle sub_item_rect = subItem.Bounds;
+            Rectangle sub_item_text_rect = sub_item_rect;
+            sub_item_text_rect.X += 3;
+            sub_item_text_rect.Width -= ListViewItemPaddingWidth;
+
+            SolidBrush sub_item_back_br = null;
+            SolidBrush sub_item_fore_br = null;
+            Font sub_item_font = null;
+
+            if (item.UseItemStyleForSubItems)
+            {
+                sub_item_back_br = ResPool.GetSolidBrush(item.BackColor);
+                sub_item_fore_br = ResPool.GetSolidBrush(item.ForeColor);
+
+                // Hot tracking for subitems only applies when UseStyle is true
+                if (control.HotTracking && item.Hot)
+                    sub_item_font = item.HotFont;
+                else
+                    sub_item_font = item.Font;
+            }
+            else
+            {
+                sub_item_back_br = ResPool.GetSolidBrush(subItem.BackColor);
+                sub_item_fore_br = ResPool.GetSolidBrush(subItem.ForeColor);
+                sub_item_font = subItem.Font;
+            }
+
+            if (item.Selected && (control.Focused || !control.HideSelection) && control.FullRowSelect)
+            {
+                Brush bg, text;
+                if (control.Focused)
+                {
+                    bg = SystemBrushes.Highlight;
+                    text = SystemBrushes.HighlightText;
+                }
+                else
+                {
+                    bg = SystemBrushes.Control;
+                    text = sub_item_fore_br;
+
+                }
+
+                dc.FillRectangle(bg, sub_item_rect);
+                if (subItem.Text != null && subItem.Text.Length > 0)
+                    dc.DrawString(subItem.Text, sub_item_font,
+                            text, sub_item_text_rect, format);
+            }
+            else
+            {
+                dc.FillRectangle(sub_item_back_br, sub_item_rect);
+                if (subItem.Text != null && subItem.Text.Length > 0)
+                    dc.DrawString(subItem.Text, sub_item_font,
+                            sub_item_fore_br,
+                            sub_item_text_rect, format);
+            }
+
+            format.Dispose();
+        }
+
+        protected virtual bool DrawListViewSubItemOwnerDraw(Graphics dc, ListViewItem item, ListViewItemStates state, int index)
+        {
+            ListView control = item.ListView;
+            ListViewItem.ListViewSubItem subitem = item.SubItems[index];
+
+            DrawListViewSubItemEventArgs args = new DrawListViewSubItemEventArgs(dc, subitem.Bounds, item,
+                    subitem, item.Index, index, control.Columns[index], state);
+            control.OnDrawSubItem(args);
+
+            return !args.DrawDefault;
+        }
+
+        protected virtual void DrawListViewGroupHeader(Graphics dc, ListView control, ListViewGroup group)
+        {
+            Rectangle text_bounds = group.HeaderBounds;
+            Rectangle header_bounds = group.HeaderBounds;
+            text_bounds.Offset(8, 0);
+            text_bounds.Inflate(-8, 0);
+            int text_height = control.Font.Height + 2; // add a tiny padding between the text and the group line
+
+            Font font = new Font(control.Font, control.Font.Style | FontStyle.Bold);
+            Brush brush = new LinearGradientBrush(new Point(header_bounds.Left, 0), new Point(header_bounds.Left + ListViewGroupLineWidth, 0),
+                    SystemColors.Desktop, Color.White);
+            Pen pen = new Pen(brush);
+
+            StringFormat sformat = new StringFormat();
+            switch (group.HeaderAlignment)
+            {
+                case HorizontalAlignment.Left:
+                    sformat.Alignment = StringAlignment.Near;
+                    break;
+                case HorizontalAlignment.Center:
+                    sformat.Alignment = StringAlignment.Center;
+                    break;
+                case HorizontalAlignment.Right:
+                    sformat.Alignment = StringAlignment.Far;
+                    break;
+            }
+
+            sformat.LineAlignment = StringAlignment.Near;
+            dc.DrawString(group.Header, font, SystemBrushes.ControlText, text_bounds, sformat);
+            dc.DrawLine(pen, header_bounds.Left, header_bounds.Top + text_height, header_bounds.Left + ListViewGroupLineWidth,
+                    header_bounds.Top + text_height);
+
+            sformat.Dispose();
+            font.Dispose();
+            pen.Dispose();
+            brush.Dispose();
+        }
+
+        public override bool ListViewHasHotHeaderStyle
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        // Sizing
+        public override int ListViewGetHeaderHeight(ListView listView, Font font)
+        {
+            return ListViewGetHeaderHeight(font);
+        }
+
+        static int ListViewGetHeaderHeight(Font font)
+        {
+            return font.Height + 5;
+        }
+
+        public static int ListViewGetHeaderHeight()
+        {
+            return ListViewGetHeaderHeight(ThemeEngine.Current.DefaultFont);
+        }
+
+        public override Size ListViewCheckBoxSize
+        {
+            get { return new Size(16, 16); }
+        }
+
+        public override int ListViewColumnHeaderHeight
+        {
+            get { return 16; }
+        }
+
+        public override int ListViewDefaultColumnWidth
+        {
+            get { return 60; }
+        }
+
+        public override int ListViewVerticalSpacing
+        {
+            get { return 22; }
+        }
+
+        public override int ListViewEmptyColumnWidth
+        {
+            get { return 10; }
+        }
+
+        public override int ListViewHorizontalSpacing
+        {
+            get { return 4; }
+        }
+
+        public override int ListViewItemPaddingWidth
+        {
+            get { return 6; }
+        }
+
+        public override Size ListViewDefaultSize
+        {
+            get { return new Size(121, 97); }
+        }
+
+        public override int ListViewGroupHeight
+        {
+            get { return 20; }
+        }
+
+        public int ListViewGroupLineWidth
+        {
+            get { return 200; }
+        }
+
+        public override int ListViewTileWidthFactor
+        {
+            get { return 22; }
+        }
+
+        public override int ListViewTileHeightFactor
+        {
+            get { return 3; }
+        }
+        #endregion // ListView
+
+        #region Menus
+
+        public override void CalcItemSize(Graphics dc, MenuItem item, int y, int x, bool menuBar)
+        {
+            item.X = x;
+            item.Y = y;
+
+            if (item.Visible == false)
+            {
+                item.Width = 0;
+                item.Height = 0;
+                return;
+            }
+
+            if (item.Separator == true)
+            {
+                item.Height = SEPARATOR_HEIGHT;
+                item.Width = SEPARATOR_MIN_WIDTH;
+                return;
+            }
+
+            if (item.MeasureEventDefined)
+            {
+                MeasureItemEventArgs mi = new MeasureItemEventArgs(dc, item.Index);
+                item.PerformMeasureItem(mi);
+                item.Height = mi.ItemHeight;
+                item.Width = mi.ItemWidth;
+                return;
+            }
+            else
+            {
+                SizeF size;
+                size = dc.MeasureString(item.Text, MenuFont, int.MaxValue, string_format_menu_text);
+                item.Width = (int)size.Width;
+                item.Height = (int)size.Height;
+
+                if (!menuBar)
+                {
+                    if (item.Shortcut != Shortcut.None && item.ShowShortcut)
+                    {
+                        item.XTab = MenuCheckSize.Width + MENU_TAB_SPACE + (int)size.Width;
+                        size = dc.MeasureString(" " + item.GetShortCutText(), MenuFont);
+                        item.Width += MENU_TAB_SPACE + (int)size.Width;
+                    }
+
+                    item.Width += 4 + (MenuCheckSize.Width * 2);
+                }
+                else
+                {
+                    item.Width += MENU_BAR_ITEMS_SPACE;
+                    x += item.Width;
+                }
+
+                if (item.Height < MenuHeight)
+                    item.Height = MenuHeight;
+            }
+        }
+
+        // Updates the menu rect and returns the height
+        public override int CalcMenuBarSize(Graphics dc, Menu menu, int width)
+        {
+            int x = 0;
+            int y = 0;
+            menu.Height = 0;
+
+            foreach (MenuItem item in menu.MenuItems)
+            {
+
+                CalcItemSize(dc, item, y, x, true);
+
+                if (x + item.Width > width)
+                {
+                    item.X = 0;
+                    y += item.Height;
+                    item.Y = y;
+                    x = 0;
+                }
+
+                x += item.Width;
+                item.MenuBar = true;
+
+                if (y + item.Height > menu.Height)
+                    menu.Height = item.Height + y;
+            }
+
+            menu.Width = width;
+            return menu.Height;
+        }
+
+        public override void CalcPopupMenuSize(Graphics dc, Menu menu)
+        {
+            int x = 3;
+            int start = 0;
+            int i, n, y, max;
+
+            menu.Height = 0;
+
+            while (start < menu.MenuItems.Count)
+            {
+                y = 3;
+                max = 0;
+                for (i = start; i < menu.MenuItems.Count; i++)
+                {
+                    MenuItem item = menu.MenuItems[i];
+
+                    if ((i != start) && (item.Break || item.BarBreak))
+                        break;
+
+                    CalcItemSize(dc, item, y, x, false);
+                    y += item.Height;
+
+                    if (item.Width > max)
+                        max = item.Width;
+                }
+
+                // Replace the -1 by the menu width (separators)
+                for (n = start; n < i; n++, start++)
+                    menu.MenuItems[n].Width = max;
+
+                if (y > menu.Height)
+                    menu.Height = y;
+
+                x += max;
+            }
+
+            menu.Width = x;
+
+            //space for border
+            menu.Width += 2;
+            menu.Height += 2;
+
+            menu.Width += SM_CXBORDER;
+            menu.Height += SM_CYBORDER;
+        }
+
+        // Draws a menu bar in a window
+        public override void DrawMenuBar(Graphics dc, Menu menu, Rectangle rect)
+        {
+            if (menu.Height == 0)
+                CalcMenuBarSize(dc, menu, rect.Width);
+
+            bool keynav = (menu as MainMenu).tracker.hotkey_active;
+            HotkeyPrefix hp = MenuAccessKeysUnderlined || keynav ? HotkeyPrefix.Show : HotkeyPrefix.Hide;
+            string_format_menu_menubar_text.HotkeyPrefix = hp;
+            string_format_menu_text.HotkeyPrefix = hp;
+
+            rect.Height = menu.Height;
+            dc.FillRectangle(SystemBrushes.Menu, rect);
+
+            for (int i = 0; i < menu.MenuItems.Count; i++)
+            {
+                MenuItem item = menu.MenuItems[i];
+                Rectangle item_rect = item.bounds;
+                item_rect.X += rect.X;
+                item_rect.Y += rect.Y;
+                item.MenuHeight = menu.Height;
+                item.PerformDrawItem(new DrawItemEventArgs(dc, MenuFont, item_rect, i, item.Status));
+            }
+        }
+
+        protected Bitmap CreateGlyphBitmap(Size size, MenuGlyph glyph, Color color)
+        {
+            Color bg_color;
+            if (color.R == 0 && color.G == 0 && color.B == 0)
+                bg_color = Color.White;
+            else
+                bg_color = Color.Black;
+
+            Bitmap bmp = new Bitmap(size.Width, size.Height);
+            Graphics gr = Graphics.FromImage(bmp);
+            Rectangle rect = new Rectangle(Point.Empty, size);
+            gr.FillRectangle(ResPool.GetSolidBrush(bg_color), rect);
+            CPDrawMenuGlyph(gr, rect, glyph, color, Color.Empty);
+            bmp.MakeTransparent(bg_color);
+            gr.Dispose();
+
+            return bmp;
+        }
+
+        public override void DrawMenuItem(MenuItem item, DrawItemEventArgs e)
+        {
+            StringFormat string_format;
+            Rectangle rect_text = e.Bounds;
+
+            if (item.Visible == false)
+                return;
+
+            if (item.MenuBar)
+                string_format = string_format_menu_menubar_text;
+            else
+                string_format = string_format_menu_text;
+
+            if (item.Separator == true)
+            {
+                int liney = e.Bounds.Y + (e.Bounds.Height / 2);
+
+                e.Graphics.DrawLine(SystemPens.ControlDark,
+                    e.Bounds.X, liney, e.Bounds.X + e.Bounds.Width, liney);
+
+                e.Graphics.DrawLine(SystemPens.ControlLight,
+                    e.Bounds.X, liney + 1, e.Bounds.X + e.Bounds.Width, liney + 1);
+
+                return;
+            }
+
+            if (!item.MenuBar)
+                rect_text.X += MenuCheckSize.Width;
+
+            if (item.BarBreak)
+            { /* Draw vertical break bar*/
+                Rectangle rect = e.Bounds;
+                rect.Y++;
+                rect.Width = 3;
+                rect.Height = item.MenuHeight - 6;
+
+                e.Graphics.DrawLine(SystemPens.ControlDark,
+                    rect.X, rect.Y, rect.X, rect.Y + rect.Height);
+
+                e.Graphics.DrawLine(SystemPens.ControlLight,
+                    rect.X + 1, rect.Y, rect.X + 1, rect.Y + rect.Height);
+            }
+
+            Color color_text;
+            Color color_back;
+            Brush brush_text = null;
+            Brush brush_back = null;
+
+            if ((e.State & DrawItemState.Selected) == DrawItemState.Selected && !item.MenuBar)
+            {
+                color_text = ColorHighlightText;
+                color_back = ColorHighlight;
+                brush_text = SystemBrushes.HighlightText;
+                brush_back = SystemBrushes.Highlight;
+            }
+            else
+            {
+                color_text = ColorMenuText;
+                color_back = ColorMenu;
+                brush_text = ResPool.GetSolidBrush(ColorMenuText);
+                brush_back = SystemBrushes.Menu;
+            }
+
+            /* Draw background */
+            if (!item.MenuBar)
+                e.Graphics.FillRectangle(brush_back, e.Bounds);
+
+            if (item.Enabled)
+            {
+                e.Graphics.DrawString(item.Text, e.Font,
+                    brush_text,
+                    rect_text, string_format);
+
+                if (item.MenuBar)
+                {
+                    Border3DStyle border_style = Border3DStyle.Adjust;
+                    if ((item.Status & DrawItemState.HotLight) != 0)
+                        border_style = Border3DStyle.RaisedInner;
+                    else if ((item.Status & DrawItemState.Selected) != 0)
+                        border_style = Border3DStyle.SunkenOuter;
+
+                    if (border_style != Border3DStyle.Adjust)
+                        CPDrawBorder3D(e.Graphics, e.Bounds, border_style, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, ColorMenu);
+                }
+            }
+            else
+            {
+                if ((item.Status & DrawItemState.Selected) != DrawItemState.Selected)
+                {
+                    e.Graphics.DrawString(item.Text, e.Font, Brushes.White,
+                                   new RectangleF(rect_text.X + 1, rect_text.Y + 1, rect_text.Width, rect_text.Height),
+                                   string_format);
+
+                }
+
+                e.Graphics.DrawString(item.Text, e.Font, ResPool.GetSolidBrush(ColorGrayText), rect_text, string_format);
+            }
+
+            if (!item.MenuBar && item.Shortcut != Shortcut.None && item.ShowShortcut)
+            {
+                string str = item.GetShortCutText();
+                Rectangle rect = rect_text;
+                rect.X = item.XTab;
+                rect.Width -= item.XTab;
+
+                if (item.Enabled)
+                {
+                    e.Graphics.DrawString(str, e.Font, brush_text, rect, string_format_menu_shortcut);
+                }
+                else
+                {
+                    if ((item.Status & DrawItemState.Selected) != DrawItemState.Selected)
+                    {
+                        e.Graphics.DrawString(str, e.Font, Brushes.White,
+                                       new RectangleF(rect.X + 1, rect.Y + 1, rect.Width, rect_text.Height),
+                                       string_format_menu_shortcut);
+
+                    }
+                    e.Graphics.DrawString(str, e.Font, ResPool.GetSolidBrush(ColorGrayText), rect, string_format_menu_shortcut);
+                }
+            }
+
+            /* Draw arrow */
+            if (item.MenuBar == false && (item.IsPopup || item.MdiList))
+            {
+
+                int cx = MenuCheckSize.Width;
+                int cy = MenuCheckSize.Height;
+                Bitmap bmp = CreateGlyphBitmap(new Size(cx, cy), MenuGlyph.Arrow, color_text);
+
+                if (item.Enabled)
+                {
+                    e.Graphics.DrawImage(bmp, e.Bounds.X + e.Bounds.Width - cx,
+                        e.Bounds.Y + ((e.Bounds.Height - cy) / 2));
+                }
+                else
+                {
+                    WidgetPaint.DrawImageDisabled(e.Graphics, bmp, e.Bounds.X + e.Bounds.Width - cx,
+                        e.Bounds.Y + ((e.Bounds.Height - cy) / 2), color_back);
+                }
+
+                bmp.Dispose();
+            }
+
+            /* Draw checked or radio */
+            if (item.MenuBar == false && item.Checked)
+            {
+
+                Rectangle area = e.Bounds;
+                int cx = MenuCheckSize.Width;
+                int cy = MenuCheckSize.Height;
+                Bitmap bmp = CreateGlyphBitmap(new Size(cx, cy), item.RadioCheck ? MenuGlyph.Bullet : MenuGlyph.Checkmark, color_text);
+
+                e.Graphics.DrawImage(bmp, area.X, e.Bounds.Y + ((e.Bounds.Height - cy) / 2));
+
+                bmp.Dispose();
+            }
+        }
+
+        public override void DrawPopupMenu(Graphics dc, Menu menu, Rectangle cliparea, Rectangle rect)
+        {
+            // Fill rectangle area
+            dc.FillRectangle(SystemBrushes.Menu, cliparea);
+
+
+            // Draw menu items
+            for (int i = 0; i < menu.MenuItems.Count; i++)
+            {
+                if (cliparea.IntersectsWith(menu.MenuItems[i].bounds))
+                {
+                    MenuItem item = menu.MenuItems[i];
+                    item.MenuHeight = menu.Height;
+                    item.PerformDrawItem(new DrawItemEventArgs(dc, MenuFont, item.bounds, i, item.Status));
+                }
+            }
+        }
+
+        #endregion // Menus
+
+        #region MonthCalendar
+
+        // draw the month calendar
+        public override void DrawMonthCalendar(Graphics dc, Rectangle clip_rectangle, MonthCalendar mc)
+        {
+            Rectangle client_rectangle = mc.ClientRectangle;
+            Size month_size = mc.SingleMonthSize;
+            // cache local copies of Marshal-by-ref internal members (gets around error CS0197)
+            Size calendar_spacing = (Size)((object)mc.calendar_spacing);
+            Size date_cell_size = (Size)((object)mc.date_cell_size);
+
+            // draw the singlecalendars
+            int x_offset = 1;
+            int y_offset = 1;
+            // adjust for the position of the specific month
+            for (int i = 0; i < mc.CalendarDimensions.Height; i++)
+            {
+                if (i > 0)
+                {
+                    y_offset += month_size.Height + calendar_spacing.Height;
+                }
+                // now adjust for x position	
+                for (int j = 0; j < mc.CalendarDimensions.Width; j++)
+                {
+                    if (j > 0)
+                    {
+                        x_offset += month_size.Width + calendar_spacing.Width;
+                    }
+                    else
+                    {
+                        x_offset = 1;
+                    }
+
+                    Rectangle month_rect = new Rectangle(x_offset, y_offset, month_size.Width, month_size.Height);
+                    if (month_rect.IntersectsWith(clip_rectangle))
+                    {
+                        DrawSingleMonth(
+                            dc,
+                            clip_rectangle,
+                            month_rect,
+                            mc,
+                            i,
+                            j);
+                    }
+                }
+            }
+
+            Rectangle bottom_rect = new Rectangle(
+                        client_rectangle.X,
+                        Math.Max(client_rectangle.Bottom - date_cell_size.Height - 3, 0),
+                        client_rectangle.Width,
+                        date_cell_size.Height + 2);
+            // draw the today date if it's set
+            if (mc.ShowToday && bottom_rect.IntersectsWith(clip_rectangle))
+            {
+                dc.FillRectangle(GetControlBackBrush(mc.BackColor), bottom_rect);
+                if (mc.ShowToday)
+                {
+                    int today_offset = 5;
+                    if (mc.ShowTodayCircle)
+                    {
+                        Rectangle today_circle_rect = new Rectangle(
+                            client_rectangle.X + 5,
+                            Math.Max(client_rectangle.Bottom - date_cell_size.Height - 2, 0),
+                            date_cell_size.Width,
+                            date_cell_size.Height);
+                        DrawTodayCircle(dc, today_circle_rect);
+                        today_offset += date_cell_size.Width + 5;
+                    }
+                    // draw today's date
+                    StringFormat text_format = new StringFormat();
+                    text_format.LineAlignment = StringAlignment.Center;
+                    text_format.Alignment = StringAlignment.Near;
+                    Rectangle today_rect = new Rectangle(
+                            today_offset + client_rectangle.X,
+                            Math.Max(client_rectangle.Bottom - date_cell_size.Height, 0),
+                            Math.Max(client_rectangle.Width - today_offset, 0),
+                            date_cell_size.Height);
+                    dc.DrawString("Today: " + DateTime.Now.ToShortDateString(), mc.bold_font, GetControlForeBrush(mc.ForeColor), today_rect, text_format);
+                    text_format.Dispose();
+                }
+            }
+
+            Brush border_brush;
+
+            if (mc.owner == null)
+                border_brush = GetControlBackBrush(mc.BackColor);
+            else
+                border_brush = SystemBrushes.ControlDarkDark;
+
+            // finally paint the borders of the calendars as required
+            for (int i = 0; i <= mc.CalendarDimensions.Width; i++)
+            {
+                if (i == 0 && clip_rectangle.X == client_rectangle.X)
+                {
+                    dc.FillRectangle(border_brush, client_rectangle.X, client_rectangle.Y, 1, client_rectangle.Height);
+                }
+                else if (i == mc.CalendarDimensions.Width && clip_rectangle.Right == client_rectangle.Right)
+                {
+                    dc.FillRectangle(border_brush, client_rectangle.Right - 1, client_rectangle.Y, 1, client_rectangle.Height);
+                }
+                else
+                {
+                    Rectangle rect = new Rectangle(
+                        client_rectangle.X + (month_size.Width * i) + (calendar_spacing.Width * (i - 1)) + 1,
+                        client_rectangle.Y,
+                        calendar_spacing.Width,
+                        client_rectangle.Height);
+                    if (i < mc.CalendarDimensions.Width && i > 0 && clip_rectangle.IntersectsWith(rect))
+                    {
+                        dc.FillRectangle(border_brush, rect);
+                    }
+                }
+            }
+            for (int i = 0; i <= mc.CalendarDimensions.Height; i++)
+            {
+                if (i == 0 && clip_rectangle.Y == client_rectangle.Y)
+                {
+                    dc.FillRectangle(border_brush, client_rectangle.X, client_rectangle.Y, client_rectangle.Width, 1);
+                }
+                else if (i == mc.CalendarDimensions.Height && clip_rectangle.Bottom == client_rectangle.Bottom)
+                {
+                    dc.FillRectangle(border_brush, client_rectangle.X, client_rectangle.Bottom - 1, client_rectangle.Width, 1);
+                }
+                else
+                {
+                    Rectangle rect = new Rectangle(
+                        client_rectangle.X,
+                        client_rectangle.Y + (month_size.Height * i) + (calendar_spacing.Height * (i - 1)) + 1,
+                        client_rectangle.Width,
+                        calendar_spacing.Height);
+                    if (i < mc.CalendarDimensions.Height && i > 0 && clip_rectangle.IntersectsWith(rect))
+                    {
+                        dc.FillRectangle(border_brush, rect);
+                    }
+                }
+            }
+
+            // draw the drop down border if need
+            if (mc.owner != null)
+            {
+                Rectangle bounds = mc.ClientRectangle;
+                if (clip_rectangle.Contains(mc.Location))
+                {
+                    // find out if top or left line to draw
+                    if (clip_rectangle.Contains(new Point(bounds.Left, bounds.Bottom)))
+                    {
+
+                        dc.DrawLine(SystemPens.ControlText, bounds.X, bounds.Y, bounds.X, bounds.Bottom - 1);
+                    }
+                    if (clip_rectangle.Contains(new Point(bounds.Right, bounds.Y)))
+                    {
+                        dc.DrawLine(SystemPens.ControlText, bounds.X, bounds.Y, bounds.Right - 1, bounds.Y);
+                    }
+                }
+                if (clip_rectangle.Contains(new Point(bounds.Right, bounds.Bottom)))
+                {
+                    // find out if bottom or right line to draw
+                    if (clip_rectangle.Contains(new Point(bounds.Left, bounds.Bottom)))
+                    {
+                        dc.DrawLine(SystemPens.ControlText, bounds.X, bounds.Bottom - 1, bounds.Right - 1, bounds.Bottom - 1);
+                    }
+                    if (clip_rectangle.Contains(new Point(bounds.Right, bounds.Y)))
+                    {
+                        dc.DrawLine(SystemPens.ControlText, bounds.Right - 1, bounds.Y, bounds.Right - 1, bounds.Bottom - 1);
+                    }
+                }
+            }
+        }
+
+        // darws a single part of the month calendar (with one month)
+        private void DrawSingleMonth(Graphics dc, Rectangle clip_rectangle, Rectangle rectangle, MonthCalendar mc, int row, int col)
+        {
+            // cache local copies of Marshal-by-ref internal members (gets around error CS0197)
+            Size title_size = (Size)((object)mc.title_size);
+            Size date_cell_size = (Size)((object)mc.date_cell_size);
+            DateTime current_month = (DateTime)((object)mc.current_month);
+            DateTime sunday = new DateTime(2006, 10, 1);
+
+            // draw the title back ground
+            DateTime this_month = current_month.AddMonths(row * mc.CalendarDimensions.Width + col);
+            Rectangle title_rect = new Rectangle(rectangle.X, rectangle.Y, title_size.Width, title_size.Height);
+            if (title_rect.IntersectsWith(clip_rectangle))
+            {
+                dc.FillRectangle(ResPool.GetSolidBrush(mc.TitleBackColor), title_rect);
+                // draw the title				
+                string title_text = this_month.ToString("MMMM yyyy");
+                dc.DrawString(title_text, mc.bold_font, ResPool.GetSolidBrush(mc.TitleForeColor), title_rect, mc.centered_format);
+
+                if (mc.ShowYearUpDown)
+                {
+                    Rectangle year_rect;
+                    Rectangle upRect, downRect;
+                    ButtonState upState, downState;
+
+                    mc.GetYearNameRectangles(title_rect, row * mc.CalendarDimensions.Width + col, out year_rect, out upRect, out downRect);
+                    dc.FillRectangle(ResPool.GetSolidBrush(SystemColors.Control), year_rect);
+                    dc.DrawString(this_month.ToString("yyyy"), mc.bold_font, ResPool.GetSolidBrush(Color.Black), year_rect, mc.centered_format);
+
+                    upState = mc.IsYearGoingUp ? ButtonState.Pushed : ButtonState.Normal;
+                    downState = mc.IsYearGoingDown ? ButtonState.Pushed : ButtonState.Normal;
+
+                    WidgetPaint.DrawScrollButton(dc, upRect, ScrollButton.Up, upState);
+                    WidgetPaint.DrawScrollButton(dc, downRect, ScrollButton.Down, downState);
+                }
+
+                // draw previous and next buttons if it's time
+                if (row == 0 && col == 0)
+                {
+                    // draw previous button
+                    DrawMonthCalendarButton(
+                        dc,
+                        rectangle,
+                        mc,
+                        title_size,
+                        mc.button_x_offset,
+                        (System.Drawing.Size)((object)mc.button_size),
+                        true);
+                }
+                if (row == 0 && col == mc.CalendarDimensions.Width - 1)
+                {
+                    // draw next button
+                    DrawMonthCalendarButton(
+                        dc,
+                        rectangle,
+                        mc,
+                        title_size,
+                        mc.button_x_offset,
+                        (System.Drawing.Size)((object)mc.button_size),
+                        false);
+                }
+            }
+
+            // set the week offset and draw week nums if needed
+            int col_offset = (mc.ShowWeekNumbers) ? 1 : 0;
+            Rectangle day_name_rect = new Rectangle(
+                rectangle.X,
+                rectangle.Y + title_size.Height,
+                (7 + col_offset) * date_cell_size.Width,
+                date_cell_size.Height);
+            if (day_name_rect.IntersectsWith(clip_rectangle))
+            {
+                dc.FillRectangle(GetControlBackBrush(mc.BackColor), day_name_rect);
+                // draw the day names 
+                DayOfWeek first_day_of_week = mc.GetDayOfWeek(mc.FirstDayOfWeek);
+                for (int i = 0; i < 7; i++)
+                {
+                    int position = i - (int)first_day_of_week;
+                    if (position < 0)
+                    {
+                        position = 7 + position;
+                    }
+                    // draw it
+                    Rectangle day_rect = new Rectangle(
+                        day_name_rect.X + ((i + col_offset) * date_cell_size.Width),
+                        day_name_rect.Y,
+                        date_cell_size.Width,
+                        date_cell_size.Height);
+                    dc.DrawString(sunday.AddDays(i + (int)first_day_of_week).ToString("ddd"), mc.Font, ResPool.GetSolidBrush(mc.TitleBackColor), day_rect, mc.centered_format);
+                }
+
+                // draw the vertical divider
+                int vert_divider_y = Math.Max(title_size.Height + date_cell_size.Height - 1, 0);
+                dc.DrawLine(
+                    ResPool.GetPen(mc.ForeColor),
+                    rectangle.X + (col_offset * date_cell_size.Width) + mc.divider_line_offset,
+                    rectangle.Y + vert_divider_y,
+                    rectangle.Right - mc.divider_line_offset,
+                    rectangle.Y + vert_divider_y);
+            }
+
+
+            // draw the actual date items in the grid (including the week numbers)
+            Rectangle date_rect = new Rectangle(
+                rectangle.X,
+                rectangle.Y + title_size.Height + date_cell_size.Height,
+                date_cell_size.Width,
+                date_cell_size.Height);
+            int month_row_count = 0;
+            bool draw_week_num_divider = false;
+            DateTime current_date = mc.GetFirstDateInMonthGrid(new DateTime(this_month.Year, this_month.Month, 1));
+            for (int i = 0; i < 6; i++)
+            {
+                // establish if this row is in our clip_area
+                Rectangle row_rect = new Rectangle(
+                    rectangle.X,
+                    rectangle.Y + title_size.Height + (date_cell_size.Height * (i + 1)),
+                    date_cell_size.Width * 7,
+                    date_cell_size.Height);
+                if (mc.ShowWeekNumbers)
+                {
+                    row_rect.Width += date_cell_size.Width;
+                }
+
+                bool draw_row = row_rect.IntersectsWith(clip_rectangle);
+                if (draw_row)
+                {
+                    dc.FillRectangle(GetControlBackBrush(mc.BackColor), row_rect);
+                }
+                // establish if this is a valid week to draw
+                if (mc.IsValidWeekToDraw(this_month, current_date, row, col))
+                {
+                    month_row_count = i;
+                }
+
+                // draw the week number if required
+                if (mc.ShowWeekNumbers && month_row_count == i)
+                {
+                    if (!draw_week_num_divider)
+                    {
+                        draw_week_num_divider = draw_row;
+                    }
+                    // get the week for this row
+                    int week = mc.GetWeekOfYear(current_date);
+
+                    if (draw_row)
+                    {
+                        dc.DrawString(
+                            week.ToString(),
+                            mc.Font,
+                            ResPool.GetSolidBrush(mc.TitleBackColor),
+                            date_rect,
+                            mc.centered_format);
+                    }
+                    date_rect.Offset(date_cell_size.Width, 0);
+                }
+
+                // only draw the days if we have to
+                if (month_row_count == i)
+                {
+                    for (int j = 0; j < 7; j++)
+                    {
+                        if (draw_row)
+                        {
+                            DrawMonthCalendarDate(
+                                dc,
+                                date_rect,
+                                mc,
+                                current_date,
+                                this_month,
+                                row,
+                                col);
+                        }
+
+                        // move the day on
+                        current_date = current_date.AddDays(1);
+                        date_rect.Offset(date_cell_size.Width, 0);
+                    }
+
+                    // shift the rectangle down one row
+                    int offset = (mc.ShowWeekNumbers) ? -8 : -7;
+                    date_rect.Offset(offset * date_cell_size.Width, date_cell_size.Height);
+                }
+            }
+
+            // month_row_count is zero based, so add one
+            month_row_count++;
+
+            // draw week numbers if required
+            if (draw_week_num_divider)
+            {
+                col_offset = 1;
+                dc.DrawLine(
+                    ResPool.GetPen(mc.ForeColor),
+                    rectangle.X + date_cell_size.Width - 1,
+                    rectangle.Y + title_size.Height + date_cell_size.Height + mc.divider_line_offset,
+                    rectangle.X + date_cell_size.Width - 1,
+                    rectangle.Y + title_size.Height + date_cell_size.Height + (month_row_count * date_cell_size.Height) - mc.divider_line_offset);
+            }
+        }
+
+        // draws the pervious or next button
+        private void DrawMonthCalendarButton(Graphics dc, Rectangle rectangle, MonthCalendar mc, Size title_size, int x_offset, Size button_size, bool is_previous)
+        {
+            const int arrow_width = 4;
+            const int arrow_height = 7;
+
+            bool is_clicked = false;
+            Rectangle button_rect;
+            PointF arrow_center;
+            PointF[] arrow_path = new PointF[3];
+
+            // prepare the button
+            if (is_previous)
+            {
+                is_clicked = mc.is_previous_clicked;
+
+                button_rect = new Rectangle(
+                    rectangle.X + 1 + x_offset,
+                    rectangle.Y + 1 + ((title_size.Height - button_size.Height) / 2),
+                    Math.Max(button_size.Width - 1, 0),
+                    Math.Max(button_size.Height - 1, 0));
+
+                arrow_center = new PointF(button_rect.X + ((button_rect.Width + arrow_width) / 2.0f),
+                                            rectangle.Y + ((button_rect.Height + arrow_height) / 2) + 1);
+                if (is_clicked)
+                {
+                    arrow_center.X += 1;
+                    arrow_center.Y += 1;
+                }
+
+                arrow_path[0].X = arrow_center.X;
+                arrow_path[0].Y = arrow_center.Y - arrow_height / 2.0f + 0.5f;
+                arrow_path[1].X = arrow_center.X;
+                arrow_path[1].Y = arrow_center.Y + arrow_height / 2.0f + 0.5f;
+                arrow_path[2].X = arrow_center.X - arrow_width;
+                arrow_path[2].Y = arrow_center.Y + 0.5f;
+            }
+            else
+            {
+                is_clicked = mc.is_next_clicked;
+
+                button_rect = new Rectangle(
+                    rectangle.Right - 1 - x_offset - button_size.Width,
+                    rectangle.Y + 1 + ((title_size.Height - button_size.Height) / 2),
+                    Math.Max(button_size.Width - 1, 0),
+                    Math.Max(button_size.Height - 1, 0));
+
+                arrow_center = new PointF(button_rect.X + ((button_rect.Width + arrow_width) / 2.0f),
+                                            rectangle.Y + ((button_rect.Height + arrow_height) / 2) + 1);
+                if (is_clicked)
+                {
+                    arrow_center.X += 1;
+                    arrow_center.Y += 1;
+                }
+
+                arrow_path[0].X = arrow_center.X - arrow_width;
+                arrow_path[0].Y = arrow_center.Y - arrow_height / 2.0f + 0.5f;
+                arrow_path[1].X = arrow_center.X - arrow_width;
+                arrow_path[1].Y = arrow_center.Y + arrow_height / 2.0f + 0.5f;
+                arrow_path[2].X = arrow_center.X;
+                arrow_path[2].Y = arrow_center.Y + 0.5f;
+            }
+
+            // fill the background
+            dc.FillRectangle(SystemBrushes.Control, button_rect);
+            // draw the border
+            if (is_clicked)
+            {
+                dc.DrawRectangle(SystemPens.ControlDark, button_rect);
+            }
+            else
+            {
+                CPDrawBorder3D(dc, button_rect, Border3DStyle.Raised, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom);
+            }
+            // draw the arrow
+            dc.FillPolygon(SystemBrushes.ControlText, arrow_path);
+            //dc.FillPolygon (SystemBrushes.ControlText, arrow_path, FillMode.Winding);
+        }
+
+
+        // draws one day in the calendar grid
+        private void DrawMonthCalendarDate(Graphics dc, Rectangle rectangle, MonthCalendar mc, DateTime date, DateTime month, int row, int col)
+        {
+            Color date_color = mc.ForeColor;
+            Rectangle interior = new Rectangle(rectangle.X, rectangle.Y, Math.Max(rectangle.Width - 1, 0), Math.Max(rectangle.Height - 1, 0));
+
+            // find out if we are the lead of the first calendar or the trail of the last calendar						
+            if (date.Year != month.Year || date.Month != month.Month)
+            {
+                DateTime check_date = month.AddMonths(-1);
+                // check if it's the month before 
+                if (check_date.Year == date.Year && check_date.Month == date.Month && row == 0 && col == 0)
+                {
+                    date_color = mc.TrailingForeColor;
+                }
+                else
+                {
+                    // check if it's the month after
+                    check_date = month.AddMonths(1);
+                    if (check_date.Year == date.Year && check_date.Month == date.Month && row == mc.CalendarDimensions.Height - 1 && col == mc.CalendarDimensions.Width - 1)
+                    {
+                        date_color = mc.TrailingForeColor;
+                    }
+                    else
+                    {
+                        return;
+                    }
+                }
+            }
+            else
+            {
+                date_color = mc.ForeColor;
+            }
+
+            const int inflate = -1;
+
+            if (date == mc.SelectionStart.Date && date == mc.SelectionEnd.Date)
+            {
+                // see if the date is in the start of selection
+                date_color = mc.BackColor;
+                // draw the left hand of the back ground
+                Rectangle selection_rect = Rectangle.Inflate(rectangle, inflate, inflate);
+                dc.FillPie(ResPool.GetSolidBrush(mc.TitleBackColor), selection_rect, 0, 360);
+            }
+            else if (date == mc.SelectionStart.Date)
+            {
+                // see if the date is in the start of selection
+                date_color = mc.BackColor;
+                // draw the left hand of the back ground
+                Rectangle selection_rect = Rectangle.Inflate(rectangle, inflate, inflate);
+                dc.FillPie(ResPool.GetSolidBrush(mc.TitleBackColor), selection_rect, 90, 180);
+                // fill the other side as a straight rect
+                if (date < mc.SelectionEnd.Date)
+                {
+                    // use rectangle instead of rectangle to go all the way to edge of rect
+                    selection_rect.X = (int)Math.Floor((double)(rectangle.X + rectangle.Width / 2));
+                    selection_rect.Width = Math.Max(rectangle.Right - selection_rect.X, 0);
+                    dc.FillRectangle(ResPool.GetSolidBrush(mc.TitleBackColor), selection_rect);
+                }
+            }
+            else if (date == mc.SelectionEnd.Date)
+            {
+                // see if it is the end of selection
+                date_color = mc.BackColor;
+                // draw the left hand of the back ground
+                Rectangle selection_rect = Rectangle.Inflate(rectangle, inflate, inflate);
+                dc.FillPie(ResPool.GetSolidBrush(mc.TitleBackColor), selection_rect, 270, 180);
+                // fill the other side as a straight rect
+                if (date > mc.SelectionStart.Date)
+                {
+                    selection_rect.X = rectangle.X;
+                    selection_rect.Width = rectangle.Width - (rectangle.Width / 2);
+                    dc.FillRectangle(ResPool.GetSolidBrush(mc.TitleBackColor), selection_rect);
+                }
+            }
+            else if (date > mc.SelectionStart.Date && date < mc.SelectionEnd.Date)
+            {
+                // now see if it's in the middle
+                date_color = mc.BackColor;
+                // draw the left hand of the back ground
+                Rectangle selection_rect = Rectangle.Inflate(rectangle, 0, inflate);
+                dc.FillRectangle(ResPool.GetSolidBrush(mc.TitleBackColor), selection_rect);
+            }
+
+            // establish if it's a bolded font
+            Font font = mc.IsBoldedDate(date) ? mc.bold_font : mc.Font;
+
+            // just draw the date now
+            dc.DrawString(date.Day.ToString(), font, ResPool.GetSolidBrush(date_color), rectangle, mc.centered_format);
+
+            // today circle if needed
+            if (mc.ShowTodayCircle && date == DateTime.Now.Date)
+            {
+                DrawTodayCircle(dc, interior);
+            }
+
+            // draw the selection grid
+            if (mc.is_date_clicked && mc.clicked_date == date)
+            {
+                Pen pen = ResPool.GetDashPen(Color.Black, DashStyle.Dot);
+                dc.DrawRectangle(pen, interior);
+            }
+        }
+
+        private void DrawTodayCircle(Graphics dc, Rectangle rectangle)
+        {
+            Color circle_color = Color.FromArgb(248, 0, 0);
+            // draw the left hand of the circle 
+            Rectangle lhs_circle_rect = new Rectangle(rectangle.X + 1, rectangle.Y + 4, Math.Max(rectangle.Width - 2, 0), Math.Max(rectangle.Height - 5, 0));
+            Rectangle rhs_circle_rect = new Rectangle(rectangle.X + 1, rectangle.Y + 1, Math.Max(rectangle.Width - 2, 0), Math.Max(rectangle.Height - 2, 0));
+            Point[] curve_points = new Point[3];
+            curve_points[0] = new Point(lhs_circle_rect.X, rhs_circle_rect.Y + rhs_circle_rect.Height / 12);
+            curve_points[1] = new Point(lhs_circle_rect.X + lhs_circle_rect.Width / 9, rhs_circle_rect.Y);
+            curve_points[2] = new Point(lhs_circle_rect.X + lhs_circle_rect.Width / 2 + 1, rhs_circle_rect.Y);
+
+            Pen pen = ResPool.GetSizedPen(circle_color, 2);
+            dc.DrawArc(pen, lhs_circle_rect, 90, 180);
+            dc.DrawArc(pen, rhs_circle_rect, 270, 180);
+            dc.DrawCurve(pen, curve_points);
+            dc.DrawLine(ResPool.GetPen(circle_color), curve_points[2], new Point(curve_points[2].X, lhs_circle_rect.Y));
+        }
+
+        #endregion     // MonthCalendar
+
+        #region Panel
+        public override Size PanelDefaultSize
+        {
+            get
+            {
+                return new Size(200, 100);
+            }
+        }
+        #endregion // Panel
+
+        #region PictureBox
+        public override void DrawPictureBox(Graphics dc, Rectangle clip, PictureBox pb)
+        {
+            Rectangle client = pb.ClientRectangle;
+
+            client = new Rectangle(client.Left + pb.Padding.Left, client.Top + pb.Padding.Top, client.Width - pb.Padding.Horizontal, client.Height - pb.Padding.Vertical);
+
+            // FIXME - instead of drawing the whole picturebox every time
+            // intersect the clip rectangle with the drawn picture and only draw what's needed,
+            // Also, we only need a background fill where no image goes
+            if (pb.Image != null)
+            {
+                switch (pb.SizeMode)
+                {
+                    case PictureBoxSizeMode.StretchImage:
+                        dc.DrawImage(pb.Image, client.Left, client.Top, client.Width, client.Height);
+                        break;
+
+                    case PictureBoxSizeMode.CenterImage:
+                        dc.DrawImage(pb.Image, (client.Width / 2) - (pb.Image.Width / 2), (client.Height / 2) - (pb.Image.Height / 2));
+                        break;
+
+                    case PictureBoxSizeMode.Zoom:
+                        Size image_size;
+
+                        if (((float)pb.Image.Width / (float)pb.Image.Height) >= ((float)client.Width / (float)client.Height))
+                            image_size = new Size(client.Width, (pb.Image.Height * client.Width) / pb.Image.Width);
+                        else
+                            image_size = new Size((pb.Image.Width * client.Height) / pb.Image.Height, client.Height);
+
+                        dc.DrawImage(pb.Image, (client.Width / 2) - (image_size.Width / 2), (client.Height / 2) - (image_size.Height / 2), image_size.Width, image_size.Height);
+                        break;
+
+                    default:
+                        // Normal, AutoSize
+                        dc.DrawImage(pb.Image, client.Left, client.Top, pb.Image.Width, pb.Image.Height);
+                        break;
+                }
+
+                return;
+            }
+        }
+
+        public override Size PictureBoxDefaultSize
+        {
+            get
+            {
+                return new Size(100, 50);
+            }
+        }
+        #endregion // PictureBox
+
+        /*
+		#region PrintPreviewControl
+		public override int PrintPreviewControlPadding {
+			get { return 8; }
+		}
+
+		public override Size PrintPreviewControlGetPageSize (PrintPreviewControl preview)
+		{
+			int page_width, page_height;
+			int padding = PrintPreviewControlPadding;
+			PreviewPageInfo[] pis = preview.page_infos;
+
+			if (preview.AutoZoom) {
+				int height_available = preview.ClientRectangle.Height - (preview.Rows) * padding - 2 * padding;
+				int width_available = preview.ClientRectangle.Width - (preview.Columns - 1) * padding - 2 * padding;
+
+				float image_ratio = (float)pis[0].Image.Width / pis[0].Image.Height;
+
+				/* try to lay things out using the width to determine the size
+				page_width = width_available / preview.Columns;
+				page_height = (int)(page_width / image_ratio);
+
+				/* does the height fit?
+				if (page_height * (preview.Rows + 1) > height_available) {
+					/* no, lay things out via the height
+					page_height = height_available / (preview.Rows + 1);
+					page_width = (int)(page_height * image_ratio);
+				}
+			}
+			else {
+				page_width = (int)(pis[0].Image.Width * preview.Zoom);
+				page_height = (int)(pis[0].Image.Height * preview.Zoom);
+			}
+
+			return new Size (page_width, page_height);
+		}
+
+		public override void PrintPreviewWidgetPaint (PaintEventArgs pe, PrintPreviewControl preview, Size page_size)
+		{
+			int padding = 8;
+			PreviewPageInfo[] pis = preview.page_infos;
+			if (pis == null)
+				return;
+
+			int page_x, page_y;
+
+			int width = page_size.Width * preview.Columns + padding * (preview.Columns - 1) + 2 * padding;
+			int height = page_size.Height * (preview.Rows + 1) + padding * preview.Rows + 2 * padding;
+
+			Rectangle viewport = preview.ViewPort;
+
+			pe.Graphics.Clip = new Region (viewport);
+
+			/* center things if we can
+			int off_x = viewport.Width / 2 - width / 2;
+			if (off_x < 0) off_x = 0;
+			int off_y = viewport.Height / 2 - height / 2;
+			if (off_y < 0) off_y = 0;
+
+			page_y = off_y + padding - preview.vbar_value;
+
+			if (preview.StartPage > 0) {
+				int p = preview.StartPage - 1;
+				for (int py = 0; py < preview.Rows + 1; py ++) {
+					page_x = off_x + padding - preview.hbar_value;
+					for (int px = 0; px < preview.Columns; px ++) {
+						if (p >= pis.Length)
+							continue;
+						Image image = preview.image_cache[p];
+						if (image == null)
+							image = pis[p].Image;
+						Rectangle dest = new Rectangle (new Point (page_x, page_y), page_size);
+
+						pe.Graphics.DrawImage (image, dest, 0, 0, image.Width, image.Height, GraphicsUnit.Pixel);
+
+						page_x += padding + page_size.Width;
+						p++;
+					}
+					page_y += padding + page_size.Height;
+				}
+			}
+		}
+		#endregion      // PrintPreviewControl*/
+
+        #region ProgressBar
+        public override void DrawProgressBar(Graphics dc, Rectangle clip_rect, ProgressBar ctrl)
+        {
+            Rectangle client_area = ctrl.client_area;
+
+            /* Draw border */
+            CPDrawBorder3D(dc, ctrl.ClientRectangle, Border3DStyle.SunkenOuter, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom & ~Border3DSide.Middle, ColorControl);
+
+            /* Draw Blocks */
+            int draw_mode = 0;
+            int max_blocks = int.MaxValue;
+            int start_pixel = client_area.X;
+            draw_mode = (int)ctrl.Style;
+
+            switch (draw_mode)
+            {
+                case 1:
+                    { // Continuous
+                        int pixels_to_draw;
+                        pixels_to_draw = (int)(client_area.Width * ((double)(ctrl.Value - ctrl.Minimum) / (double)(Math.Max(ctrl.Maximum - ctrl.Minimum, 1))));
+                        dc.FillRectangle(new SolidBrush(Application.CurrentSkin.ProgressBar_BackgroundColor), new Rectangle(client_area.X, client_area.Y, pixels_to_draw, client_area.Height));
+                        break;
+                    }
+                case 2: // Marquee
+                    if (XplatUI.ThemesEnabled)
+                    {
+                        int ms_diff = (int)(DateTime.Now - ctrl.start).TotalMilliseconds;
+                        double percent_done = (double)ms_diff / ProgressBarMarqueeSpeedScaling
+                            % (double)ctrl.MarqueeAnimationSpeed / (double)ctrl.MarqueeAnimationSpeed;
+                        max_blocks = 5;
+                        start_pixel = client_area.X + (int)(client_area.Width * percent_done);
+                    }
+
+                    goto case 0;
+                case 0:
+                default:  // Blocks
+                    Rectangle block_rect;
+                    int space_betweenblocks = ProgressBarChunkSpacing;
+                    int block_width;
+                    int increment;
+                    int barpos_pixels;
+                    int block_count = 0;
+
+                    block_width = ProgressBarGetChunkSize(client_area.Height);
+                    block_width = Math.Max(block_width, 0); // block_width is used to break out the loop below, it must be >= 0!
+                    barpos_pixels = (int)(((double)(ctrl.Value - ctrl.Minimum) * client_area.Width) / (Math.Max(ctrl.Maximum - ctrl.Minimum, 1)));
+                    increment = block_width + space_betweenblocks;
+
+                    block_rect = new Rectangle(start_pixel, client_area.Y, block_width, client_area.Height);
+                    while (true)
+                    {
+                        if (max_blocks != int.MaxValue)
+                        {
+                            if (block_count >= max_blocks)
+                                break;
+                            if (block_rect.X > client_area.Width)
+                                block_rect.X -= client_area.Width;
+                        }
+                        else
+                        {
+                            if ((block_rect.X - client_area.X) >= barpos_pixels)
+                                break;
+                        }
+
+                        if (clip_rect.IntersectsWith(block_rect) == true)
+                        {
+                            dc.FillRectangle(new SolidBrush(Application.CurrentSkin.ProgressBar_BlockColor), block_rect);
+                        }
+
+                        block_rect.X += increment;
+                        block_count++;
+                    }
+                    break;
+
+            }
+        }
+
+        public const int ProgressBarChunkSpacing = 2;
+
+        public static int ProgressBarGetChunkSize()
+        {
+            return ProgressBarGetChunkSize(ProgressBarDefaultHeight);
+        }
+
+        static int ProgressBarGetChunkSize(int progressBarClientAreaHeight)
+        {
+            int size = (progressBarClientAreaHeight * 2) / 3;
+            return size;
+        }
+
+        const int ProgressBarDefaultHeight = 23;
+
+        public override Size ProgressBarDefaultSize
+        {
+            get
+            {
+                return new Size(100, ProgressBarDefaultHeight);
+            }
+        }
+
+        public const double ProgressBarMarqueeSpeedScaling = 15;
+
+        #endregion  // ProgressBar
+
+        #region RadioButton
+        public override void DrawRadioButton(Graphics dc, Rectangle clip_rectangle, RadioButton radio_button)
+        {
+            StringFormat text_format;
+            Rectangle client_rectangle;
+            Rectangle text_rectangle;
+            Rectangle radiobutton_rectangle;
+            int radiobutton_size = 13;
+            int radiobutton_space = 4;
+
+            client_rectangle = radio_button.ClientRectangle;
+            text_rectangle = client_rectangle;
+            radiobutton_rectangle = new Rectangle(text_rectangle.X, text_rectangle.Y, radiobutton_size, radiobutton_size);
+
+            text_format = new StringFormat();
+            text_format.Alignment = StringAlignment.Near;
+            text_format.LineAlignment = StringAlignment.Center;
+            text_format.HotkeyPrefix = HotkeyPrefix.Show;
+
+            /* Calculate the position of text and checkbox rectangle */
+            if (radio_button.appearance != Appearance.Button)
+            {
+                switch (radio_button.radiobutton_alignment)
+                {
+                    case ContentAlignment.BottomCenter:
+                        {
+                            radiobutton_rectangle.X = (client_rectangle.Right - client_rectangle.Left) / 2 - radiobutton_size / 2;
+                            radiobutton_rectangle.Y = client_rectangle.Bottom - radiobutton_size;
+                            text_rectangle.X = client_rectangle.X;
+                            text_rectangle.Width = client_rectangle.Width;
+                            text_rectangle.Height = client_rectangle.Height - radiobutton_size - radiobutton_space;
+                            break;
+                        }
+
+                    case ContentAlignment.BottomLeft:
+                        {
+                            radiobutton_rectangle.X = client_rectangle.Left;
+                            radiobutton_rectangle.Y = client_rectangle.Bottom - radiobutton_size;
+                            text_rectangle.X = client_rectangle.X + radiobutton_size + radiobutton_space;
+                            text_rectangle.Width = client_rectangle.Width - radiobutton_size - radiobutton_space;
+                            break;
+                        }
+
+                    case ContentAlignment.BottomRight:
+                        {
+                            radiobutton_rectangle.X = client_rectangle.Right - radiobutton_size;
+                            radiobutton_rectangle.Y = client_rectangle.Bottom - radiobutton_size;
+                            text_rectangle.X = client_rectangle.X;
+                            text_rectangle.Width = client_rectangle.Width - radiobutton_size - radiobutton_space;
+                            break;
+                        }
+
+                    case ContentAlignment.MiddleCenter:
+                        {
+                            radiobutton_rectangle.X = (client_rectangle.Right - client_rectangle.Left) / 2 - radiobutton_size / 2;
+                            radiobutton_rectangle.Y = (client_rectangle.Bottom - client_rectangle.Top) / 2 - radiobutton_size / 2;
+                            text_rectangle.X = client_rectangle.X;
+                            text_rectangle.Width = client_rectangle.Width;
+                            break;
+                        }
+
+                    default:
+                    case ContentAlignment.MiddleLeft:
+                        {
+                            radiobutton_rectangle.X = client_rectangle.Left;
+                            radiobutton_rectangle.Y = (client_rectangle.Bottom - client_rectangle.Top) / 2 - radiobutton_size / 2;
+                            text_rectangle.X = client_rectangle.X + radiobutton_size + radiobutton_space;
+                            text_rectangle.Width = client_rectangle.Width - radiobutton_size - radiobutton_space;
+                            break;
+                        }
+
+                    case ContentAlignment.MiddleRight:
+                        {
+                            radiobutton_rectangle.X = client_rectangle.Right - radiobutton_size;
+                            radiobutton_rectangle.Y = (client_rectangle.Bottom - client_rectangle.Top) / 2 - radiobutton_size / 2;
+                            text_rectangle.X = client_rectangle.X;
+                            text_rectangle.Width = client_rectangle.Width - radiobutton_size - radiobutton_space;
+                            break;
+                        }
+
+                    case ContentAlignment.TopCenter:
+                        {
+                            radiobutton_rectangle.X = (client_rectangle.Right - client_rectangle.Left) / 2 - radiobutton_size / 2;
+                            radiobutton_rectangle.Y = client_rectangle.Top;
+                            text_rectangle.X = client_rectangle.X;
+                            text_rectangle.Y = radiobutton_size + radiobutton_space;
+                            text_rectangle.Width = client_rectangle.Width;
+                            text_rectangle.Height = client_rectangle.Height - radiobutton_size - radiobutton_space;
+                            break;
+                        }
+
+                    case ContentAlignment.TopLeft:
+                        {
+                            radiobutton_rectangle.X = client_rectangle.Left;
+                            radiobutton_rectangle.Y = client_rectangle.Top;
+                            text_rectangle.X = client_rectangle.X + radiobutton_size + radiobutton_space;
+                            text_rectangle.Width = client_rectangle.Width - radiobutton_size - radiobutton_space;
+                            break;
+                        }
+
+                    case ContentAlignment.TopRight:
+                        {
+                            radiobutton_rectangle.X = client_rectangle.Right - radiobutton_size;
+                            radiobutton_rectangle.Y = client_rectangle.Top;
+                            text_rectangle.X = client_rectangle.X;
+                            text_rectangle.Width = client_rectangle.Width - radiobutton_size - radiobutton_space;
+                            break;
+                        }
+                }
+            }
+            else
+            {
+                text_rectangle.X = client_rectangle.X;
+                text_rectangle.Width = client_rectangle.Width;
+            }
+
+            /* Set the horizontal alignment of our text */
+            switch (radio_button.text_alignment)
+            {
+                case ContentAlignment.BottomLeft:
+                case ContentAlignment.MiddleLeft:
+                case ContentAlignment.TopLeft:
+                    {
+                        text_format.Alignment = StringAlignment.Near;
+                        break;
+                    }
+
+                case ContentAlignment.BottomCenter:
+                case ContentAlignment.MiddleCenter:
+                case ContentAlignment.TopCenter:
+                    {
+                        text_format.Alignment = StringAlignment.Center;
+                        break;
+                    }
+
+                case ContentAlignment.BottomRight:
+                case ContentAlignment.MiddleRight:
+                case ContentAlignment.TopRight:
+                    {
+                        text_format.Alignment = StringAlignment.Far;
+                        break;
+                    }
+            }
+
+            /* Set the vertical alignment of our text */
+            switch (radio_button.text_alignment)
+            {
+                case ContentAlignment.TopLeft:
+                case ContentAlignment.TopCenter:
+                case ContentAlignment.TopRight:
+                    {
+                        text_format.LineAlignment = StringAlignment.Near;
+                        break;
+                    }
+
+                case ContentAlignment.BottomLeft:
+                case ContentAlignment.BottomCenter:
+                case ContentAlignment.BottomRight:
+                    {
+                        text_format.LineAlignment = StringAlignment.Far;
+                        break;
+                    }
+
+                case ContentAlignment.MiddleLeft:
+                case ContentAlignment.MiddleCenter:
+                case ContentAlignment.MiddleRight:
+                    {
+                        text_format.LineAlignment = StringAlignment.Center;
+                        break;
+                    }
+            }
+
+            ButtonState state = ButtonState.Normal;
+            if (radio_button.FlatStyle == FlatStyle.Flat)
+            {
+                state |= ButtonState.Flat;
+            }
+
+            if (radio_button.Checked)
+            {
+                state |= ButtonState.Checked;
+            }
+
+            if (!radio_button.Enabled)
+            {
+                state |= ButtonState.Inactive;
+            }
+
+            // Start drawing
+            RadioButton_DrawButton(radio_button, dc, state, radiobutton_rectangle);
+
+            if ((radio_button.image != null) || (radio_button.image_list != null))
+                ButtonBase_DrawImage(radio_button, dc);
+
+            RadioButton_DrawText(radio_button, text_rectangle, dc, text_format);
+
+            if (radio_button.Focused && radio_button.Enabled && radio_button.appearance != Appearance.Button && radio_button.Text != String.Empty && radio_button.ShowFocusCues)
+            {
+                SizeF text_size = dc.MeasureString(radio_button.Text, radio_button.Font);
+
+                Rectangle focus_rect = Rectangle.Empty;
+                focus_rect.X = text_rectangle.X;
+                focus_rect.Y = (int)((text_rectangle.Height - text_size.Height) / 2);
+                focus_rect.Size = text_size.ToSize();
+
+                RadioButton_DrawFocus(radio_button, dc, focus_rect);
+            }
+
+            text_format.Dispose();
+        }
+
+        protected virtual void RadioButton_DrawButton(RadioButton radio_button, Graphics dc, ButtonState state, Rectangle radiobutton_rectangle)
+        {
+            dc.FillRectangle(GetControlBackBrush(radio_button.BackColor), radio_button.ClientRectangle);
+
+            if (radio_button.appearance == Appearance.Button)
+            {
+                ButtonBase_DrawButton(radio_button, dc);
+
+                if ((radio_button.Focused) && radio_button.Enabled)
+                    ButtonBase_DrawFocus(radio_button, dc);
+            }
+            else
+            {
+                // establish if we are rendering a flat style of some sort
+                if (radio_button.FlatStyle == FlatStyle.Flat || radio_button.FlatStyle == FlatStyle.Popup)
+                {
+                    DrawFlatStyleRadioButton(dc, radiobutton_rectangle, radio_button);
+                }
+                else
+                {
+                    CPDrawRadioButton(dc, radiobutton_rectangle, state);
+                }
+            }
+        }
+
+        protected virtual void RadioButton_DrawText(RadioButton radio_button, Rectangle text_rectangle, Graphics dc, StringFormat text_format)
+        {
+            DrawCheckBox_and_RadioButtonText(radio_button, text_rectangle, dc,
+                              text_format, radio_button.Appearance, radio_button.Checked);
+        }
+
+        protected virtual void RadioButton_DrawFocus(RadioButton radio_button, Graphics dc, Rectangle text_rectangle)
+        {
+            DrawInnerFocusRectangle(dc, text_rectangle, radio_button.BackColor);
+        }
+
+
+        // renders a radio button with the Flat and Popup FlatStyle
+        protected virtual void DrawFlatStyleRadioButton(Graphics graphics, Rectangle rectangle, RadioButton radio_button)
+        {
+            int lineWidth;
+
+            if (radio_button.Enabled)
+            {
+
+                // draw the outer flatstyle arcs
+                if (radio_button.FlatStyle == FlatStyle.Flat)
+                {
+                    graphics.DrawArc(SystemPens.ControlDarkDark, rectangle, 0, 359);
+
+                    // fill in the area depending on whether or not the mouse is hovering
+                    if ((radio_button.is_entered || radio_button.Capture) && !radio_button.is_pressed)
+                    {
+                        graphics.FillPie(SystemBrushes.ControlLight, rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2, 0, 359);
+                    }
+                    else
+                    {
+                        graphics.FillPie(SystemBrushes.ControlLightLight, rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2, 0, 359);
+                    }
+                }
+                else
+                {
+                    // must be a popup radio button
+                    // fill the control
+                    graphics.FillPie(SystemBrushes.ControlLightLight, rectangle, 0, 359);
+
+                    if (radio_button.is_entered || radio_button.Capture)
+                    {
+                        // draw the popup 3d button knob
+                        graphics.DrawArc(SystemPens.ControlLight, rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2, 0, 359);
+
+                        graphics.DrawArc(SystemPens.ControlDark, rectangle, 135, 180);
+                        graphics.DrawArc(SystemPens.ControlLightLight, rectangle, 315, 180);
+
+                    }
+                    else
+                    {
+                        // just draw lighter flatstyle outer circle
+                        graphics.DrawArc(SystemPens.ControlDark, rectangle, 0, 359);
+                    }
+                }
+            }
+            else
+            {
+                // disabled
+                // fill control background color regardless of actual backcolor
+                graphics.FillPie(SystemBrushes.Control, rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2, 0, 359);
+                // draw the ark as control dark
+                graphics.DrawArc(SystemPens.ControlDark, rectangle, 0, 359);
+            }
+
+            // draw the check
+            if (radio_button.Checked)
+            {
+                lineWidth = Math.Max(1, Math.Min(rectangle.Width, rectangle.Height) / 3);
+
+                Pen dot_pen = SystemPens.ControlDarkDark;
+                Brush dot_brush = SystemBrushes.ControlDarkDark;
+
+                if (!radio_button.Enabled || ((radio_button.FlatStyle == FlatStyle.Popup) && radio_button.is_pressed))
+                {
+                    dot_pen = SystemPens.ControlDark;
+                    dot_brush = SystemBrushes.ControlDark;
+                }
+
+                if (rectangle.Height > 13)
+                {
+                    graphics.FillPie(dot_brush, rectangle.X + lineWidth, rectangle.Y + lineWidth, rectangle.Width - lineWidth * 2, rectangle.Height - lineWidth * 2, 0, 359);
+                }
+                else
+                {
+                    int x_half_pos = (rectangle.Width / 2) + rectangle.X;
+                    int y_half_pos = (rectangle.Height / 2) + rectangle.Y;
+
+                    graphics.DrawLine(dot_pen, x_half_pos - 1, y_half_pos, x_half_pos + 2, y_half_pos);
+                    graphics.DrawLine(dot_pen, x_half_pos - 1, y_half_pos + 1, x_half_pos + 2, y_half_pos + 1);
+
+                    graphics.DrawLine(dot_pen, x_half_pos, y_half_pos - 1, x_half_pos, y_half_pos + 2);
+                    graphics.DrawLine(dot_pen, x_half_pos + 1, y_half_pos - 1, x_half_pos + 1, y_half_pos + 2);
+                }
+            }
+        }
+
+        public override Size RadioButtonDefaultSize
+        {
+            get
+            {
+                return new Size(104, 24);
+            }
+        }
+
+        public override void DrawRadioButton(Graphics g, RadioButton rb, Rectangle glyphArea, Rectangle textBounds, Rectangle imageBounds, Rectangle clipRectangle)
+        {
+            // Draw Button Background
+            if (rb.FlatStyle == FlatStyle.Flat || rb.FlatStyle == FlatStyle.Popup)
+            {
+                glyphArea.Height -= 2;
+                glyphArea.Width -= 2;
+            }
+
+            DrawRadioButtonGlyph(g, rb, glyphArea);
+
+            // If we have an image, draw it
+            if (imageBounds.Size != Size.Empty)
+                DrawRadioButtonImage(g, rb, imageBounds);
+
+            if (rb.Focused && rb.Enabled && rb.ShowFocusCues && textBounds.Size != Size.Empty)
+                DrawRadioButtonFocus(g, rb, textBounds);
+
+            // If we have text, draw it
+            if (textBounds != Rectangle.Empty)
+                DrawRadioButtonText(g, rb, textBounds);
+        }
+
+        public virtual void DrawRadioButtonGlyph(Graphics g, RadioButton rb, Rectangle glyphArea)
+        {
+            if (rb.Pressed)
+                MemphisThemeElements.CurrentTheme.RadioButtonPainter.PaintRadioButton(g, glyphArea, rb.BackColor, rb.ForeColor, ElementState.Pressed, rb.FlatStyle, rb.Checked);
+            else if (rb.InternalSelected)
+                MemphisThemeElements.CurrentTheme.RadioButtonPainter.PaintRadioButton(g, glyphArea, rb.BackColor, rb.ForeColor, ElementState.Normal, rb.FlatStyle, rb.Checked);
+            else if (rb.Entered)
+                MemphisThemeElements.CurrentTheme.RadioButtonPainter.PaintRadioButton(g, glyphArea, rb.BackColor, rb.ForeColor, ElementState.Hot, rb.FlatStyle, rb.Checked);
+            else if (!rb.Enabled)
+                MemphisThemeElements.CurrentTheme.RadioButtonPainter.PaintRadioButton(g, glyphArea, rb.BackColor, rb.ForeColor, ElementState.Disabled, rb.FlatStyle, rb.Checked);
+            else
+                MemphisThemeElements.CurrentTheme.RadioButtonPainter.PaintRadioButton(g, glyphArea, rb.BackColor, rb.ForeColor, ElementState.Normal, rb.FlatStyle, rb.Checked);
+        }
+
+        public virtual void DrawRadioButtonFocus(Graphics g, RadioButton rb, Rectangle focusArea)
+        {
+            WidgetPaint.DrawFocusRectangle(g, focusArea);
+        }
+
+        public virtual void DrawRadioButtonImage(Graphics g, RadioButton rb, Rectangle imageBounds)
+        {
+            if (rb.Enabled)
+                g.DrawImage(rb.Image, imageBounds);
+            else
+                CPDrawImageDisabled(g, rb.Image, imageBounds.Left, imageBounds.Top, ColorControl);
+        }
+
+        public virtual void DrawRadioButtonText(Graphics g, RadioButton rb, Rectangle textBounds)
+        {
+            if (rb.Enabled)
+                TextRenderer.DrawTextInternal(g, rb.Text, rb.Font, textBounds, rb.ForeColor, rb.TextFormatFlags, rb.UseCompatibleTextRendering);
+            else
+                DrawStringDisabled20(g, rb.Text, rb.Font, textBounds, rb.BackColor, rb.TextFormatFlags, rb.UseCompatibleTextRendering);
+        }
+
+        public override Size CalculateRadioButtonAutoSize(RadioButton rb)
+        {
+            Size ret_size = Size.Empty;
+            Size text_size = TextRenderer.MeasureTextInternal(rb.Text, rb.Font, rb.UseCompatibleTextRendering);
+            Size image_size = rb.Image == null ? Size.Empty : rb.Image.Size;
+
+            // Pad the text size
+            if (rb.Text.Length != 0)
+            {
+                text_size.Height += 4;
+                text_size.Width += 4;
+            }
+
+            switch (rb.TextImageRelation)
+            {
+                case TextImageRelation.Overlay:
+                    ret_size.Height = Math.Max(rb.Text.Length == 0 ? 0 : text_size.Height, image_size.Height);
+                    ret_size.Width = Math.Max(text_size.Width, image_size.Width);
+                    break;
+                case TextImageRelation.ImageAboveText:
+                case TextImageRelation.TextAboveImage:
+                    ret_size.Height = text_size.Height + image_size.Height;
+                    ret_size.Width = Math.Max(text_size.Width, image_size.Width);
+                    break;
+                case TextImageRelation.ImageBeforeText:
+                case TextImageRelation.TextBeforeImage:
+                    ret_size.Height = Math.Max(text_size.Height, image_size.Height);
+                    ret_size.Width = text_size.Width + image_size.Width;
+                    break;
+            }
+
+            // Pad the result
+            ret_size.Height += (rb.Padding.Vertical);
+            ret_size.Width += (rb.Padding.Horizontal) + 15;
+
+            // There seems to be a minimum height
+            if (ret_size.Height == rb.Padding.Vertical)
+                ret_size.Height += 14;
+
+            return ret_size;
+        }
+
+        public override void CalculateRadioButtonTextAndImageLayout(ButtonBase b, Point offset, out Rectangle glyphArea, out Rectangle textRectangle, out Rectangle imageRectangle)
+        {
+            CalculateCheckBoxTextAndImageLayout(b, offset, out glyphArea, out textRectangle, out imageRectangle);
+        }
+        #endregion // RadioButton
+
+        #region ScrollBar
+        public override void DrawScrollBar(Graphics dc, Rectangle clip, ScrollBar bar)
+        {
+            int scrollbutton_width = bar.scrollbutton_width;
+            int scrollbutton_height = bar.scrollbutton_height;
+            Rectangle first_arrow_area;
+            Rectangle second_arrow_area;
+            Rectangle thumb_pos;
+
+            thumb_pos = bar.ThumbPos;
+
+            if (bar.vert)
+            {
+                first_arrow_area = new Rectangle(0, 0, bar.Width, scrollbutton_height);
+                bar.FirstArrowArea = first_arrow_area;
+
+                second_arrow_area = new Rectangle(0, bar.ClientRectangle.Height - scrollbutton_height, bar.Width, scrollbutton_height);
+                bar.SecondArrowArea = second_arrow_area;
+
+                thumb_pos.Width = bar.Width;
+                bar.ThumbPos = thumb_pos;
+
+                Brush VerticalBrush;
+                /* Background, upper track */
+                if (bar.thumb_moving == ScrollBar.ThumbMoving.Backwards)
+                    VerticalBrush = ResPool.GetHatchBrush(HatchStyle.Percent50, Color.FromArgb(255, 63, 63, 63), Color.Black);
+                else
+                    VerticalBrush = ResPool.GetHatchBrush(HatchStyle.Percent50, ColorScrollBar, Color.White);
+                Rectangle UpperTrack = new Rectangle(0, 0, bar.ClientRectangle.Width, bar.ThumbPos.Bottom);
+                if (clip.IntersectsWith(UpperTrack))
+                    dc.FillRectangle(VerticalBrush, UpperTrack);
+
+                /* Background, lower track */
+                if (bar.thumb_moving == ScrollBar.ThumbMoving.Forward)
+                    VerticalBrush = ResPool.GetHatchBrush(HatchStyle.Percent50, Color.FromArgb(255, 63, 63, 63), Color.Black);
+                else
+                    VerticalBrush = ResPool.GetHatchBrush(HatchStyle.Percent50, ColorScrollBar, Color.White);
+                Rectangle LowerTrack = new Rectangle(0, bar.ThumbPos.Bottom, bar.ClientRectangle.Width, bar.ClientRectangle.Height - bar.ThumbPos.Bottom);
+                if (clip.IntersectsWith(LowerTrack))
+                    dc.FillRectangle(VerticalBrush, LowerTrack);
+
+                /* Buttons */
+                if (clip.IntersectsWith(first_arrow_area))
+                    CPDrawScrollButton(dc, first_arrow_area, ScrollButton.Up, bar.firstbutton_state);
+                if (clip.IntersectsWith(second_arrow_area))
+                    CPDrawScrollButton(dc, second_arrow_area, ScrollButton.Down, bar.secondbutton_state);
+            }
+            else
+            {
+                first_arrow_area = new Rectangle(0, 0, scrollbutton_width, bar.Height);
+                bar.FirstArrowArea = first_arrow_area;
+
+                second_arrow_area = new Rectangle(bar.ClientRectangle.Width - scrollbutton_width, 0, scrollbutton_width, bar.Height);
+                bar.SecondArrowArea = second_arrow_area;
+
+                thumb_pos.Height = bar.Height;
+                bar.ThumbPos = thumb_pos;
+
+                Brush HorizontalBrush;
+                //Background, left track
+                if (bar.thumb_moving == ScrollBar.ThumbMoving.Backwards)
+                    HorizontalBrush = ResPool.GetHatchBrush(HatchStyle.Percent50, Color.FromArgb(255, 63, 63, 63), Color.Black);
+                else
+                    HorizontalBrush = ResPool.GetHatchBrush(HatchStyle.Percent50, ColorScrollBar, Color.White);
+                Rectangle LeftTrack = new Rectangle(0, 0, bar.ThumbPos.Right, bar.ClientRectangle.Height);
+                if (clip.IntersectsWith(LeftTrack))
+                    dc.FillRectangle(HorizontalBrush, LeftTrack);
+
+                //Background, right track
+                if (bar.thumb_moving == ScrollBar.ThumbMoving.Forward)
+                    HorizontalBrush = ResPool.GetHatchBrush(HatchStyle.Percent50, Color.FromArgb(255, 63, 63, 63), Color.Black);
+                else
+                    HorizontalBrush = ResPool.GetHatchBrush(HatchStyle.Percent50, ColorScrollBar, Color.White);
+                Rectangle RightTrack = new Rectangle(bar.ThumbPos.Right, 0, bar.ClientRectangle.Width - bar.ThumbPos.Right, bar.ClientRectangle.Height);
+                if (clip.IntersectsWith(RightTrack))
+                    dc.FillRectangle(HorizontalBrush, RightTrack);
+
+                /* Buttons */
+                if (clip.IntersectsWith(first_arrow_area))
+                    CPDrawScrollButton(dc, first_arrow_area, ScrollButton.Left, bar.firstbutton_state);
+                if (clip.IntersectsWith(second_arrow_area))
+                    CPDrawScrollButton(dc, second_arrow_area, ScrollButton.Right, bar.secondbutton_state);
+            }
+
+            /* Thumb */
+            ScrollBar_DrawThumb(bar, thumb_pos, clip, dc);
+        }
+
+        protected virtual void ScrollBar_DrawThumb(ScrollBar bar, Rectangle thumb_pos, Rectangle clip, Graphics dc)
+        {
+            if (bar.Enabled && thumb_pos.Width > 0 && thumb_pos.Height > 0 && clip.IntersectsWith(thumb_pos))
+                DrawScrollButtonPrimitive(dc, thumb_pos, ButtonState.Normal);
+        }
+
+        public override int ScrollBarButtonSize
+        {
+            get { return 16; }
+        }
+
+        public override bool ScrollBarHasHotElementStyles
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        public override bool ScrollBarHasPressedThumbStyle
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        public override bool ScrollBarHasHoverArrowButtonStyle
+        {
+            get
+            {
+                return false;
+            }
+        }
+        #endregion // ScrollBar
+
+        #region StatusBar
+        public override void DrawStatusBar(Graphics real_dc, Rectangle clip, StatusBar sb)
+        {
+            Rectangle area = sb.ClientRectangle;
+            int horz_border = 2;
+            int vert_border = 2;
+
+            Image backbuffer = new Bitmap(sb.ClientSize.Width, sb.ClientSize.Height, real_dc);
+            Graphics dc = Graphics.FromImage(backbuffer);
+
+            DrawStatusBarBackground(dc, clip, sb);
+
+            if (!sb.ShowPanels && sb.Text != String.Empty)
+            {
+                string text = sb.Text;
+                StringFormat string_format = new StringFormat();
+                string_format.Trimming = StringTrimming.Character;
+                string_format.FormatFlags = StringFormatFlags.NoWrap;
+
+                if (text.Length > 127)
+                    text = text.Substring(0, 127);
+
+                if (text[0] == '\t')
+                {
+                    string_format.Alignment = StringAlignment.Center;
+                    text = text.Substring(1);
+                    if (text[0] == '\t')
+                    {
+                        string_format.Alignment = StringAlignment.Far;
+                        text = text.Substring(1);
+                    }
+                }
+
+                dc.DrawString(text, sb.Font, ResPool.GetSolidBrush(sb.ForeColor),
+                        new Rectangle(area.X + 2, area.Y + 2, area.Width - 4, area.Height - 4), string_format);
+                string_format.Dispose();
+            }
+            else if (sb.ShowPanels)
+            {
+                Brush br_forecolor = GetControlForeBrush(sb.ForeColor);
+                int prev_x = area.X + horz_border;
+                int y = area.Y + vert_border;
+                for (int i = 0; i < sb.Panels.Count; i++)
+                {
+                    Rectangle pr = new Rectangle(prev_x, y,
+                        sb.Panels[i].Width, area.Height);
+                    prev_x += pr.Width + StatusBarHorzGapWidth;
+                    if (pr.IntersectsWith(clip))
+                        DrawStatusBarPanel(dc, pr, i, br_forecolor, sb.Panels[i]);
+                }
+            }
+
+            if (sb.SizingGrip)
+                DrawStatusBarSizingGrip(dc, clip, sb, area);
+
+            real_dc.DrawImage(backbuffer, 0, 0);
+            dc.Dispose();
+            backbuffer.Dispose();
+
+        }
+
+        protected virtual void DrawStatusBarBackground(Graphics dc, Rectangle clip, StatusBar sb)
+        {
+            bool is_color_control = sb.BackColor.ToArgb() == ColorControl.ToArgb();
+
+            Brush brush = is_color_control ? SystemBrushes.Control : ResPool.GetSolidBrush(sb.BackColor);
+            dc.FillRectangle(brush, clip);
+        }
+
+        protected virtual void DrawStatusBarSizingGrip(Graphics dc, Rectangle clip, StatusBar sb, Rectangle area)
+        {
+            area = new Rectangle(area.Right - 16 - 2, area.Bottom - 12 - 1, 16, 16);
+            CPDrawSizeGrip(dc, ColorControl, area);
+        }
+
+        protected virtual void DrawStatusBarPanel(Graphics dc, Rectangle area, int index,
+            Brush br_forecolor, StatusBarPanel panel)
+        {
+            int border_size = 3; // this is actually const, even if the border style is none
+            int icon_width = 16;
+
+            area.Height -= border_size;
+
+            DrawStatusBarPanelBackground(dc, area, panel);
+
+            if (panel.Style == StatusBarPanelStyle.OwnerDraw)
+            {
+                StatusBarDrawItemEventArgs e = new StatusBarDrawItemEventArgs(
+                    dc, panel.Parent.Font, area, index, DrawItemState.Default,
+                    panel, panel.Parent.ForeColor, panel.Parent.BackColor);
+                panel.Parent.OnDrawItemInternal(e);
+                return;
+            }
+
+            string text = panel.Text;
+            StringFormat string_format = new StringFormat();
+            string_format.Trimming = StringTrimming.Character;
+            string_format.FormatFlags = StringFormatFlags.NoWrap;
+
+
+            if (text != null && text.Length > 0 && text[0] == '\t')
+            {
+                string_format.Alignment = StringAlignment.Center;
+                text = text.Substring(1);
+                if (text[0] == '\t')
+                {
+                    string_format.Alignment = StringAlignment.Far;
+                    text = text.Substring(1);
+                }
+            }
+
+            Rectangle string_rect = Rectangle.Empty;
+            int x;
+            int len;
+            int icon_x = 0;
+            int y = (area.Height / 2 - (int)panel.Parent.Font.Size / 2) - 1;
+
+            switch (panel.Alignment)
+            {
+                case HorizontalAlignment.Right:
+                    len = (int)dc.MeasureString(text, panel.Parent.Font).Width;
+                    x = area.Right - len - 4;
+                    string_rect = new Rectangle(x, y,
+                            area.Right - x - border_size,
+                            area.Bottom - y - border_size);
+                    if (panel.Icon != null)
+                    {
+                        icon_x = x - icon_width - 2;
+                    }
+                    break;
+                case HorizontalAlignment.Center:
+                    len = (int)dc.MeasureString(text, panel.Parent.Font).Width;
+                    x = area.Left + ((panel.Width - len) / 2);
+
+                    string_rect = new Rectangle(x, y,
+                            area.Right - x - border_size,
+                            area.Bottom - y - border_size);
+
+                    if (panel.Icon != null)
+                    {
+                        icon_x = x - icon_width - 2;
+                    }
+                    break;
+
+
+                default:
+                    int left = area.Left + border_size; ;
+                    if (panel.Icon != null)
+                    {
+                        icon_x = area.Left + 2;
+                        left = icon_x + icon_width + 2;
+                    }
+
+                    x = left;
+                    string_rect = new Rectangle(x, y,
+                            area.Right - x - border_size,
+                            area.Bottom - y - border_size);
+                    break;
+            }
+
+            RectangleF clip_bounds = dc.ClipBounds;
+            dc.SetClip(area);
+            dc.DrawString(text, panel.Parent.Font, br_forecolor, string_rect, string_format);
+            dc.SetClip(clip_bounds);
+
+            if (panel.Icon != null)
+            {
+                dc.DrawIcon(panel.Icon, new Rectangle(icon_x, y, icon_width, icon_width));
+            }
+        }
+
+        protected virtual void DrawStatusBarPanelBackground(Graphics dc, Rectangle area, StatusBarPanel panel)
+        {
+            if (panel.BorderStyle != StatusBarPanelBorderStyle.None)
+            {
+                Border3DStyle border_style = Border3DStyle.SunkenOuter;
+                if (panel.BorderStyle == StatusBarPanelBorderStyle.Raised)
+                    border_style = Border3DStyle.RaisedInner;
+
+                CPDrawBorder3D(dc, area, border_style, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom, panel.Parent.BackColor);
+            }
+        }
+
+        public override int StatusBarSizeGripWidth
+        {
+            get { return 15; }
+        }
+
+        public override int StatusBarHorzGapWidth
+        {
+            get { return 3; }
+        }
+
+        public override Size StatusBarDefaultSize
+        {
+            get
+            {
+                return new Size(100, 22);
+            }
+        }
+        #endregion // StatusBar
+
+        #region TabControl
+
+        #region TabControl settings
+
+        public override Size TabControlDefaultItemSize
+        {
+            get { return MemphisThemeElements.CurrentTheme.TabWidgetPainter.DefaultItemSize; }
+        }
+
+        public override Point TabControlDefaultPadding
+        {
+            get { return MemphisThemeElements.CurrentTheme.TabWidgetPainter.DefaultPadding; }
+        }
+
+        public override int TabControlMinimumTabWidth
+        {
+            get { return MemphisThemeElements.CurrentTheme.TabWidgetPainter.MinimumTabWidth; }
+        }
+
+        public override Rectangle TabWidgetselectedDelta
+        {
+            get { return MemphisThemeElements.CurrentTheme.TabWidgetPainter.SelectedTabDelta; }
+        }
+
+        public override int TabWidgetselectedSpacing
+        {
+            get { return MemphisThemeElements.CurrentTheme.TabWidgetPainter.SelectedSpacing; }
+        }
+
+        public override int TabPanelOffsetX
+        {
+            get { return MemphisThemeElements.CurrentTheme.TabWidgetPainter.TabPanelOffset.X; }
+        }
+
+        public override int TabPanelOffsetY
+        {
+            get { return MemphisThemeElements.CurrentTheme.TabWidgetPainter.TabPanelOffset.Y; }
+        }
+
+        public override int TabControlColSpacing
+        {
+            get { return MemphisThemeElements.CurrentTheme.TabWidgetPainter.ColSpacing; }
+        }
+
+        public override Point TabControlImagePadding
+        {
+            get { return MemphisThemeElements.CurrentTheme.TabWidgetPainter.ImagePadding; }
+        }
+
+        public override int TabWidgetscrollerWidth
+        {
+            get { return MemphisThemeElements.CurrentTheme.TabWidgetPainter.ScrollerWidth; }
+        }
+
+
+        public override Size TabControlGetSpacing(TabWidget tab)
+        {
+            try
+            {
+                return MemphisThemeElements.CurrentTheme.TabWidgetPainter.RowSpacing(tab);
+            }
+            catch
+            {
+                throw new Exception("Invalid Appearance value: " + tab.Appearance);
+            }
+        }
+        #endregion
+
+        public override void DrawTabControl(Graphics dc, Rectangle area, TabWidget tab)
+        {
+            MemphisThemeElements.CurrentTheme.TabWidgetPainter.Draw(dc, area, tab);
+        }
+
+        public override Rectangle TabControlGetDisplayRectangle(TabWidget tab)
+        {
+            return MemphisThemeElements.CurrentTheme.TabWidgetPainter.GetDisplayRectangle(tab);
+        }
+
+        public override Rectangle TabControlGetPanelRect(TabWidget tab)
+        {
+            return MemphisThemeElements.CurrentTheme.TabWidgetPainter.GetTabPanelRect(tab);
+        }
+
+        #endregion
+
+        #region TextBox
+        public override void TextBoxBaseFillBackground(TextBoxBase textBoxBase, Graphics g, Rectangle clippingArea)
+        {
+            if (textBoxBase.backcolor_set || (textBoxBase.Enabled && !textBoxBase.read_only))
+            {
+                g.FillRectangle(ResPool.GetSolidBrush(textBoxBase.BackColor), clippingArea);
+            }
+            else
+            {
+                g.FillRectangle(ResPool.GetSolidBrush(ColorControl), clippingArea);
+            }
+        }
+
+        public override bool TextBoxBaseHandleWmNcPaint(TextBoxBase textBoxBase, ref Message m)
+        {
+            return false;
+        }
+
+        public override bool TextBoxBaseShouldPaintBackground(TextBoxBase textBoxBase)
+        {
+            return true;
+        }
+        #endregion
+
+
+        #region ToolTip
+        public override void DrawToolTip(Graphics dc, Rectangle clip_rectangle, ToolTip.ToolTipWindow control)
+        {
+            ToolTipDrawBackground(dc, clip_rectangle, control);
+
+            TextFormatFlags flags = TextFormatFlags.HidePrefix;
+
+            Color foreground = control.ForeColor;
+            if (control.title.Length > 0)
+            {
+                Font bold_font = new Font(control.Font, control.Font.Style | FontStyle.Bold);
+                TextRenderer.DrawTextInternal(dc, control.title, bold_font, control.title_rect,
+                        foreground, flags, false);
+                bold_font.Dispose();
+            }
+
+            if (control.icon != null)
+                dc.DrawIcon(control.icon, control.icon_rect);
+
+            TextRenderer.DrawTextInternal(dc, control.Text, control.Font, control.text_rect, foreground, flags, false);
+        }
+
+        protected virtual void ToolTipDrawBackground(Graphics dc, Rectangle clip_rectangle, ToolTip.ToolTipWindow control)
+        {
+            Brush back_brush = ResPool.GetSolidBrush(control.BackColor);
+            dc.FillRectangle(back_brush, control.ClientRectangle);
+            dc.DrawRectangle(SystemPens.WindowFrame, 0, 0, control.Width - 1, control.Height - 1);
+        }
+
+        public override Size ToolTipSize(ToolTip.ToolTipWindow tt, string text)
+        {
+            Size size = TextRenderer.MeasureTextInternal(text, tt.Font, false);
+            size.Width += 4;
+            size.Height += 3;
+            Rectangle text_rect = new Rectangle(Point.Empty, size);
+            text_rect.Inflate(-2, -1);
+            tt.text_rect = text_rect;
+            tt.icon_rect = tt.title_rect = Rectangle.Empty;
+
+            Size title_size = Size.Empty;
+            if (tt.title.Length > 0)
+            {
+                Font bold_font = new Font(tt.Font, tt.Font.Style | FontStyle.Bold);
+                title_size = TextRenderer.MeasureTextInternal(tt.title, bold_font, false);
+                bold_font.Dispose();
+            }
+
+            Size icon_size = Size.Empty;
+            if (tt.icon != null)
+                icon_size = new Size(size.Height, size.Height);
+
+            if (icon_size != Size.Empty || title_size != Size.Empty)
+            {
+                int padding = 8;
+                int top_area_width = 0;
+                int top_area_height = icon_size.Height > title_size.Height ? icon_size.Height : title_size.Height;
+                Size text_size = size;
+                Point location = new Point(padding, padding);
+
+                if (icon_size != Size.Empty)
+                {
+                    tt.icon_rect = new Rectangle(location, icon_size);
+                    top_area_width = icon_size.Width + padding;
+                }
+
+                if (title_size != Size.Empty)
+                {
+                    Rectangle title_rect = new Rectangle(location, new Size(title_size.Width, top_area_height));
+                    if (icon_size != Size.Empty)
+                        title_rect.X += icon_size.Width + padding;
+
+                    tt.title_rect = title_rect;
+                    top_area_width += title_size.Width;
+                }
+
+                tt.text_rect = new Rectangle(new Point(location.X, location.Y + top_area_height + padding),
+                        text_size);
+
+                size.Height += padding + top_area_height;
+                if (top_area_width > size.Width)
+                    size.Width = top_area_width;
+
+                // margins
+                size.Width += padding * 2;
+                size.Height += padding * 2;
+            }
+
+            return size;
+        }
+
+        public override bool ToolTipTransparentBackground
+        {
+            get
+            {
+                return false;
+            }
+        }
+        #endregion    // ToolTip
+
+        #region BalloonWindow
+        NotifyIcon.BalloonWindow balloon_window;
+
+        public override void ShowBalloonWindow(IntPtr handle, int timeout, string title, string text, ToolTipIcon icon)
+        {
+            Widget control = Widget.FromHandle(handle);
+
+            if (control == null)
+                return;
+
+            if (balloon_window != null)
+            {
+                balloon_window.Close();
+                balloon_window.Dispose();
+            }
+
+            balloon_window = new NotifyIcon.BalloonWindow(handle);
+            balloon_window.Title = title;
+            balloon_window.Text = text;
+            balloon_window.Icon = icon;
+            balloon_window.Timeout = timeout;
+            balloon_window.Show();
+        }
+
+        public override void HideBalloonWindow(IntPtr handle)
+        {
+            if (balloon_window == null || balloon_window.OwnerHandle != handle)
+                return;
+
+            balloon_window.Close();
+            balloon_window.Dispose();
+            balloon_window = null;
+        }
+
+        private const int balloon_iconsize = 16;
+        private const int balloon_bordersize = 8;
+
+        public override void DrawBalloonWindow(Graphics dc, Rectangle clip, NotifyIcon.BalloonWindow control)
+        {
+            Brush solidbrush = ResPool.GetSolidBrush(this.ColorInfoText);
+            Rectangle rect = control.ClientRectangle;
+            int iconsize = (control.Icon == ToolTipIcon.None) ? 0 : balloon_iconsize;
+
+            // Rectangle borders and background.
+            dc.FillRectangle(ResPool.GetSolidBrush(ColorInfo), rect);
+            dc.DrawRectangle(ResPool.GetPen(ColorWindowFrame), 0, 0, rect.Width - 1, rect.Height - 1);
+
+            // Icon
+            Image image;
+            switch (control.Icon)
+            {
+                case ToolTipIcon.Info:
+                    {
+                        image = ThemeEngine.Current.Images(UIIcon.MessageBoxInfo, balloon_iconsize);
+                        break;
+                    }
+
+                case ToolTipIcon.Warning:
+                    {
+                        image = ThemeEngine.Current.Images(UIIcon.MessageBoxError, balloon_iconsize);
+                        break;
+                    }
+
+                case ToolTipIcon.Error:
+                    {
+                        image = ThemeEngine.Current.Images(UIIcon.MessageBoxWarning, balloon_iconsize);
+                        break;
+                    }
+
+                default:
+                    {
+                        image = null;
+                        break;
+                    }
+            }
+
+            if (control.Icon != ToolTipIcon.None)
+                dc.DrawImage(image, new Rectangle(balloon_bordersize, balloon_bordersize, iconsize, iconsize));
+
+            // Title
+            Rectangle titlerect = new Rectangle(rect.X + balloon_bordersize + iconsize + (iconsize > 0 ? balloon_bordersize : 0),
+                                                rect.Y + balloon_bordersize,
+                                                rect.Width - ((3 * balloon_bordersize) + iconsize),
+                                                rect.Height - (2 * balloon_bordersize));
+
+            Font titlefont = new Font(control.Font.FontFamily, control.Font.Size, control.Font.Style | FontStyle.Bold, control.Font.Unit);
+            dc.DrawString(control.Title, titlefont, solidbrush, titlerect, control.Format);
+
+            // Text
+            Rectangle textrect = new Rectangle(rect.X + balloon_bordersize,
+                                                rect.Y + balloon_bordersize,
+                                                rect.Width - (2 * balloon_bordersize),
+                                                rect.Height - (2 * balloon_bordersize));
+
+            StringFormat textformat = control.Format;
+            textformat.LineAlignment = StringAlignment.Far;
+            dc.DrawString(control.Text, control.Font, solidbrush, textrect, textformat);
+        }
+
+        public override Rectangle BalloonWindowRect(NotifyIcon.BalloonWindow control)
+        {
+            Rectangle deskrect = Screen.GetWorkingArea(control);
+            SizeF maxsize = new SizeF(250, 200);
+
+            SizeF titlesize = TextRenderer.MeasureString(control.Title, control.Font, maxsize, control.Format);
+            SizeF textsize = TextRenderer.MeasureString(control.Text, control.Font, maxsize, control.Format);
+
+            if (titlesize.Height < balloon_iconsize)
+                titlesize.Height = balloon_iconsize;
+
+            Rectangle rect = new Rectangle();
+            rect.Height = (int)(titlesize.Height + textsize.Height + (3 * balloon_bordersize));
+            rect.Width = (int)((titlesize.Width > textsize.Width) ? titlesize.Width : textsize.Width) + (2 * balloon_bordersize);
+            rect.X = deskrect.Width - rect.Width - 2;
+            rect.Y = deskrect.Height - rect.Height - 2;
+
+            return rect;
+        }
+        #endregion // BalloonWindow
+
+        #region	TrackBar
+        public override int TrackBarValueFromMousePosition(int x, int y, TrackBar tb)
+        {
+            int result = tb.Value;
+            int value_pos = tb.Value;
+            float pixels_betweenticks;
+            Rectangle thumb_pos = Rectangle.Empty, thumb_area = Rectangle.Empty;
+            Point channel_startpoint = Point.Empty, na_point = Point.Empty;
+
+            GetTrackBarDrawingInfo(tb, out pixels_betweenticks, out thumb_area, out thumb_pos, out channel_startpoint, out na_point, out na_point);
+
+            /* Convert thumb position from mouse position to value*/
+            if (tb.Orientation == Orientation.Vertical)
+            {
+                value_pos = (int)Math.Round(((thumb_area.Bottom - y - (float)thumb_pos.Height / 2) / (float)pixels_betweenticks), 0);
+
+                if (value_pos + tb.Minimum > tb.Maximum)
+                    value_pos = tb.Maximum - tb.Minimum;
+                else if (value_pos + tb.Minimum < tb.Minimum)
+                    value_pos = 0;
+
+                result = value_pos + tb.Minimum;
+            }
+            else
+            {
+                value_pos = (int)Math.Round(((x - channel_startpoint.X - (float)thumb_pos.Width / 2) / (float)pixels_betweenticks), 0);
+
+                if (value_pos + tb.Minimum > tb.Maximum)
+                    value_pos = tb.Maximum - tb.Minimum;
+                else if (value_pos + tb.Minimum < tb.Minimum)
+                    value_pos = 0;
+
+                result = value_pos + tb.Minimum;
+            }
+
+            return result;
+        }
+
+        private void GetTrackBarDrawingInfo(TrackBar tb, out float pixels_betweenticks, out Rectangle thumb_area, out Rectangle thumb_pos, out Point channel_startpoint, out Point bottomtick_startpoint, out Point toptick_startpoint)
+        {
+            thumb_area = Rectangle.Empty;
+            thumb_pos = Rectangle.Empty;
+
+            if (tb.Orientation == Orientation.Vertical)
+            {
+                toptick_startpoint = new Point();
+                bottomtick_startpoint = new Point();
+                channel_startpoint = new Point();
+                float pixel_len;
+                const int space_from_right = 8;
+                const int space_from_left = 8;
+                const int space_from_bottom = 11;
+                Rectangle area = tb.ClientRectangle;
+
+                switch (tb.TickStyle)
+                {
+                    case TickStyle.BottomRight:
+                    case TickStyle.None:
+                        channel_startpoint.Y = 8;
+                        channel_startpoint.X = 9;
+                        bottomtick_startpoint.Y = 13;
+                        bottomtick_startpoint.X = 24;
+                        break;
+                    case TickStyle.TopLeft:
+                        channel_startpoint.Y = 8;
+                        channel_startpoint.X = 19;
+                        toptick_startpoint.Y = 13;
+                        toptick_startpoint.X = 8;
+                        break;
+                    case TickStyle.Both:
+                        channel_startpoint.Y = 8;
+                        channel_startpoint.X = 18;
+                        bottomtick_startpoint.Y = 13;
+                        bottomtick_startpoint.X = 32;
+                        toptick_startpoint.Y = 13;
+                        toptick_startpoint.X = 8;
+                        break;
+                    default:
+                        break;
+                }
+
+                thumb_area.X = area.X + channel_startpoint.X;
+                thumb_area.Y = area.Y + channel_startpoint.Y;
+                thumb_area.Height = area.Height - space_from_right - space_from_left;
+                thumb_area.Width = TrackBarVerticalTrackWidth;
+
+                pixel_len = thumb_area.Height - 11;
+                if (tb.Maximum == tb.Minimum)
+                {
+                    pixels_betweenticks = 0;
+                }
+                else
+                {
+                    pixels_betweenticks = pixel_len / (tb.Maximum - tb.Minimum);
+                }
+
+                thumb_pos.Y = thumb_area.Bottom - space_from_bottom - (int)(pixels_betweenticks * (float)(tb.Value - tb.Minimum));
+            }
+            else
+            {
+                toptick_startpoint = new Point();
+                bottomtick_startpoint = new Point();
+                channel_startpoint = new Point();
+                float pixel_len;
+                const int space_from_right = 8;
+                const int space_from_left = 8;
+                Rectangle area = tb.ClientRectangle;
+
+                switch (tb.TickStyle)
+                {
+                    case TickStyle.BottomRight:
+                    case TickStyle.None:
+                        channel_startpoint.X = 8;
+                        channel_startpoint.Y = 9;
+                        bottomtick_startpoint.X = 13;
+                        bottomtick_startpoint.Y = 24;
+                        break;
+                    case TickStyle.TopLeft:
+                        channel_startpoint.X = 8;
+                        channel_startpoint.Y = 19;
+                        toptick_startpoint.X = 13;
+                        toptick_startpoint.Y = 8;
+                        break;
+                    case TickStyle.Both:
+                        channel_startpoint.X = 8;
+                        channel_startpoint.Y = 18;
+                        bottomtick_startpoint.X = 13;
+                        bottomtick_startpoint.Y = 32;
+                        toptick_startpoint.X = 13;
+                        toptick_startpoint.Y = 8;
+                        break;
+                    default:
+                        break;
+                }
+
+                thumb_area.X = area.X + channel_startpoint.X;
+                thumb_area.Y = area.Y + channel_startpoint.Y;
+                thumb_area.Width = area.Width - space_from_right - space_from_left;
+                thumb_area.Height = TrackBarHorizontalTrackHeight;
+
+                pixel_len = thumb_area.Width - 11;
+                if (tb.Maximum == tb.Minimum)
+                {
+                    pixels_betweenticks = 0;
+                }
+                else
+                {
+                    pixels_betweenticks = pixel_len / (tb.Maximum - tb.Minimum);
+                }
+
+                thumb_pos.X = channel_startpoint.X + (int)(pixels_betweenticks * (float)(tb.Value - tb.Minimum));
+            }
+
+            thumb_pos.Size = TrackBarGetThumbSize(tb);
+        }
+
+        protected virtual Size TrackBarGetThumbSize(TrackBar trackBar)
+        {
+            return TrackBarGetThumbSize();
+        }
+
+        public static Size TrackBarGetThumbSize()
+        {
+            /* Draw thumb fixed 10x22 size */
+            return new Size(10, 22);
+        }
+
+        public const int TrackBarVerticalTrackWidth = 4;
+
+        public const int TrackBarHorizontalTrackHeight = 4;
+
+        #region Ticks
+        protected interface ITrackBarTickPainter
+        {
+            void Paint(float x1, float y1, float x2, float y2);
+        }
+
+        class TrackBarTickPainter : ITrackBarTickPainter
+        {
+            readonly Graphics g;
+            readonly Pen pen;
+            public TrackBarTickPainter(Graphics g, Pen pen)
+            {
+                this.g = g;
+                this.pen = pen;
+            }
+            public void Paint(float x1, float y1, float x2, float y2)
+            {
+                g.DrawLine(pen, x1, y1, x2, y2);
+            }
+        }
+        protected virtual ITrackBarTickPainter GetTrackBarTickPainter(Graphics g)
+        {
+            return new TrackBarTickPainter(g, ResPool.GetPen(pen_ticks_color));
+        }
+        #endregion
+
+        #region DrawTrackBar_Vertical
+        private void DrawTrackBar_Vertical(Graphics dc, Rectangle clip_rectangle, TrackBar tb,
+            ref Rectangle thumb_pos, ref Rectangle thumb_area, Brush br_thumb,
+            float ticks, int value_pos, bool mouse_value)
+        {
+
+            Point toptick_startpoint = new Point();
+            Point bottomtick_startpoint = new Point();
+            Point channel_startpoint = new Point();
+            float pixel_len;
+            float pixels_betweenticks;
+            Rectangle area = tb.ClientRectangle;
+
+            GetTrackBarDrawingInfo(tb, out pixels_betweenticks, out thumb_area, out thumb_pos, out channel_startpoint, out bottomtick_startpoint, out toptick_startpoint);
+
+            #region Track
+            TrackBarDrawVerticalTrack(dc, thumb_area, channel_startpoint, clip_rectangle);
+            #endregion
+
+            #region Thumb
+            switch (tb.TickStyle)
+            {
+                case TickStyle.BottomRight:
+                case TickStyle.None:
+                    thumb_pos.X = channel_startpoint.X - 8;
+                    TrackBarDrawVerticalThumbRight(dc, thumb_pos, br_thumb, clip_rectangle, tb);
+                    break;
+                case TickStyle.TopLeft:
+                    thumb_pos.X = channel_startpoint.X - 10;
+                    TrackBarDrawVerticalThumbLeft(dc, thumb_pos, br_thumb, clip_rectangle, tb);
+                    break;
+                default:
+                    thumb_pos.X = area.X + 10;
+                    TrackBarDrawVerticalThumb(dc, thumb_pos, br_thumb, clip_rectangle, tb);
+                    break;
+            }
+            #endregion
+
+            pixel_len = thumb_area.Height - 11;
+            pixels_betweenticks = pixel_len / ticks;
+
+            thumb_area.X = thumb_pos.X;
+            thumb_area.Y = channel_startpoint.Y;
+            thumb_area.Width = thumb_pos.Height;
+
+            #region Ticks
+            if (pixels_betweenticks <= 0)
+                return;
+            if (tb.TickStyle == TickStyle.None)
+                return;
+            Region outside = new Region(area);
+            outside.Exclude(thumb_area);
+
+            if (outside.IsVisible(clip_rectangle))
+            {
+                ITrackBarTickPainter tick_painter = TrackBarGetVerticalTickPainter(dc);
+
+                if ((tb.TickStyle & TickStyle.BottomRight) == TickStyle.BottomRight)
+                {
+                    float x = area.X + bottomtick_startpoint.X;
+                    for (float inc = 0; inc < pixel_len + 1; inc += pixels_betweenticks)
+                    {
+                        float y = area.Y + bottomtick_startpoint.Y + inc;
+                        tick_painter.Paint(
+                            x, y,
+                            x + (inc == 0 || inc + pixels_betweenticks >= pixel_len + 1 ? 3 : 2), y);
+                    }
+                }
+
+                if ((tb.TickStyle & TickStyle.TopLeft) == TickStyle.TopLeft)
+                {
+                    float x = area.X + toptick_startpoint.X;
+                    for (float inc = 0; inc < (pixel_len + 1); inc += pixels_betweenticks)
+                    {
+                        float y = area.Y + toptick_startpoint.Y + inc;
+                        tick_painter.Paint(
+                            x - (inc == 0 || inc + pixels_betweenticks >= pixel_len + 1 ? 3 : 2), y,
+                            x, y);
+                    }
+                }
+            }
+
+            outside.Dispose();
+            #endregion
+        }
+
+        #region Track
+        protected virtual void TrackBarDrawVerticalTrack(Graphics dc, Rectangle thumb_area, Point channel_startpoint, Rectangle clippingArea)
+        {
+            dc.FillRectangle(SystemBrushes.ControlDark, channel_startpoint.X, channel_startpoint.Y,
+                1, thumb_area.Height);
+
+            dc.FillRectangle(SystemBrushes.ControlDarkDark, channel_startpoint.X + 1, channel_startpoint.Y,
+                1, thumb_area.Height);
+
+            dc.FillRectangle(SystemBrushes.ControlLight, channel_startpoint.X + 3, channel_startpoint.Y,
+                1, thumb_area.Height);
+        }
+        #endregion
+
+        #region Thumb
+        protected virtual void TrackBarDrawVerticalThumbRight(Graphics dc, Rectangle thumb_pos, Brush br_thumb, Rectangle clippingArea, TrackBar trackBar)
+        {
+            Pen pen = SystemPens.ControlLightLight;
+            dc.DrawLine(pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X, thumb_pos.Y + 10);
+            dc.DrawLine(pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X + 16, thumb_pos.Y);
+            dc.DrawLine(pen, thumb_pos.X + 16, thumb_pos.Y, thumb_pos.X + 16 + 4, thumb_pos.Y + 4);
+
+            pen = SystemPens.ControlDark;
+            dc.DrawLine(pen, thumb_pos.X + 1, thumb_pos.Y + 9, thumb_pos.X + 15, thumb_pos.Y + 9);
+            dc.DrawLine(pen, thumb_pos.X + 16, thumb_pos.Y + 9, thumb_pos.X + 16 + 4, thumb_pos.Y + 9 - 4);
+
+            pen = SystemPens.ControlDarkDark;
+            dc.DrawLine(pen, thumb_pos.X, thumb_pos.Y + 10, thumb_pos.X + 16, thumb_pos.Y + 10);
+            dc.DrawLine(pen, thumb_pos.X + 16, thumb_pos.Y + 10, thumb_pos.X + 16 + 5, thumb_pos.Y + 10 - 5);
+
+            dc.FillRectangle(br_thumb, thumb_pos.X + 1, thumb_pos.Y + 1, 16, 8);
+            dc.FillRectangle(br_thumb, thumb_pos.X + 17, thumb_pos.Y + 2, 1, 6);
+            dc.FillRectangle(br_thumb, thumb_pos.X + 18, thumb_pos.Y + 3, 1, 4);
+            dc.FillRectangle(br_thumb, thumb_pos.X + 19, thumb_pos.Y + 4, 1, 2);
+        }
+
+        protected virtual void TrackBarDrawVerticalThumbLeft(Graphics dc, Rectangle thumb_pos, Brush br_thumb, Rectangle clippingArea, TrackBar trackBar)
+        {
+            Pen pen = SystemPens.ControlLightLight;
+            dc.DrawLine(pen, thumb_pos.X + 4, thumb_pos.Y, thumb_pos.X + 4 + 16, thumb_pos.Y);
+            dc.DrawLine(pen, thumb_pos.X + 4, thumb_pos.Y, thumb_pos.X, thumb_pos.Y + 4);
+
+            pen = SystemPens.ControlDark;
+            dc.DrawLine(pen, thumb_pos.X + 4, thumb_pos.Y + 9, thumb_pos.X + 4 + 16, thumb_pos.Y + 9);
+            dc.DrawLine(pen, thumb_pos.X + 4, thumb_pos.Y + 9, thumb_pos.X, thumb_pos.Y + 5);
+            dc.DrawLine(pen, thumb_pos.X + 19, thumb_pos.Y + 9, thumb_pos.X + 19, thumb_pos.Y + 1);
+
+            pen = SystemPens.ControlDarkDark;
+            dc.DrawLine(pen, thumb_pos.X + 4, thumb_pos.Y + 10, thumb_pos.X + 4 + 16, thumb_pos.Y + 10);
+            dc.DrawLine(pen, thumb_pos.X + 4, thumb_pos.Y + 10, thumb_pos.X - 1, thumb_pos.Y + 5);
+            dc.DrawLine(pen, thumb_pos.X + 20, thumb_pos.Y, thumb_pos.X + 20, thumb_pos.Y + 10);
+
+            dc.FillRectangle(br_thumb, thumb_pos.X + 4, thumb_pos.Y + 1, 15, 8);
+            dc.FillRectangle(br_thumb, thumb_pos.X + 3, thumb_pos.Y + 2, 1, 6);
+            dc.FillRectangle(br_thumb, thumb_pos.X + 2, thumb_pos.Y + 3, 1, 4);
+            dc.FillRectangle(br_thumb, thumb_pos.X + 1, thumb_pos.Y + 4, 1, 2);
+        }
+
+        protected virtual void TrackBarDrawVerticalThumb(Graphics dc, Rectangle thumb_pos, Brush br_thumb, Rectangle clippingArea, TrackBar trackBar)
+        {
+            Pen pen = SystemPens.ControlLightLight;
+            dc.DrawLine(pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X, thumb_pos.Y + 9);
+            dc.DrawLine(pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X + 19, thumb_pos.Y);
+
+            pen = SystemPens.ControlDark;
+            dc.DrawLine(pen, thumb_pos.X + 1, thumb_pos.Y + 9, thumb_pos.X + 19, thumb_pos.Y + 9);
+            dc.DrawLine(pen, thumb_pos.X + 10, thumb_pos.Y + 1, thumb_pos.X + 19, thumb_pos.Y + 8);
+
+            pen = SystemPens.ControlDarkDark;
+            dc.DrawLine(pen, thumb_pos.X, thumb_pos.Y + 10, thumb_pos.X + 20, thumb_pos.Y + 10);
+            dc.DrawLine(pen, thumb_pos.X + 20, thumb_pos.Y, thumb_pos.X + 20, thumb_pos.Y + 9);
+
+            dc.FillRectangle(br_thumb, thumb_pos.X + 1, thumb_pos.Y + 1, 18, 8);
+        }
+        #endregion
+
+        #region Ticks
+        protected virtual ITrackBarTickPainter TrackBarGetVerticalTickPainter(Graphics g)
+        {
+            return GetTrackBarTickPainter(g);
+        }
+        #endregion
+        #endregion
+
+        #region DrawTrackBar_Horizontal
+        /* 
+			Horizontal trackbar 
+		  
+			Does not matter the size of the control, Win32 always draws:
+				- Ticks starting from pixel 13, 8
+				- Channel starting at pos 8, 19 and ends at Width - 8
+				- Autosize makes always the control 45 pixels high
+				- Ticks are draw at (channel.Witdh - 10) / (Maximum - Minimum)
+				
+		*/
+        private void DrawTrackBar_Horizontal(Graphics dc, Rectangle clip_rectangle, TrackBar tb,
+            ref Rectangle thumb_pos, ref Rectangle thumb_area, Brush br_thumb,
+            float ticks, int value_pos, bool mouse_value)
+        {
+            Point toptick_startpoint = new Point();
+            Point bottomtick_startpoint = new Point();
+            Point channel_startpoint = new Point();
+            float pixel_len;
+            float pixels_betweenticks;
+            Rectangle area = tb.ClientRectangle;
+
+            GetTrackBarDrawingInfo(tb, out pixels_betweenticks, out thumb_area, out thumb_pos, out channel_startpoint, out bottomtick_startpoint, out toptick_startpoint);
+
+            #region Track
+            TrackBarDrawHorizontalTrack(dc, thumb_area, channel_startpoint, clip_rectangle);
+            #endregion
+
+            #region Thumb
+            switch (tb.TickStyle)
+            {
+                case TickStyle.BottomRight:
+                case TickStyle.None:
+                    thumb_pos.Y = channel_startpoint.Y - 8;
+                    TrackBarDrawHorizontalThumbBottom(dc, thumb_pos, br_thumb, clip_rectangle, tb);
+                    break;
+                case TickStyle.TopLeft:
+                    thumb_pos.Y = channel_startpoint.Y - 10;
+                    TrackBarDrawHorizontalThumbTop(dc, thumb_pos, br_thumb, clip_rectangle, tb);
+                    break;
+                default:
+                    thumb_pos.Y = area.Y + 10;
+                    TrackBarDrawHorizontalThumb(dc, thumb_pos, br_thumb, clip_rectangle, tb);
+                    break;
+            }
+            #endregion
+
+            pixel_len = thumb_area.Width - 11;
+            pixels_betweenticks = pixel_len / ticks;
+
+            thumb_area.Y = thumb_pos.Y;
+            thumb_area.X = channel_startpoint.X;
+            thumb_area.Height = thumb_pos.Height;
+            #region Ticks
+            if (pixels_betweenticks <= 0)
+                return;
+            if (tb.TickStyle == TickStyle.None)
+                return;
+            Region outside = new Region(area);
+            outside.Exclude(thumb_area);
+
+            if (outside.IsVisible(clip_rectangle))
+            {
+                ITrackBarTickPainter tick_painter = TrackBarGetHorizontalTickPainter(dc);
+
+                if ((tb.TickStyle & TickStyle.BottomRight) == TickStyle.BottomRight)
+                {
+                    float y = area.Y + bottomtick_startpoint.Y;
+                    for (float inc = 0; inc < pixel_len + 1; inc += pixels_betweenticks)
+                    {
+                        float x = area.X + bottomtick_startpoint.X + inc;
+                        tick_painter.Paint(
+                            x, y,
+                            x, y + (inc == 0 || inc + pixels_betweenticks >= pixel_len + 1 ? 3 : 2));
+                    }
+                }
+
+                if ((tb.TickStyle & TickStyle.TopLeft) == TickStyle.TopLeft)
+                {
+                    float y = area.Y + toptick_startpoint.Y;
+                    for (float inc = 0; inc < pixel_len + 1; inc += pixels_betweenticks)
+                    {
+                        float x = area.X + toptick_startpoint.X + inc;
+                        tick_painter.Paint(
+                            x, y - (inc == 0 || (inc + pixels_betweenticks) >= pixel_len + 1 ? 3 : 2),
+                            x, y);
+                    }
+                }
+            }
+
+            outside.Dispose();
+            #endregion
+        }
+
+        #region Track
+        protected virtual void TrackBarDrawHorizontalTrack(Graphics dc, Rectangle thumb_area, Point channel_startpoint, Rectangle clippingArea)
+        {
+            dc.FillRectangle(SystemBrushes.ControlDark, channel_startpoint.X, channel_startpoint.Y,
+                thumb_area.Width, 1);
+
+            dc.FillRectangle(SystemBrushes.ControlDarkDark, channel_startpoint.X, channel_startpoint.Y + 1,
+                thumb_area.Width, 1);
+
+            dc.FillRectangle(SystemBrushes.ControlLight, channel_startpoint.X, channel_startpoint.Y + 3,
+                thumb_area.Width, 1);
+        }
+        #endregion
+
+        #region Thumb
+        protected virtual void TrackBarDrawHorizontalThumbBottom(Graphics dc, Rectangle thumb_pos, Brush br_thumb, Rectangle clippingArea, TrackBar trackBar)
+        {
+            Pen pen = SystemPens.ControlLightLight;
+            dc.DrawLine(pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X + 10, thumb_pos.Y);
+            dc.DrawLine(pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X, thumb_pos.Y + 16);
+            dc.DrawLine(pen, thumb_pos.X, thumb_pos.Y + 16, thumb_pos.X + 4, thumb_pos.Y + 16 + 4);
+
+            pen = SystemPens.ControlDark;
+            dc.DrawLine(pen, thumb_pos.X + 9, thumb_pos.Y + 1, thumb_pos.X + 9, thumb_pos.Y + 15);
+            dc.DrawLine(pen, thumb_pos.X + 9, thumb_pos.Y + 16, thumb_pos.X + 9 - 4, thumb_pos.Y + 16 + 4);
+
+            pen = SystemPens.ControlDarkDark;
+            dc.DrawLine(pen, thumb_pos.X + 10, thumb_pos.Y, thumb_pos.X + 10, thumb_pos.Y + 16);
+            dc.DrawLine(pen, thumb_pos.X + 10, thumb_pos.Y + 16, thumb_pos.X + 10 - 5, thumb_pos.Y + 16 + 5);
+
+            dc.FillRectangle(br_thumb, thumb_pos.X + 1, thumb_pos.Y + 1, 8, 16);
+            dc.FillRectangle(br_thumb, thumb_pos.X + 2, thumb_pos.Y + 17, 6, 1);
+            dc.FillRectangle(br_thumb, thumb_pos.X + 3, thumb_pos.Y + 18, 4, 1);
+            dc.FillRectangle(br_thumb, thumb_pos.X + 4, thumb_pos.Y + 19, 2, 1);
+        }
+
+        protected virtual void TrackBarDrawHorizontalThumbTop(Graphics dc, Rectangle thumb_pos, Brush br_thumb, Rectangle clippingArea, TrackBar trackBar)
+        {
+            Pen pen = SystemPens.ControlLightLight;
+            dc.DrawLine(pen, thumb_pos.X, thumb_pos.Y + 4, thumb_pos.X, thumb_pos.Y + 4 + 16);
+            dc.DrawLine(pen, thumb_pos.X, thumb_pos.Y + 4, thumb_pos.X + 4, thumb_pos.Y);
+
+            pen = SystemPens.ControlDark;
+            dc.DrawLine(pen, thumb_pos.X + 9, thumb_pos.Y + 4, thumb_pos.X + 9, thumb_pos.Y + 4 + 16);
+            dc.DrawLine(pen, thumb_pos.X + 9, thumb_pos.Y + 4, thumb_pos.X + 5, thumb_pos.Y);
+            dc.DrawLine(pen, thumb_pos.X + 9, thumb_pos.Y + 19, thumb_pos.X + 1, thumb_pos.Y + 19);
+
+            pen = SystemPens.ControlDarkDark;
+            dc.DrawLine(pen, thumb_pos.X + 10, thumb_pos.Y + 4, thumb_pos.X + 10, thumb_pos.Y + 4 + 16);
+            dc.DrawLine(pen, thumb_pos.X + 10, thumb_pos.Y + 4, thumb_pos.X + 5, thumb_pos.Y - 1);
+            dc.DrawLine(pen, thumb_pos.X, thumb_pos.Y + 20, thumb_pos.X + 10, thumb_pos.Y + 20);
+
+            dc.FillRectangle(br_thumb, thumb_pos.X + 1, thumb_pos.Y + 4, 8, 15);
+            dc.FillRectangle(br_thumb, thumb_pos.X + 2, thumb_pos.Y + 3, 6, 1);
+            dc.FillRectangle(br_thumb, thumb_pos.X + 3, thumb_pos.Y + 2, 4, 1);
+            dc.FillRectangle(br_thumb, thumb_pos.X + 4, thumb_pos.Y + 1, 2, 1);
+        }
+
+        protected virtual void TrackBarDrawHorizontalThumb(Graphics dc, Rectangle thumb_pos, Brush br_thumb, Rectangle clippingArea, TrackBar trackBar)
+        {
+            Pen pen = SystemPens.ControlLightLight;
+            dc.DrawLine(pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X + 9, thumb_pos.Y);
+            dc.DrawLine(pen, thumb_pos.X, thumb_pos.Y, thumb_pos.X, thumb_pos.Y + 19);
+
+            pen = SystemPens.ControlDark;
+            dc.DrawLine(pen, thumb_pos.X + 9, thumb_pos.Y + 1, thumb_pos.X + 9, thumb_pos.Y + 19);
+            dc.DrawLine(pen, thumb_pos.X + 1, thumb_pos.Y + 10, thumb_pos.X + 8, thumb_pos.Y + 19);
+
+            pen = SystemPens.ControlDarkDark;
+            dc.DrawLine(pen, thumb_pos.X + 10, thumb_pos.Y, thumb_pos.X + 10, thumb_pos.Y + 20);
+            dc.DrawLine(pen, thumb_pos.X, thumb_pos.Y + 20, thumb_pos.X + 9, thumb_pos.Y + 20);
+
+            dc.FillRectangle(br_thumb, thumb_pos.X + 1, thumb_pos.Y + 1, 8, 18);
+        }
+        #endregion
+
+        #region Ticks
+        protected virtual ITrackBarTickPainter TrackBarGetHorizontalTickPainter(Graphics g)
+        {
+            return GetTrackBarTickPainter(g);
+        }
+        #endregion
+        #endregion
+
+        public override void DrawTrackBar(Graphics dc, Rectangle clip_rectangle, TrackBar tb)
+        {
+            Brush br_thumb;
+            int value_pos;
+            bool mouse_value;
+            float ticks = (tb.Maximum - tb.Minimum) / tb.tickFrequency; /* N of ticks draw*/
+            Rectangle area;
+            Rectangle thumb_pos = tb.ThumbPos;
+            Rectangle thumb_area = tb.ThumbArea;
+
+            if (tb.thumb_pressed)
+            {
+                value_pos = tb.thumb_mouseclick;
+                mouse_value = true;
+            }
+            else
+            {
+                value_pos = tb.Value - tb.Minimum;
+                mouse_value = false;
+            }
+
+            area = tb.ClientRectangle;
+
+            if (!tb.Enabled)
+            {
+                br_thumb = (Brush)ResPool.GetHatchBrush(HatchStyle.Percent50, ColorControlLightLight, ColorControlLight);
+            }
+            else if (tb.thumb_pressed == true)
+            {
+                br_thumb = (Brush)ResPool.GetHatchBrush(HatchStyle.Percent50, ColorControlLight, ColorControl);
+            }
+            else
+            {
+                br_thumb = SystemBrushes.Control;
+            }
+
+
+            /* Widget Background */
+            if (tb.BackColor.ToArgb() == DefaultControlBackColor.ToArgb())
+            {
+                dc.FillRectangle(SystemBrushes.Control, clip_rectangle);
+            }
+            else
+            {
+                dc.FillRectangle(ResPool.GetSolidBrush(tb.BackColor), clip_rectangle);
+            }
+
+            if (tb.Focused)
+            {
+                CPDrawFocusRectangle(dc, area, tb.ForeColor, tb.BackColor);
+            }
+
+            if (tb.Orientation == Orientation.Vertical)
+            {
+                DrawTrackBar_Vertical(dc, clip_rectangle, tb, ref thumb_pos, ref thumb_area,
+                    br_thumb, ticks, value_pos, mouse_value);
+
+            }
+            else
+            {
+                DrawTrackBar_Horizontal(dc, clip_rectangle, tb, ref thumb_pos, ref thumb_area,
+                    br_thumb, ticks, value_pos, mouse_value);
+            }
+
+            tb.ThumbPos = thumb_pos;
+            tb.ThumbArea = thumb_area;
+        }
+
+        public override Size TrackBarDefaultSize
+        {
+            get
+            {
+                return new Size(104, 42);
+            }
+        }
+
+        public override bool TrackBarHasHotThumbStyle
+        {
+            get
+            {
+                return false;
+            }
+        }
+        #endregion // TrackBar
+
+        #region UpDownBase
+        public override void UpDownBaseDrawButton(Graphics g, Rectangle bounds, bool top, VisualStyles.PushButtonState state)
+        {
+            WidgetPaint.DrawScrollButton(g, bounds, top ? ScrollButton.Up : ScrollButton.Down, state == VisualStyles.PushButtonState.Pressed ? ButtonState.Pushed : ButtonState.Normal);
+        }
+
+        public override bool UpDownBaseHasHotButtonStyle
+        {
+            get
+            {
+                return false;
+            }
+        }
+        #endregion
+
+        #region	VScrollBar
+        public override Size VScrollBarDefaultSize
+        {
+            get
+            {
+                return new Size(this.ScrollBarButtonSize, 80);
+            }
+        }
+        #endregion // VScrollBar
+
+        #region TreeView
+        public override Size TreeViewDefaultSize
+        {
+            get
+            {
+                return new Size(121, 97);
+            }
+        }
+
+        public override void TreeViewDrawNodePlusMinus(TreeView treeView, TreeNode node, Graphics dc, int x, int middle)
+        {
+            int height = treeView.ActualItemHeight - 2;
+            dc.FillRectangle(ResPool.GetSolidBrush(treeView.BackColor), (x + 4) - (height / 2), node.GetY() + 1, height, height);
+
+            dc.DrawRectangle(SystemPens.ControlDarkDark, x, middle - 4, 8, 8);
+
+            if (node.IsExpanded)
+            {
+                dc.DrawLine(SystemPens.ControlDarkDark, x + 2, middle, x + 6, middle);
+            }
+            else
+            {
+                dc.DrawLine(SystemPens.ControlDarkDark, x + 2, middle, x + 6, middle);
+                dc.DrawLine(SystemPens.ControlDarkDark, x + 4, middle - 2, x + 4, middle + 2);
+            }
+        }
+        #endregion
+
+        #region Managed window
+        public override int ManagedWindowTitleBarHeight(InternalWindowManager wm)
+        {
+            if (wm.IsToolWindow && !wm.IsMinimized)
+                return SystemInformation.ToolWindowCaptionHeight;
+            if (wm.Form.FormBorderStyle == FormBorderStyle.None)
+                return 0;
+            return SystemInformation.CaptionHeight;
+        }
+
+        public override int ManagedWindowBorderWidth(InternalWindowManager wm)
+        {
+            if ((wm.IsToolWindow && wm.form.FormBorderStyle == FormBorderStyle.FixedToolWindow) ||
+                wm.IsMinimized)
+                return 3;
+            else
+                return 4;
+        }
+
+        public override int ManagedWindowIconWidth(InternalWindowManager wm)
+        {
+            return ManagedWindowTitleBarHeight(wm) - 5;
+        }
+
+        public override void ManagedWindowSetButtonLocations(InternalWindowManager wm)
+        {
+            TitleButtons buttons = wm.TitleButtons;
+            Form form = wm.form;
+
+            buttons.HelpButton.Visible = form.HelpButton;
+
+            foreach (TitleButton button in buttons)
+            {
+                button.Visible = false;
+            }
+
+            switch (form.FormBorderStyle)
+            {
+                case FormBorderStyle.None:
+                    if (form.WindowState != FormWindowState.Normal)
+                        goto case FormBorderStyle.Sizable;
+                    break;
+                case FormBorderStyle.FixedToolWindow:
+                case FormBorderStyle.SizableToolWindow:
+                    buttons.CloseButton.Visible = true;
+                    if (form.WindowState != FormWindowState.Normal)
+                        goto case FormBorderStyle.Sizable;
+                    break;
+                case FormBorderStyle.FixedSingle:
+                case FormBorderStyle.Fixed3D:
+                case FormBorderStyle.FixedDialog:
+                case FormBorderStyle.Sizable:
+                    switch (form.WindowState)
+                    {
+                        case FormWindowState.Normal:
+                            buttons.MinimizeButton.Visible = true;
+                            buttons.MaximizeButton.Visible = true;
+                            buttons.RestoreButton.Visible = false;
+                            break;
+                        case FormWindowState.Maximized:
+                            buttons.MinimizeButton.Visible = true;
+                            buttons.MaximizeButton.Visible = false;
+                            buttons.RestoreButton.Visible = true;
+                            break;
+                        case FormWindowState.Minimized:
+                            buttons.MinimizeButton.Visible = false;
+                            buttons.MaximizeButton.Visible = true;
+                            buttons.RestoreButton.Visible = true;
+                            break;
+                    }
+                    buttons.CloseButton.Visible = true;
+                    break;
+            }
+
+            // Respect MinimizeBox/MaximizeBox
+            if (form.MinimizeBox == false && form.MaximizeBox == false)
+            {
+                buttons.MinimizeButton.Visible = false;
+                buttons.MaximizeButton.Visible = false;
+            }
+            else if (form.MinimizeBox == false)
+                buttons.MinimizeButton.State = ButtonState.Inactive;
+            else if (form.MaximizeBox == false)
+                buttons.MaximizeButton.State = ButtonState.Inactive;
+
+            int bw = ManagedWindowBorderWidth(wm);
+            Size btsize = ManagedWindowButtonSize(wm);
+            int btw = btsize.Width;
+            int bth = btsize.Height;
+            int top = bw + 2;
+            int left = form.Width - bw - btw - ManagedWindowSpacingAfterLastTitleButton;
+
+            if ((!wm.IsToolWindow || wm.IsMinimized) && wm.HasBorders)
+            {
+                buttons.CloseButton.Rectangle = new Rectangle(left, top, btw, bth);
+                left -= 2 + btw;
+
+                if (buttons.MaximizeButton.Visible)
+                {
+                    buttons.MaximizeButton.Rectangle = new Rectangle(left, top, btw, bth);
+                    left -= 2 + btw;
+                }
+                if (buttons.RestoreButton.Visible)
+                {
+                    buttons.RestoreButton.Rectangle = new Rectangle(left, top, btw, bth);
+                    left -= 2 + btw;
+                }
+
+                buttons.MinimizeButton.Rectangle = new Rectangle(left, top, btw, bth);
+                left -= 2 + btw;
+            }
+            else if (wm.IsToolWindow)
+            {
+                buttons.CloseButton.Rectangle = new Rectangle(left, top, btw, bth);
+                left -= 2 + btw;
+            }
+        }
+
+        protected virtual Rectangle ManagedWindowDrawTitleBarAndBorders(Graphics dc, Rectangle clip, InternalWindowManager wm)
+        {
+            Form form = wm.Form;
+            int tbheight = ManagedWindowTitleBarHeight(wm);
+            int bdwidth = ManagedWindowBorderWidth(wm);
+            Color titlebar_color = Color.FromArgb(255, 10, 36, 106);
+            Color titlebar_color2 = Color.FromArgb(255, 166, 202, 240);
+            Color color = ThemeEngine.Current.ColorControlDark;
+            Color color2 = Color.FromArgb(255, 192, 192, 192);
+
+            Pen pen = ResPool.GetPen(ColorControl);
+            Rectangle borders = new Rectangle(0, 0, form.Width, form.Height);
+            WidgetPaint.DrawBorder3D(dc, borders, Border3DStyle.Raised);
+            // The 3d border is only 2 pixels wide, so we draw the innermost pixels ourselves
+            borders = new Rectangle(2, 2, form.Width - 5, form.Height - 5);
+            for (int i = 2; i < bdwidth; i++)
+            {
+                dc.DrawRectangle(pen, borders);
+                borders.Inflate(-1, -1);
+            }
+
+
+            bool draw_titlebar_enabled = false;
+            if (wm.Form.Parent != null && wm.Form.Parent is Form)
+            {
+                draw_titlebar_enabled = false;
+            }
+            else if (wm.IsActive && !wm.IsMaximized)
+            {
+                draw_titlebar_enabled = true;
+            }
+            if (draw_titlebar_enabled)
+            {
+                color = titlebar_color;
+                color2 = titlebar_color2;
+            }
+
+            Rectangle tb = new Rectangle(bdwidth, bdwidth, form.Width - (bdwidth * 2), tbheight - 1);
+
+            // HACK: For now always draw the titlebar until we get updates better
+            if (tb.Width > 0 && tb.Height > 0)
+            {
+                using (System.Drawing.Drawing2D.LinearGradientBrush gradient = new LinearGradientBrush(tb, color, color2, LinearGradientMode.Horizontal))
+                {
+                    dc.FillRectangle(gradient, tb);
+                }
+            }
+
+            if (!wm.IsMinimized)
+                // Draw the line just beneath the title bar
+                dc.DrawLine(ResPool.GetPen(SystemColors.Control), bdwidth,
+                        tbheight + bdwidth - 1, form.Width - bdwidth - 1,
+                        tbheight + bdwidth - 1);
+            return tb;
+        }
+
+        public override void DrawManagedWindowDecorations(Graphics dc, Rectangle clip, InternalWindowManager wm)
+        {
+#if debug
+			Console.WriteLine (DateTime.Now.ToLongTimeString () + " DrawManagedWindowDecorations");
+			dc.FillRectangle (Brushes.Black, clip);
+#endif
+            Rectangle tb = ManagedWindowDrawTitleBarAndBorders(dc, clip, wm);
+
+            Form form = wm.Form;
+            if (wm.ShowIcon)
+            {
+                Rectangle icon = ManagedWindowGetTitleBarIconArea(wm);
+                if (icon.IntersectsWith(clip))
+                    dc.DrawIcon(form.Icon, icon);
+                const int SpacingBetweenIconAndCaption = 2;
+                tb.Width -= icon.Right + SpacingBetweenIconAndCaption - tb.X;
+                tb.X = icon.Right + SpacingBetweenIconAndCaption;
+            }
+
+            foreach (TitleButton button in wm.TitleButtons.AllButtons)
+            {
+                tb.Width -= Math.Max(0, tb.Right - DrawTitleButton(dc, button, clip, form));
+            }
+            const int SpacingBetweenCaptionAndLeftMostButton = 3;
+            tb.Width -= SpacingBetweenCaptionAndLeftMostButton;
+
+            string window_caption = form.Text;
+            window_caption = window_caption.Replace(Environment.NewLine, string.Empty);
+
+            if (window_caption != null && window_caption != string.Empty)
+            {
+                StringFormat format = new StringFormat();
+                format.FormatFlags = StringFormatFlags.NoWrap;
+                format.Trimming = StringTrimming.EllipsisCharacter;
+                format.LineAlignment = StringAlignment.Center;
+
+                if (tb.IntersectsWith(clip))
+                    dc.DrawString(window_caption, WindowBorderFont,
+                        ThemeEngine.Current.ResPool.GetSolidBrush(Color.White),
+                        tb, format);
+            }
+        }
+
+        public override Size ManagedWindowButtonSize(InternalWindowManager wm)
+        {
+            int height = ManagedWindowTitleBarHeight(wm);
+            if (!wm.IsMaximized && !wm.IsMinimized)
+            {
+                if (wm.IsToolWindow)
+                    return new Size(SystemInformation.ToolWindowCaptionButtonSize.Width - 2,
+                            height - 5);
+                if (wm.Form.FormBorderStyle == FormBorderStyle.None)
+                    return Size.Empty;
+            }
+            else
+                height = SystemInformation.CaptionHeight;
+
+            return new Size(SystemInformation.CaptionButtonSize.Width - 2,
+                    height - 5);
+        }
+
+        private int DrawTitleButton(Graphics dc, TitleButton button, Rectangle clip, Form form)
+        {
+            if (!button.Visible)
+            {
+                return int.MaxValue;
+            }
+
+            if (button.Rectangle.IntersectsWith(clip))
+            {
+                ManagedWindowDrawTitleButton(dc, button, clip, form);
+            }
+            return button.Rectangle.Left;
+        }
+
+        protected virtual void ManagedWindowDrawTitleButton(Graphics dc, TitleButton button, Rectangle clip, Form form)
+        {
+            dc.FillRectangle(SystemBrushes.Control, button.Rectangle);
+
+            WidgetPaint.DrawCaptionButton(dc, button.Rectangle,
+                    button.Caption, button.State);
+        }
+
+        public override Rectangle ManagedWindowGetTitleBarIconArea(InternalWindowManager wm)
+        {
+            int bw = ManagedWindowBorderWidth(wm);
+            return new Rectangle(bw + 3, bw + 2, wm.IconWidth, wm.IconWidth);
+        }
+
+        public override Size ManagedWindowGetMenuButtonSize(InternalWindowManager wm)
+        {
+            Size result = SystemInformation.MenuButtonSize;
+            result.Width -= 2;
+            result.Height -= 4;
+            return result;
+        }
+
+        public override bool ManagedWindowTitleButtonHasHotElementStyle(TitleButton button, Form form)
+        {
+            return false;
+        }
+
+        public override void ManagedWindowDrawMenuButton(Graphics dc, TitleButton button, Rectangle clip, InternalWindowManager wm)
+        {
+            dc.FillRectangle(SystemBrushes.Control, button.Rectangle);
+            WidgetPaint.DrawCaptionButton(dc, button.Rectangle,
+                    button.Caption, button.State);
+        }
+
+        public override void ManagedWindowOnSizeInitializedOrChanged(Form form)
+        {
+        }
+        #endregion
+
+        #region WidgetPaint
+        public override void CPDrawBorder(Graphics graphics, Rectangle bounds, Color leftColor, int leftWidth,
+            ButtonBorderStyle leftStyle, Color topColor, int topWidth, ButtonBorderStyle topStyle,
+            Color rightColor, int rightWidth, ButtonBorderStyle rightStyle, Color bottomColor,
+            int bottomWidth, ButtonBorderStyle bottomStyle)
+        {
+            DrawBorderInternal(graphics, bounds.Left, bounds.Top, bounds.Left, bounds.Bottom - 1, leftWidth, leftColor, leftStyle, Border3DSide.Left);
+            DrawBorderInternal(graphics, bounds.Left, bounds.Top, bounds.Right - 1, bounds.Top, topWidth, topColor, topStyle, Border3DSide.Top);
+            DrawBorderInternal(graphics, bounds.Right - 1, bounds.Top, bounds.Right - 1, bounds.Bottom - 1, rightWidth, rightColor, rightStyle, Border3DSide.Right);
+            DrawBorderInternal(graphics, bounds.Left, bounds.Bottom - 1, bounds.Right - 1, bounds.Bottom - 1, bottomWidth, bottomColor, bottomStyle, Border3DSide.Bottom);
+        }
+
+        public override void CPDrawBorder(Graphics graphics, RectangleF bounds, Color leftColor, int leftWidth,
+            ButtonBorderStyle leftStyle, Color topColor, int topWidth, ButtonBorderStyle topStyle,
+            Color rightColor, int rightWidth, ButtonBorderStyle rightStyle, Color bottomColor,
+            int bottomWidth, ButtonBorderStyle bottomStyle)
+        {
+            DrawBorderInternal(graphics, bounds.Left, bounds.Top, bounds.Left, bounds.Bottom - 1, leftWidth, leftColor, leftStyle, Border3DSide.Left);
+            DrawBorderInternal(graphics, bounds.Left, bounds.Top, bounds.Right - 1, bounds.Top, topWidth, topColor, topStyle, Border3DSide.Top);
+            DrawBorderInternal(graphics, bounds.Right - 1, bounds.Top, bounds.Right - 1, bounds.Bottom - 1, rightWidth, rightColor, rightStyle, Border3DSide.Right);
+            DrawBorderInternal(graphics, bounds.Left, bounds.Bottom - 1, bounds.Right - 1, bounds.Bottom - 1, bottomWidth, bottomColor, bottomStyle, Border3DSide.Bottom);
+        }
+
+        public override void CPDrawBorder3D(Graphics graphics, Rectangle rectangle, Border3DStyle style, Border3DSide sides)
+        {
+            CPDrawBorder3D(graphics, rectangle, style, sides, ColorControl);
+        }
+
+        public override void CPDrawBorder3D(Graphics graphics, Rectangle rectangle, Border3DStyle style, Border3DSide sides, Color control_color)
+        {
+            var skin = Application.CurrentSkin;
+            Pen penTopLeft;
+            Pen penTopLeftInner;
+            Pen penBottomRight;
+            Pen penBottomRightInner;
+            Rectangle rect = new Rectangle(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
+            bool is_ColorControl = control_color.ToArgb() == ColorControl.ToArgb() ? true : false;
+
+            if ((style & Border3DStyle.Adjust) != 0)
+            {
+                rect.Y -= 2;
+                rect.X -= 2;
+                rect.Width += 4;
+                rect.Height += 4;
+            }
+
+            penTopLeft = penTopLeftInner = penBottomRight = penBottomRightInner = is_ColorControl ? SystemPens.Control : ResPool.GetPen(control_color);
+
+            CPColor cpcolor = CPColor.Empty;
+
+            if (!is_ColorControl)
+                cpcolor = ResPool.GetCPColor(control_color);
+
+            switch (style)
+            {
+                case Border3DStyle.Raised:
+                    penTopLeftInner = new Pen(skin.Border3DTopLeftInner);
+                    penBottomRight = new Pen(skin.Border3DBottomRight);
+                    penBottomRightInner = new Pen(skin.Border3DBottomRightInner);
+                    break;
+                case Border3DStyle.Sunken:
+                    penTopLeft = new Pen(skin.Border3DBottomRightInner);
+                    penTopLeftInner = new Pen(skin.Border3DBottomRight);
+                    penBottomRight = new Pen(skin.Border3DTopLeftInner);
+                    break;
+                case Border3DStyle.Etched:
+                    penTopLeft = new Pen(skin.Border3DBottomRightInner);
+                    penTopLeftInner = new Pen(skin.Border3DTopLeftInner);
+                    break;
+                case Border3DStyle.RaisedOuter:
+                    penBottomRight = new Pen(skin.Border3DBottomRight);
+                    break;
+                case Border3DStyle.SunkenOuter:
+                    penTopLeft = new Pen(skin.Border3DBottomRightInner);
+                    penBottomRight = new Pen(skin.Border3DTopLeftInner);
+                    break;
+                case Border3DStyle.RaisedInner:
+                    penTopLeft = new Pen(skin.Border3DTopLeftInner);
+                    penBottomRight = new Pen(skin.Border3DBottomRightInner);
+                    break;
+                case Border3DStyle.SunkenInner:
+                    penTopLeft = new Pen(skin.Border3DBottomRight);
+                    break;
+                case Border3DStyle.Flat:
+                    penTopLeft = penBottomRight = new Pen(skin.DefaultForeColor);
+                    break;
+                case Border3DStyle.Bump:
+                    penTopLeftInner = penBottomRight = new Pen(skin.Border3DBottomRight);
+                    break;
+                default:
+                    break;
+            }
+
+            bool inner = ((style != Border3DStyle.RaisedOuter) && (style != Border3DStyle.SunkenOuter));
+
+            if ((sides & Border3DSide.Middle) != 0)
+            {
+                Brush brush = is_ColorControl ? SystemBrushes.Control : ResPool.GetSolidBrush(control_color);
+                graphics.FillRectangle(brush, rect);
+            }
+
+            if ((sides & Border3DSide.Left) != 0)
+            {
+                graphics.DrawLine(penTopLeft, rect.Left, rect.Bottom - 2, rect.Left, rect.Top);
+                if ((rect.Width > 2) && inner)
+                    graphics.DrawLine(penTopLeftInner, rect.Left + 1, rect.Bottom - 2, rect.Left + 1, rect.Top);
+            }
+
+            if ((sides & Border3DSide.Top) != 0)
+            {
+                graphics.DrawLine(penTopLeft, rect.Left, rect.Top, rect.Right - 2, rect.Top);
+                if ((rect.Height > 2) && inner)
+                    graphics.DrawLine(penTopLeftInner, rect.Left + 1, rect.Top + 1, rect.Right - 3, rect.Top + 1);
+            }
+
+            if ((sides & Border3DSide.Right) != 0)
+            {
+                graphics.DrawLine(penBottomRight, rect.Right - 1, rect.Top, rect.Right - 1, rect.Bottom - 1);
+                if ((rect.Width > 3) && inner)
+                    graphics.DrawLine(penBottomRightInner, rect.Right - 2, rect.Top + 1, rect.Right - 2, rect.Bottom - 2);
+            }
+
+            if ((sides & Border3DSide.Bottom) != 0)
+            {
+                graphics.DrawLine(penBottomRight, rect.Left, rect.Bottom - 1, rect.Right - 1, rect.Bottom - 1);
+                if ((rect.Height > 3) && inner)
+                    graphics.DrawLine(penBottomRightInner, rect.Left + 1, rect.Bottom - 2, rect.Right - 2, rect.Bottom - 2);
+            }
+        }
+
+        public override void CPDrawButton(Graphics dc, Rectangle rectangle, ButtonState state)
+        {
+            CPDrawButtonInternal(dc, rectangle, state, SystemPens.ControlDarkDark, SystemPens.ControlDark, SystemPens.ControlLight);
+        }
+
+        private void CPDrawButtonInternal(Graphics dc, Rectangle rectangle, ButtonState state, Pen DarkPen, Pen NormalPen, Pen LightPen)
+        {
+            // sadly enough, the rectangle gets always filled with a hatchbrush
+            dc.FillRectangle(new SolidBrush(Application.CurrentSkin.ButtonBackColor),
+                      rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2);
+
+            if ((state & ButtonState.All) == ButtonState.All || ((state & ButtonState.Checked) == ButtonState.Checked && (state & ButtonState.Flat) == ButtonState.Flat))
+            {
+                dc.FillRectangle(new SolidBrush(Application.CurrentSkin.ButtonBackColor_Checked), rectangle.X + 2, rectangle.Y + 2, rectangle.Width - 4, rectangle.Height - 4);
+
+                dc.DrawRectangle(new Pen(new SolidBrush(Application.CurrentSkin.ButtonBorderColor), Application.CurrentSkin.ButtonBorderWidth), rectangle.X, rectangle.Y, rectangle.Width - 1, rectangle.Height - 1);
+            }
+            else
+            if ((state & ButtonState.Flat) == ButtonState.Flat)
+            {
+                dc.DrawRectangle(new Pen(new SolidBrush(Application.CurrentSkin.ButtonBorderColor), Application.CurrentSkin.ButtonBorderWidth), rectangle.X, rectangle.Y, rectangle.Width - 1, rectangle.Height - 1);
+            }
+            else
+            if ((state & ButtonState.Checked) == ButtonState.Checked)
+            {
+                dc.FillRectangle(new SolidBrush(Application.CurrentSkin.ButtonBackColor_Checked), rectangle.X + 2, rectangle.Y + 2, rectangle.Width - 4, rectangle.Height - 4);
+
+                Pen pen = new Pen(new SolidBrush(Application.CurrentSkin.Border3DTopLeftInner));
+                dc.DrawLine(pen, rectangle.X, rectangle.Y, rectangle.X, rectangle.Bottom - 2);
+                dc.DrawLine(pen, rectangle.X + 1, rectangle.Y, rectangle.Right - 2, rectangle.Y);
+
+                pen = new Pen(new SolidBrush(Application.CurrentSkin.Border3DBottomRight));
+                dc.DrawLine(pen, rectangle.X + 1, rectangle.Y + 1, rectangle.X + 1, rectangle.Bottom - 3);
+                dc.DrawLine(pen, rectangle.X + 2, rectangle.Y + 1, rectangle.Right - 3, rectangle.Y + 1);
+
+                pen = new Pen(new SolidBrush(Application.CurrentSkin.Border3DBottomRightInner));
+                dc.DrawLine(pen, rectangle.X, rectangle.Bottom - 1, rectangle.Right - 2, rectangle.Bottom - 1);
+                dc.DrawLine(pen, rectangle.Right - 1, rectangle.Y, rectangle.Right - 1, rectangle.Bottom - 1);
+            }
+            else
+            if (((state & ButtonState.Pushed) == ButtonState.Pushed) && ((state & ButtonState.Normal) == ButtonState.Normal))
+            {
+                Pen pen = new Pen(new SolidBrush(Application.CurrentSkin.Border3DTopLeftInner));
+                dc.DrawLine(pen, rectangle.X, rectangle.Y, rectangle.X, rectangle.Bottom - 2);
+                dc.DrawLine(pen, rectangle.X + 1, rectangle.Y, rectangle.Right - 2, rectangle.Y);
+
+                pen = new Pen(new SolidBrush(Application.CurrentSkin.Border3DBottomRight));
+                dc.DrawLine(pen, rectangle.X + 1, rectangle.Y + 1, rectangle.X + 1, rectangle.Bottom - 3);
+                dc.DrawLine(pen, rectangle.X + 2, rectangle.Y + 1, rectangle.Right - 3, rectangle.Y + 1);
+
+                pen = new Pen(new SolidBrush(Application.CurrentSkin.Border3DBottomRightInner));
+                dc.DrawLine(pen, rectangle.X, rectangle.Bottom - 1, rectangle.Right - 2, rectangle.Bottom - 1);
+                dc.DrawLine(pen, rectangle.Right - 1, rectangle.Y, rectangle.Right - 1, rectangle.Bottom - 1);
+            }
+            else
+            if (((state & ButtonState.Inactive) == ButtonState.Inactive) || ((state & ButtonState.Normal) == ButtonState.Normal))
+            {
+                Pen pen = new Pen(new SolidBrush(Application.CurrentSkin.Border3DTopLeftInner));
+                dc.DrawLine(pen, rectangle.X, rectangle.Y, rectangle.Right - 2, rectangle.Y);
+                dc.DrawLine(pen, rectangle.X, rectangle.Y, rectangle.X, rectangle.Bottom - 2);
+
+                pen = new Pen(new SolidBrush(Application.CurrentSkin.Border3DBottomRight));
+                dc.DrawLine(pen, rectangle.X + 1, rectangle.Bottom - 2, rectangle.Right - 2, rectangle.Bottom - 2);
+                dc.DrawLine(pen, rectangle.Right - 2, rectangle.Y + 1, rectangle.Right - 2, rectangle.Bottom - 3);
+
+                pen = new Pen(new SolidBrush(Application.CurrentSkin.Border3DBottomRightInner));
+                dc.DrawLine(pen, rectangle.X, rectangle.Bottom - 1, rectangle.Right - 1, rectangle.Bottom - 1);
+                dc.DrawLine(pen, rectangle.Right - 1, rectangle.Y, rectangle.Right - 1, rectangle.Bottom - 2);
+            }
+        }
+
+
+        public override void CPDrawCaptionButton(Graphics graphics, Rectangle rectangle, CaptionButton button, ButtonState state)
+        {
+            Rectangle captionRect;
+            int lineWidth;
+
+            CPDrawButtonInternal(graphics, rectangle, state, SystemPens.ControlDarkDark, SystemPens.ControlDark, SystemPens.ControlLightLight);
+
+            if (rectangle.Width < rectangle.Height)
+            {
+                captionRect = new Rectangle(rectangle.X + 1, rectangle.Y + rectangle.Height / 2 - rectangle.Width / 2 + 1, rectangle.Width - 4, rectangle.Width - 4);
+            }
+            else
+            {
+                captionRect = new Rectangle(rectangle.X + rectangle.Width / 2 - rectangle.Height / 2 + 1, rectangle.Y + 1, rectangle.Height - 4, rectangle.Height - 4);
+            }
+
+            if ((state & ButtonState.Pushed) != 0)
+            {
+                captionRect = new Rectangle(rectangle.X + 2, rectangle.Y + 2, rectangle.Width - 3, rectangle.Height - 3);
+            }
+
+            /* Make sure we've got at least a line width of 1 */
+            lineWidth = Math.Max(1, captionRect.Width / 7);
+
+            switch (button)
+            {
+                case CaptionButton.Close:
+                    {
+                        Pen pen;
+
+                        if ((state & ButtonState.Inactive) != 0)
+                        {
+                            pen = ResPool.GetSizedPen(ColorControlLight, lineWidth);
+                            DrawCaptionHelper(graphics, ColorControlLight, pen, lineWidth, 1, captionRect, button);
+
+                            pen = ResPool.GetSizedPen(ColorControlDark, lineWidth);
+                            DrawCaptionHelper(graphics, ColorControlDark, pen, lineWidth, 0, captionRect, button);
+                            return;
+                        }
+                        else
+                        {
+                            pen = ResPool.GetSizedPen(ColorControlText, lineWidth);
+                            DrawCaptionHelper(graphics, ColorControlText, pen, lineWidth, 0, captionRect, button);
+                            return;
+                        }
+                    }
+
+                case CaptionButton.Help:
+                case CaptionButton.Maximize:
+                case CaptionButton.Minimize:
+                case CaptionButton.Restore:
+                    {
+                        if ((state & ButtonState.Inactive) != 0)
+                        {
+                            DrawCaptionHelper(graphics, ColorControlLight, SystemPens.ControlLightLight, lineWidth, 1, captionRect, button);
+
+                            DrawCaptionHelper(graphics, ColorControlDark, SystemPens.ControlDark, lineWidth, 0, captionRect, button);
+                            return;
+                        }
+                        else
+                        {
+                            DrawCaptionHelper(graphics, ColorControlText, SystemPens.ControlText, lineWidth, 0, captionRect, button);
+                            return;
+                        }
+                    }
+            }
+        }
+
+        public override void CPDrawCheckBox(Graphics dc, Rectangle rectangle, ButtonState state)
+        {
+            CPDrawCheckBoxInternal(dc, rectangle, state, false /* mixed */);
+        }
+
+        private void CPDrawCheckBoxInternal(Graphics dc, Rectangle rectangle, ButtonState state, bool mixed)
+        {
+            Pen check_pen = (mixed) ? Pens.Gray : Pens.Black;
+
+            Rectangle cb_rect = new Rectangle(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
+
+            if ((state & ButtonState.All) == ButtonState.All)
+            {
+                cb_rect.Width -= 2;
+                cb_rect.Height -= 2;
+
+                dc.FillRectangle(SystemBrushes.Control, cb_rect.X, cb_rect.Y, cb_rect.Width - 1, cb_rect.Height - 1);
+                dc.DrawRectangle(SystemPens.ControlDark, cb_rect.X, cb_rect.Y, cb_rect.Width - 1, cb_rect.Height - 1);
+
+                check_pen = SystemPens.ControlDark;
+            }
+            else
+            if ((state & ButtonState.Flat) == ButtonState.Flat)
+            {
+                cb_rect.Width -= 2;
+                cb_rect.Height -= 2;
+
+                if ((state & ButtonState.Inactive) == ButtonState.Inactive)
+                    dc.FillRectangle(SystemBrushes.ControlLight, cb_rect.X, cb_rect.Y, cb_rect.Width - 1, cb_rect.Height - 1);
+                else
+                    dc.FillRectangle(Brushes.White, cb_rect.X, cb_rect.Y, cb_rect.Width - 1, cb_rect.Height - 1);
+                dc.DrawRectangle(SystemPens.ControlDark, cb_rect.X, cb_rect.Y, cb_rect.Width - 1, cb_rect.Height - 1);
+            }
+            else
+            {
+                cb_rect.Width -= 1;
+                cb_rect.Height -= 1;
+
+                int check_box_visible_size = (cb_rect.Height > cb_rect.Width) ? cb_rect.Width : cb_rect.Height;
+
+                int x_pos = Math.Max(0, cb_rect.X + (cb_rect.Width / 2) - check_box_visible_size / 2);
+                int y_pos = Math.Max(0, cb_rect.Y + (cb_rect.Height / 2) - check_box_visible_size / 2);
+
+                Rectangle rect = new Rectangle(x_pos, y_pos, check_box_visible_size, check_box_visible_size);
+
+                if (((state & ButtonState.Pushed) == ButtonState.Pushed) || ((state & ButtonState.Inactive) == ButtonState.Inactive))
+                {
+                    dc.FillRectangle(ResPool.GetHatchBrush(HatchStyle.Percent50,
+                                         Color.FromArgb(Clamp(ColorControl.R + 3, 0, 255),
+                                                 ColorControl.G, ColorControl.B),
+                                         ColorControl), rect.X + 2, rect.Y + 2, rect.Width - 3, rect.Height - 3);
+                }
+                else
+                    dc.FillRectangle(SystemBrushes.ControlLightLight, rect.X + 2, rect.Y + 2, rect.Width - 3, rect.Height - 3);
+
+                Pen pen = SystemPens.ControlDark;
+                dc.DrawLine(pen, rect.X, rect.Y, rect.X, rect.Bottom - 1);
+                dc.DrawLine(pen, rect.X + 1, rect.Y, rect.Right - 1, rect.Y);
+
+                pen = SystemPens.ControlDarkDark;
+                dc.DrawLine(pen, rect.X + 1, rect.Y + 1, rect.X + 1, rect.Bottom - 2);
+                dc.DrawLine(pen, rect.X + 2, rect.Y + 1, rect.Right - 2, rect.Y + 1);
+
+                pen = SystemPens.ControlLightLight;
+                dc.DrawLine(pen, rect.Right, rect.Y, rect.Right, rect.Bottom);
+                dc.DrawLine(pen, rect.X, rect.Bottom, rect.Right, rect.Bottom);
+
+                // oh boy, matching ms is like fighting against windmills
+                using (Pen h_pen = new Pen(ResPool.GetHatchBrush(HatchStyle.Percent50,
+                                           Color.FromArgb(Clamp(ColorControl.R + 3, 0, 255),
+                                                   ColorControl.G, ColorControl.B), ColorControl)))
+                {
+                    dc.DrawLine(h_pen, rect.X + 1, rect.Bottom - 1, rect.Right - 1, rect.Bottom - 1);
+                    dc.DrawLine(h_pen, rect.Right - 1, rect.Y + 1, rect.Right - 1, rect.Bottom - 1);
+                }
+
+                if ((state & ButtonState.Inactive) == ButtonState.Inactive)
+                    check_pen = SystemPens.ControlDark;
+            }
+
+            if ((state & ButtonState.Checked) == ButtonState.Checked)
+            {
+                int check_size = (cb_rect.Height > cb_rect.Width) ? cb_rect.Width / 2 : cb_rect.Height / 2;
+
+                if (check_size < 7)
+                {
+                    int lineWidth = Math.Max(3, check_size / 3);
+                    int Scale = Math.Max(1, check_size / 9);
+
+                    Rectangle rect = new Rectangle(cb_rect.X + (cb_rect.Width / 2) - (int)Math.Ceiling((float)check_size / 2) - 1, cb_rect.Y + (cb_rect.Height / 2) - (check_size / 2) - 1,
+                                    check_size, check_size);
+
+                    for (int i = 0; i < lineWidth; i++)
+                    {
+                        dc.DrawLine(check_pen, rect.Left + lineWidth / 2, rect.Top + lineWidth + i, rect.Left + lineWidth / 2 + 2 * Scale, rect.Top + lineWidth + 2 * Scale + i);
+                        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);
+                    }
+                }
+                else
+                {
+                    int lineWidth = Math.Max(3, check_size / 3) + 1;
+
+                    int x_half = cb_rect.Width / 2;
+                    int y_half = cb_rect.Height / 2;
+
+                    Rectangle rect = new Rectangle(cb_rect.X + x_half - (check_size / 2) - 1, cb_rect.Y + y_half - (check_size / 2),
+                                    check_size, check_size);
+
+                    int gradient_left = check_size / 3;
+                    int gradient_right = check_size - gradient_left - 1;
+
+
+                    for (int i = 0; i < lineWidth; i++)
+                    {
+                        dc.DrawLine(check_pen, rect.X, rect.Bottom - 1 - gradient_left - i, rect.X + gradient_left, rect.Bottom - 1 - i);
+                        dc.DrawLine(check_pen, rect.X + gradient_left, rect.Bottom - 1 - i, rect.Right - 1, rect.Bottom - i - 1 - gradient_right);
+                    }
+                }
+            }
+        }
+
+        public override void CPDrawComboButton(Graphics graphics, Rectangle rectangle, ButtonState state)
+        {
+            Point[] arrow = new Point[3];
+            Point P1;
+            Point P2;
+            Point P3;
+            int centerX;
+            int centerY;
+            int shiftX;
+            int shiftY;
+            Rectangle rect;
+
+            if ((state & ButtonState.Checked) != 0)
+            {
+                graphics.FillRectangle(ResPool.GetHatchBrush(HatchStyle.Percent50, ColorControlLightLight, ColorControlLight), rectangle);
+            }
+
+            if ((state & ButtonState.Flat) != 0)
+            {
+                WidgetPaint.DrawBorder(graphics, rectangle, ColorControlDark, ButtonBorderStyle.Solid);
+            }
+            else
+            {
+                if ((state & (ButtonState.Pushed | ButtonState.Checked)) != 0)
+                {
+                    // this needs to render like a pushed button - jba
+                    // CPDrawBorder3D(graphics, rectangle, Border3DStyle.Sunken, Border3DSide.Left | Border3DSide.Top | Border3DSide.Right | Border3DSide.Bottom, ColorControl);
+                    Rectangle trace_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max(rectangle.Width - 1, 0), Math.Max(rectangle.Height - 1, 0));
+                    graphics.DrawRectangle(SystemPens.ControlDark, trace_rectangle);
+                }
+                else
+                {
+                    CPDrawBorder3D(graphics, rectangle, Border3DStyle.Raised, Border3DSide.Left | Border3DSide.Top | Border3DSide.Right | Border3DSide.Bottom, ColorControl);
+                }
+            }
+
+            rect = new Rectangle(rectangle.X + rectangle.Width / 4, rectangle.Y + rectangle.Height / 4, rectangle.Width / 2, rectangle.Height / 2);
+            centerX = rect.Left + rect.Width / 2;
+            centerY = rect.Top + rect.Height / 2;
+            shiftX = Math.Max(1, rect.Width / 8);
+            shiftY = Math.Max(1, rect.Height / 8);
+
+            if ((state & ButtonState.Pushed) != 0)
+            {
+                shiftX++;
+                shiftY++;
+            }
+
+            rect.Y -= shiftY;
+            centerY -= shiftY;
+            P1 = new Point(rect.Left, centerY);
+            P2 = new Point(rect.Right, centerY);
+            P3 = new Point(centerX, rect.Bottom);
+
+            arrow[0] = P1;
+            arrow[1] = P2;
+            arrow[2] = P3;
+
+            /* Draw the arrow */
+            if ((state & ButtonState.Inactive) != 0)
+            {
+                /* Move away from the shadow */
+                arrow[0].X += 1; arrow[0].Y += 1;
+                arrow[1].X += 1; arrow[1].Y += 1;
+                arrow[2].X += 1; arrow[2].Y += 1;
+
+                graphics.FillPolygon(SystemBrushes.ControlLightLight, arrow, FillMode.Winding);
+
+                arrow[0] = P1;
+                arrow[1] = P2;
+                arrow[2] = P3;
+
+                graphics.FillPolygon(SystemBrushes.ControlDark, arrow, FillMode.Winding);
+            }
+            else
+            {
+                graphics.FillPolygon(SystemBrushes.ControlText, arrow, FillMode.Winding);
+            }
+        }
+
+        public override void CPDrawContainerGrabHandle(Graphics graphics, Rectangle bounds)
+        {
+            Pen pen = Pens.Black;
+            Rectangle rect = new Rectangle(bounds.X, bounds.Y, bounds.Width - 1, bounds.Height - 1);    // Dunno why, but MS does it that way, too
+            int X;
+            int Y;
+
+            graphics.FillRectangle(SystemBrushes.ControlLightLight, rect);
+            graphics.DrawRectangle(pen, rect);
+
+            X = rect.X + rect.Width / 2;
+            Y = rect.Y + rect.Height / 2;
+
+            /* Draw the cross */
+            graphics.DrawLine(pen, X, rect.Y + 2, X, rect.Bottom - 2);
+            graphics.DrawLine(pen, rect.X + 2, Y, rect.Right - 2, Y);
+
+            /* Draw 'arrows' for vertical lines */
+            graphics.DrawLine(pen, X - 1, rect.Y + 3, X + 1, rect.Y + 3);
+            graphics.DrawLine(pen, X - 1, rect.Bottom - 3, X + 1, rect.Bottom - 3);
+
+            /* Draw 'arrows' for horizontal lines */
+            graphics.DrawLine(pen, rect.X + 3, Y - 1, rect.X + 3, Y + 1);
+            graphics.DrawLine(pen, rect.Right - 3, Y - 1, rect.Right - 3, Y + 1);
+        }
+
+        public virtual void DrawFlatStyleFocusRectangle(Graphics graphics, Rectangle rectangle, ButtonBase button, Color foreColor, Color backColor)
+        {
+            // make a rectange to trace around border of the button
+            Rectangle trace_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max(rectangle.Width - 1, 0), Math.Max(rectangle.Height - 1, 0));
+
+            Color outerColor = foreColor;
+            // adjust focus color according to the flatstyle
+            if (button.FlatStyle == FlatStyle.Popup && !button.is_pressed)
+            {
+                outerColor = (backColor.ToArgb() == ColorControl.ToArgb()) ? WidgetPaint.Dark(ColorControl) : ColorControlText;
+            }
+
+            // draw the outer rectangle
+            graphics.DrawRectangle(ResPool.GetPen(outerColor), trace_rectangle);
+
+            // draw the inner rectangle						
+            if (button.FlatStyle == FlatStyle.Popup)
+            {
+                DrawInnerFocusRectangle(graphics, Rectangle.Inflate(rectangle, -4, -4), backColor);
+            }
+            else
+            {
+                // draw a flat inner rectangle
+                Pen pen = ResPool.GetPen(WidgetPaint.LightLight(backColor));
+                graphics.DrawRectangle(pen, Rectangle.Inflate(trace_rectangle, -4, -4));
+            }
+        }
+
+        public virtual void DrawInnerFocusRectangle(Graphics graphics, Rectangle rectangle, Color backColor)
+        {
+            // make a rectange to trace around border of the button
+            Rectangle trace_rectangle = new Rectangle(rectangle.X, rectangle.Y, Math.Max(rectangle.Width - 1, 0), Math.Max(rectangle.Height - 1, 0));
+
+#if NotUntilCairoIsFixed
+			Color colorBackInverted = Color.FromArgb (Math.Abs (backColor.R-255), Math.Abs (backColor.G-255), Math.Abs (backColor.B-255));
+			DashStyle oldStyle; // used for caching old penstyle
+			Pen pen = ResPool.GetPen (colorBackInverted);
+
+			oldStyle = pen.DashStyle; 
+			pen.DashStyle = DashStyle.Dot;
+
+			graphics.DrawRectangle (pen, trace_rectangle);
+			pen.DashStyle = oldStyle;
+#else
+            CPDrawFocusRectangle(graphics, trace_rectangle, Color.Wheat, backColor);
+#endif
+        }
+
+
+        public override void CPDrawFocusRectangle(Graphics graphics, Rectangle rectangle, Color foreColor, Color backColor)
+        {
+            Rectangle rect = rectangle;
+            Pen pen;
+            HatchBrush brush;
+
+            if (backColor.GetBrightness() >= 0.5)
+            {
+                foreColor = Color.Transparent;
+                backColor = Color.Black;
+
+            }
+            else
+            {
+                backColor = Color.FromArgb(Math.Abs(backColor.R - 255), Math.Abs(backColor.G - 255), Math.Abs(backColor.B - 255));
+                foreColor = Color.Black;
+            }
+
+            brush = ResPool.GetHatchBrush(HatchStyle.Percent50, backColor, foreColor);
+            pen = new Pen(brush, 1);
+
+            rect.Width--;
+            rect.Height--;
+
+            graphics.DrawRectangle(pen, rect);
+            pen.Dispose();
+        }
+
+        public override void CPDrawGrabHandle(Graphics graphics, Rectangle rectangle, bool primary, bool enabled)
+        {
+            Brush sb;
+            Pen pen;
+
+            if (primary == true)
+            {
+                pen = Pens.Black;
+                if (enabled == true)
+                {
+                    sb = Brushes.White;
+                }
+                else
+                {
+                    sb = SystemBrushes.Control;
+                }
+            }
+            else
+            {
+                pen = Pens.White;
+                if (enabled == true)
+                {
+                    sb = Brushes.Black;
+                }
+                else
+                {
+                    sb = SystemBrushes.Control;
+                }
+            }
+            graphics.FillRectangle(sb, rectangle);
+            graphics.DrawRectangle(pen, rectangle);
+        }
+
+
+        public override void CPDrawGrid(Graphics graphics, Rectangle area, Size pixelsBetweenDots, Color backColor)
+        {
+            Color foreColor;
+            int h;
+            int b;
+            int s;
+
+            WidgetPaint.Color2HBS(backColor, out h, out b, out s);
+
+            if (b > 127)
+            {
+                foreColor = Color.Black;
+            }
+            else
+            {
+                foreColor = Color.White;
+            }
+
+            // still not perfect. it seems that ms calculates the position of the first dot or line
+
+            using (Pen pen = new Pen(foreColor))
+            {
+                pen.DashPattern = new float[] { 1.0f, pixelsBetweenDots.Width - 1 };
+
+                for (int y = area.Top; y < area.Bottom; y += pixelsBetweenDots.Height)
+                    graphics.DrawLine(pen, area.X, y, area.Right - 1, y);
+            }
+        }
+
+        public override void CPDrawImageDisabled(Graphics graphics, Image image, int x, int y, Color background)
+        {
+            /*
+				Microsoft seems to ignore the background and simply make
+				the image grayscale. At least when having > 256 colors on
+				the display.
+			*/
+
+            if (imagedisabled_attributes == null)
+            {
+                imagedisabled_attributes = new ImageAttributes();
+                ColorMatrix colorMatrix = new ColorMatrix(new float[][] {
+					  // This table would create a perfect grayscale image, based on luminance
+					  //				new float[]{0.3f,0.3f,0.3f,0,0},
+					  //				new float[]{0.59f,0.59f,0.59f,0,0},
+					  //				new float[]{0.11f,0.11f,0.11f,0,0},
+					  //				new float[]{0,0,0,1,0,0},
+					  //				new float[]{0,0,0,0,1,0},
+					  //				new float[]{0,0,0,0,0,1}
+		
+					  // This table generates a image that is grayscaled and then
+					  // brightened up. Seems to match MS close enough.
+					  new float[]{0.2f,0.2f,0.2f,0,0},
+                      new float[]{0.41f,0.41f,0.41f,0,0},
+                      new float[]{0.11f,0.11f,0.11f,0,0},
+                      new float[]{0.15f,0.15f,0.15f,1,0,0},
+                      new float[]{0.15f,0.15f,0.15f,0,1,0},
+                      new float[]{0.15f,0.15f,0.15f,0,0,1}
+                  });
+
+                imagedisabled_attributes.SetColorMatrix(colorMatrix);
+            }
+
+            graphics.DrawImage(image, new Rectangle(x, y, image.Width, image.Height), 0, 0, image.Width, image.Height, GraphicsUnit.Pixel, imagedisabled_attributes);
+
+        }
+
+
+        public override void CPDrawLockedFrame(Graphics graphics, Rectangle rectangle, bool primary)
+        {
+            Pen penBorder;
+            Pen penInside;
+
+            if (primary)
+            {
+                penBorder = ResPool.GetSizedPen(Color.White, 2);
+                penInside = ResPool.GetPen(Color.Black);
+            }
+            else
+            {
+                penBorder = ResPool.GetSizedPen(Color.Black, 2);
+                penInside = ResPool.GetPen(Color.White);
+            }
+            penBorder.Alignment = PenAlignment.Inset;
+            penInside.Alignment = PenAlignment.Inset;
+
+            graphics.DrawRectangle(penBorder, rectangle);
+            graphics.DrawRectangle(penInside, rectangle.X + 2, rectangle.Y + 2, rectangle.Width - 5, rectangle.Height - 5);
+        }
+
+
+        public override void CPDrawMenuGlyph(Graphics graphics, Rectangle rectangle, MenuGlyph glyph, Color color, Color backColor)
+        {
+            Rectangle rect;
+            int lineWidth;
+
+            if (backColor != Color.Empty)
+                graphics.FillRectangle(ResPool.GetSolidBrush(backColor), rectangle);
+
+            Brush brush = ResPool.GetSolidBrush(color);
+
+            switch (glyph)
+            {
+                case MenuGlyph.Arrow:
+                    {
+                        float height = rectangle.Height * 0.7f;
+                        float width = height / 2.0f;
+
+                        PointF ddCenter = new PointF(rectangle.X + ((rectangle.Width - width) / 2.0f), rectangle.Y + (rectangle.Height / 2.0f));
+
+                        PointF[] vertices = new PointF[3];
+                        vertices[0].X = ddCenter.X;
+                        vertices[0].Y = ddCenter.Y - (height / 2.0f);
+                        vertices[1].X = ddCenter.X;
+                        vertices[1].Y = ddCenter.Y + (height / 2.0f);
+                        vertices[2].X = ddCenter.X + width + 0.1f;
+                        vertices[2].Y = ddCenter.Y;
+
+                        graphics.FillPolygon(brush, vertices);
+
+                        return;
+                    }
+
+                case MenuGlyph.Bullet:
+                    {
+
+                        lineWidth = Math.Max(2, rectangle.Width / 3);
+                        rect = new Rectangle(rectangle.X + lineWidth, rectangle.Y + lineWidth, rectangle.Width - lineWidth * 2, rectangle.Height - lineWidth * 2);
+
+                        graphics.FillEllipse(brush, rect);
+
+                        return;
+                    }
+
+                case MenuGlyph.Checkmark:
+                    {
+
+                        Pen pen = ResPool.GetPen(color);
+                        lineWidth = Math.Max(2, rectangle.Width / 6);
+                        rect = new Rectangle(rectangle.X + lineWidth, rectangle.Y + lineWidth, rectangle.Width - lineWidth * 2, rectangle.Height - lineWidth * 2);
+
+                        int Scale = Math.Max(1, rectangle.Width / 12);
+                        int top = (rect.Y + lineWidth + ((rect.Height - ((2 * Scale) + lineWidth)) / 2));
+
+                        for (int i = 0; i < lineWidth; i++)
+                        {
+                            graphics.DrawLine(pen, rect.Left + lineWidth / 2, top + i, rect.Left + lineWidth / 2 + 2 * Scale, top + 2 * Scale + i);
+                            graphics.DrawLine(pen, rect.Left + lineWidth / 2 + 2 * Scale, top + 2 * Scale + i, rect.Left + lineWidth / 2 + 6 * Scale, top - 2 * Scale + i);
+                        }
+                        return;
+                    }
+            }
+
+        }
+
+        public override void CPDrawMixedCheckBox(Graphics graphics, Rectangle rectangle, ButtonState state)
+        {
+            CPDrawCheckBoxInternal(graphics, rectangle, state, true /* mixed */);
+        }
+
+        public override void CPDrawRadioButton(Graphics dc, Rectangle rectangle, ButtonState state)
+        {
+            CPColor cpcolor = ResPool.GetCPColor(ColorControl);
+
+            Color dot_color = Color.Black;
+
+            Color top_left_outer = Color.Black;
+            Color top_left_inner = Color.Black;
+            Color bottom_right_outer = Color.Black;
+            Color bottom_right_inner = Color.Black;
+
+            int ellipse_diameter = (rectangle.Width > rectangle.Height) ? (int)(rectangle.Height * 0.9f) : (int)(rectangle.Width * 0.9f);
+            int radius = ellipse_diameter / 2;
+
+            Rectangle rb_rect = new Rectangle(rectangle.X + (rectangle.Width / 2) - radius, rectangle.Y + (rectangle.Height / 2) - radius, ellipse_diameter, ellipse_diameter);
+
+            Brush brush = null;
+
+            if ((state & ButtonState.All) == ButtonState.All)
+            {
+                brush = ResPool.GetHatchBrush(HatchStyle.Percent50, Color.FromArgb(Clamp(ColorControl.R + 3, 0, 255),
+                                                     ColorControl.G, ColorControl.B), ColorControl);
+                dot_color = cpcolor.Dark;
+            }
+            else
+            if ((state & ButtonState.Flat) == ButtonState.Flat)
+            {
+                if (((state & ButtonState.Inactive) == ButtonState.Inactive) || ((state & ButtonState.Pushed) == ButtonState.Pushed))
+                    brush = ResPool.GetHatchBrush(HatchStyle.Percent50, Color.FromArgb(Clamp(ColorControl.R + 3, 0, 255), ColorControl.G, ColorControl.B), ColorControl);
+                else
+                    brush = SystemBrushes.ControlLightLight;
+            }
+            else
+            {
+                if (((state & ButtonState.Inactive) == ButtonState.Inactive) || ((state & ButtonState.Pushed) == ButtonState.Pushed))
+                    brush = ResPool.GetHatchBrush(HatchStyle.Percent50, Color.FromArgb(Clamp(ColorControl.R + 3, 0, 255), ColorControl.G, ColorControl.B), ColorControl);
+                else
+                    brush = SystemBrushes.ControlLightLight;
+
+                top_left_outer = cpcolor.Dark;
+                top_left_inner = cpcolor.DarkDark;
+                bottom_right_outer = cpcolor.Light;
+                bottom_right_inner = Color.Transparent;
+
+                if ((state & ButtonState.Inactive) == ButtonState.Inactive)
+                    dot_color = cpcolor.Dark;
+            }
+
+            dc.FillEllipse(brush, rb_rect.X + 1, rb_rect.Y + 1, ellipse_diameter - 1, ellipse_diameter - 1);
+
+            int line_width = Math.Max(1, (int)(ellipse_diameter * 0.08f));
+
+            dc.DrawArc(ResPool.GetSizedPen(top_left_outer, line_width), rb_rect, 135.0f, 180.0f);
+            dc.DrawArc(ResPool.GetSizedPen(top_left_inner, line_width), Rectangle.Inflate(rb_rect, -line_width, -line_width), 135.0f, 180.0f);
+            dc.DrawArc(ResPool.GetSizedPen(bottom_right_outer, line_width), rb_rect, 315.0f, 180.0f);
+
+            if (bottom_right_inner != Color.Transparent)
+                dc.DrawArc(ResPool.GetSizedPen(bottom_right_inner, line_width), Rectangle.Inflate(rb_rect, -line_width, -line_width), 315.0f, 180.0f);
+            else
+                using (Pen h_pen = new Pen(ResPool.GetHatchBrush(HatchStyle.Percent50, Color.FromArgb(Clamp(ColorControl.R + 3, 0, 255), ColorControl.G, ColorControl.B), ColorControl), line_width))
+                {
+                    dc.DrawArc(h_pen, Rectangle.Inflate(rb_rect, -line_width, -line_width), 315.0f, 180.0f);
+                }
+
+            if ((state & ButtonState.Checked) == ButtonState.Checked)
+            {
+                int inflate = line_width * 4;
+                Rectangle tmp = Rectangle.Inflate(rb_rect, -inflate, -inflate);
+                if (rectangle.Height > 13)
+                {
+                    tmp.X += 1;
+                    tmp.Y += 1;
+                    tmp.Height -= 1;
+                    dc.FillEllipse(ResPool.GetSolidBrush(dot_color), tmp);
+                }
+                else
+                {
+                    Pen pen = ResPool.GetPen(dot_color);
+                    dc.DrawLine(pen, tmp.X, tmp.Y + (tmp.Height / 2), tmp.Right, tmp.Y + (tmp.Height / 2));
+                    dc.DrawLine(pen, tmp.X, tmp.Y + (tmp.Height / 2) + 1, tmp.Right, tmp.Y + (tmp.Height / 2) + 1);
+
+                    dc.DrawLine(pen, tmp.X + (tmp.Width / 2), tmp.Y, tmp.X + (tmp.Width / 2), tmp.Bottom);
+                    dc.DrawLine(pen, tmp.X + (tmp.Width / 2) + 1, tmp.Y, tmp.X + (tmp.Width / 2) + 1, tmp.Bottom);
+                }
+            }
+        }
+
+        public override void CPDrawReversibleFrame(Rectangle rectangle, Color backColor, FrameStyle style)
+        {
+
+        }
+
+
+        public override void CPDrawReversibleLine(Point start, Point end, Color backColor)
+        {
+
+        }
+
+
+        /* Scroll button: regular button + direction arrow */
+        public override void CPDrawScrollButton(Graphics dc, Rectangle area, ScrollButton type, ButtonState state)
+        {
+            DrawScrollButtonPrimitive(dc, area, state);
+
+            bool fill_rect = true;
+            int offset = 0;
+
+            if ((state & ButtonState.Pushed) != 0)
+                offset = 1;
+
+            // skip the border
+            Rectangle rect = new Rectangle(area.X + 2 + offset, area.Y + 2 + offset, area.Width - 4, area.Height - 4);
+
+            Point[] arrow = new Point[3];
+            for (int i = 0; i < 3; i++)
+                arrow[i] = new Point();
+
+            Pen pen = SystemPens.ControlText;
+
+            if ((state & ButtonState.Inactive) != 0)
+            {
+                pen = SystemPens.ControlDark;
+            }
+
+            switch (type)
+            {
+                default:
+                case ScrollButton.Down:
+                    int x_middle = (int)Math.Round(rect.Width / 2.0f) - 1;
+                    int y_middle = (int)Math.Round(rect.Height / 2.0f) - 1;
+                    if (x_middle == 1)
+                        x_middle = 2;
+
+                    int triangle_height;
+
+                    if (rect.Height < 8)
+                    {
+                        triangle_height = 2;
+                        fill_rect = false;
+                    }
+                    else if (rect.Height == 11)
+                    {
+                        triangle_height = 3;
+                    }
+                    else
+                    {
+                        triangle_height = (int)Math.Round(rect.Height / 3.0f);
+                    }
+
+                    arrow[0].X = rect.X + x_middle;
+                    arrow[0].Y = rect.Y + y_middle + triangle_height / 2;
+
+                    arrow[1].X = arrow[0].X + triangle_height - 1;
+                    arrow[1].Y = arrow[0].Y - triangle_height + 1;
+                    arrow[2].X = arrow[0].X - triangle_height + 1;
+                    arrow[2].Y = arrow[1].Y;
+
+                    dc.DrawPolygon(pen, arrow);
+
+                    if ((state & ButtonState.Inactive) != 0)
+                    {
+                        dc.DrawLine(SystemPens.ControlLightLight, arrow[1].X + 1, arrow[1].Y + 1, arrow[0].X + 1, arrow[0].Y + 1);
+                        dc.DrawLine(SystemPens.ControlLightLight, arrow[1].X, arrow[1].Y + 1, arrow[0].X + 1, arrow[0].Y);
+                    }
+
+                    if (fill_rect)
+                    {
+                        for (int i = 0; i < arrow[0].Y - arrow[1].Y; i++)
+                        {
+                            dc.DrawLine(pen, arrow[1].X, arrow[1].Y + i, arrow[2].X, arrow[1].Y + i);
+                            arrow[1].X -= 1;
+                            arrow[2].X += 1;
+                        }
+                    }
+                    break;
+
+                case ScrollButton.Up:
+                    x_middle = (int)Math.Round(rect.Width / 2.0f) - 1;
+                    y_middle = (int)Math.Round(rect.Height / 2.0f);
+                    if (x_middle == 1)
+                        x_middle = 2;
+
+                    if (y_middle == 1)
+                        y_middle = 2;
+
+                    if (rect.Height < 8)
+                    {
+                        triangle_height = 2;
+                        fill_rect = false;
+                    }
+                    else if (rect.Height == 11)
+                    {
+                        triangle_height = 3;
+                    }
+                    else
+                    {
+                        triangle_height = (int)Math.Round(rect.Height / 3.0f);
+                    }
+
+                    arrow[0].X = rect.X + x_middle;
+                    arrow[0].Y = rect.Y + y_middle - triangle_height / 2;
+
+                    arrow[1].X = arrow[0].X + triangle_height - 1;
+                    arrow[1].Y = arrow[0].Y + triangle_height - 1;
+                    arrow[2].X = arrow[0].X - triangle_height + 1;
+                    arrow[2].Y = arrow[1].Y;
+
+                    dc.DrawPolygon(pen, arrow);
+
+                    if ((state & ButtonState.Inactive) != 0)
+                    {
+                        dc.DrawLine(SystemPens.ControlLightLight, arrow[1].X + 1, arrow[1].Y + 1, arrow[2].X + 1, arrow[1].Y + 1);
+                    }
+
+                    if (fill_rect)
+                    {
+                        for (int i = 0; i < arrow[1].Y - arrow[0].Y; i++)
+                        {
+                            dc.DrawLine(pen, arrow[2].X, arrow[1].Y - i, arrow[1].X, arrow[1].Y - i);
+                            arrow[1].X -= 1;
+                            arrow[2].X += 1;
+                        }
+                    }
+                    break;
+
+                case ScrollButton.Left:
+                    y_middle = (int)Math.Round(rect.Height / 2.0f) - 1;
+                    if (y_middle == 1)
+                        y_middle = 2;
+
+                    int triangle_width;
+
+                    if (rect.Width < 8)
+                    {
+                        triangle_width = 2;
+                        fill_rect = false;
+                    }
+                    else if (rect.Width == 11)
+                    {
+                        triangle_width = 3;
+                    }
+                    else
+                    {
+                        triangle_width = (int)Math.Round(rect.Width / 3.0f);
+                    }
+
+                    arrow[0].X = rect.Left + triangle_width - 1;
+                    arrow[0].Y = rect.Y + y_middle;
+
+                    if (arrow[0].X - 1 == rect.X)
+                        arrow[0].X += 1;
+
+                    arrow[1].X = arrow[0].X + triangle_width - 1;
+                    arrow[1].Y = arrow[0].Y - triangle_width + 1;
+                    arrow[2].X = arrow[1].X;
+                    arrow[2].Y = arrow[0].Y + triangle_width - 1;
+
+                    dc.DrawPolygon(pen, arrow);
+
+                    if ((state & ButtonState.Inactive) != 0)
+                    {
+                        dc.DrawLine(SystemPens.ControlLightLight, arrow[1].X + 1, arrow[1].Y + 1, arrow[2].X + 1, arrow[2].Y + 1);
+                    }
+
+                    if (fill_rect)
+                    {
+                        for (int i = 0; i < arrow[2].X - arrow[0].X; i++)
+                        {
+                            dc.DrawLine(pen, arrow[2].X - i, arrow[1].Y, arrow[2].X - i, arrow[2].Y);
+                            arrow[1].Y += 1;
+                            arrow[2].Y -= 1;
+                        }
+                    }
+                    break;
+
+                case ScrollButton.Right:
+                    y_middle = (int)Math.Round(rect.Height / 2.0f) - 1;
+                    if (y_middle == 1)
+                        y_middle = 2;
+
+                    if (rect.Width < 8)
+                    {
+                        triangle_width = 2;
+                        fill_rect = false;
+                    }
+                    else if (rect.Width == 11)
+                    {
+                        triangle_width = 3;
+                    }
+                    else
+                    {
+                        triangle_width = (int)Math.Round(rect.Width / 3.0f);
+                    }
+
+                    arrow[0].X = rect.Right - triangle_width - 1;
+                    arrow[0].Y = rect.Y + y_middle;
+
+                    if (arrow[0].X - 1 == rect.X)
+                        arrow[0].X += 1;
+
+                    arrow[1].X = arrow[0].X - triangle_width + 1;
+                    arrow[1].Y = arrow[0].Y - triangle_width + 1;
+                    arrow[2].X = arrow[1].X;
+                    arrow[2].Y = arrow[0].Y + triangle_width - 1;
+
+                    dc.DrawPolygon(pen, arrow);
+
+                    if ((state & ButtonState.Inactive) != 0)
+                    {
+                        dc.DrawLine(SystemPens.ControlLightLight, arrow[0].X + 1, arrow[0].Y + 1, arrow[2].X + 1, arrow[2].Y + 1);
+                        dc.DrawLine(SystemPens.ControlLightLight, arrow[0].X, arrow[0].Y + 1, arrow[2].X + 1, arrow[2].Y);
+                    }
+
+                    if (fill_rect)
+                    {
+                        for (int i = 0; i < arrow[0].X - arrow[1].X; i++)
+                        {
+                            dc.DrawLine(pen, arrow[2].X + i, arrow[1].Y, arrow[2].X + i, arrow[2].Y);
+                            arrow[1].Y += 1;
+                            arrow[2].Y -= 1;
+                        }
+                    }
+                    break;
+            }
+        }
+
+        public override void CPDrawSelectionFrame(Graphics graphics, bool active, Rectangle outsideRect, Rectangle insideRect,
+            Color backColor)
+        {
+
+        }
+
+
+        public override void CPDrawSizeGrip(Graphics dc, Color backColor, Rectangle bounds)
+        {
+            Pen pen_dark = ResPool.GetPen(WidgetPaint.Dark(backColor));
+            Pen pen_light_light = ResPool.GetPen(WidgetPaint.LightLight(backColor));
+
+            for (int i = 2; i < bounds.Width - 2; i += 4)
+            {
+                dc.DrawLine(pen_light_light, bounds.X + i, bounds.Bottom - 2, bounds.Right - 1, bounds.Y + i - 1);
+                dc.DrawLine(pen_dark, bounds.X + i + 1, bounds.Bottom - 2, bounds.Right - 1, bounds.Y + i);
+                dc.DrawLine(pen_dark, bounds.X + i + 2, bounds.Bottom - 2, bounds.Right - 1, bounds.Y + i + 1);
+            }
+        }
+
+        private void DrawStringDisabled20(Graphics g, string s, Font font, Rectangle layoutRectangle, Color color, TextFormatFlags flags, bool useDrawString)
+        {
+            CPColor cpcolor = ResPool.GetCPColor(color);
+
+            layoutRectangle.Offset(1, 1);
+            TextRenderer.DrawTextInternal(g, s, font, layoutRectangle, cpcolor.LightLight, flags, useDrawString);
+
+            layoutRectangle.Offset(-1, -1);
+            TextRenderer.DrawTextInternal(g, s, font, layoutRectangle, cpcolor.Dark, flags, useDrawString);
+        }
+
+        public override void CPDrawStringDisabled(Graphics dc, string s, Font font, Color color, RectangleF layoutRectangle, StringFormat format)
+        {
+            CPColor cpcolor = ResPool.GetCPColor(color);
+
+            dc.DrawString(s, font, ResPool.GetSolidBrush(cpcolor.LightLight),
+                       new RectangleF(layoutRectangle.X + 1, layoutRectangle.Y + 1, layoutRectangle.Width, layoutRectangle.Height),
+                       format);
+            dc.DrawString(s, font, ResPool.GetSolidBrush(cpcolor.Dark), layoutRectangle, format);
+        }
+
+        public override void CPDrawStringDisabled(IDeviceContext dc, string s, Font font, Color color, Rectangle layoutRectangle, TextFormatFlags format)
+        {
+            CPColor cpcolor = ResPool.GetCPColor(color);
+
+            layoutRectangle.Offset(1, 1);
+            TextRenderer.DrawText(dc, s, font, layoutRectangle, cpcolor.LightLight, format);
+
+            layoutRectangle.Offset(-1, -1);
+            TextRenderer.DrawText(dc, s, font, layoutRectangle, cpcolor.Dark, format);
+        }
+
+        public override void CPDrawVisualStyleBorder(Graphics graphics, Rectangle bounds)
+        {
+            graphics.DrawRectangle(new System.Drawing.Pen(new SolidBrush(Application.CurrentSkin.VisualStyleBorderColor), Application.CurrentSkin.VisualStyleBorderWidth), bounds);
+        }
+
+        private static void DrawBorderInternal(Graphics graphics, int startX, int startY, int endX, int endY,
+            int width, Color color, ButtonBorderStyle style, Border3DSide side)
+        {
+            DrawBorderInternal(graphics, (float)startX, (float)startY, (float)endX, (float)endY,
+                width, color, style, side);
+        }
+
+        private static void DrawBorderInternal(Graphics graphics, float startX, float startY, float endX, float endY,
+            int width, Color color, ButtonBorderStyle style, Border3DSide side)
+        {
+
+            Pen pen = null;
+
+            switch (style)
+            {
+                case ButtonBorderStyle.Solid:
+                case ButtonBorderStyle.Inset:
+                case ButtonBorderStyle.Outset:
+                    pen = ThemeEngine.Current.ResPool.GetDashPen(color, DashStyle.Solid);
+                    break;
+                case ButtonBorderStyle.Dashed:
+                    pen = ThemeEngine.Current.ResPool.GetDashPen(color, DashStyle.Dash);
+                    break;
+                case ButtonBorderStyle.Dotted:
+                    pen = ThemeEngine.Current.ResPool.GetDashPen(color, DashStyle.Dot);
+                    break;
+                default:
+                case ButtonBorderStyle.None:
+                    return;
+            }
+
+            switch (style)
+            {
+                case ButtonBorderStyle.Outset:
+                    {
+                        Color colorGrade;
+                        int hue, brightness, saturation;
+                        int brightnessSteps;
+                        int brightnessDownSteps;
+
+                        WidgetPaint.Color2HBS(color, out hue, out brightness, out saturation);
+
+                        brightnessDownSteps = brightness / width;
+                        if (brightness > 127)
+                        {
+                            brightnessSteps = Math.Max(6, (160 - brightness) / width);
+                        }
+                        else
+                        {
+                            brightnessSteps = (127 - brightness) / width;
+                        }
+
+                        for (int i = 0; i < width; i++)
+                        {
+                            switch (side)
+                            {
+                                case Border3DSide.Left:
+                                    {
+                                        colorGrade = WidgetPaint.HBS2Color(hue, Math.Min(255, brightness + brightnessSteps * (width - i)), saturation);
+                                        pen = ThemeEngine.Current.ResPool.GetPen(colorGrade);
+                                        graphics.DrawLine(pen, startX + i, startY + i, endX + i, endY - i);
+                                        break;
+                                    }
+
+                                case Border3DSide.Right:
+                                    {
+                                        colorGrade = WidgetPaint.HBS2Color(hue, Math.Max(0, brightness - brightnessDownSteps * (width - i)), saturation);
+                                        pen = ThemeEngine.Current.ResPool.GetPen(colorGrade);
+                                        graphics.DrawLine(pen, startX - i, startY + i, endX - i, endY - i);
+                                        break;
+                                    }
+
+                                case Border3DSide.Top:
+                                    {
+                                        colorGrade = WidgetPaint.HBS2Color(hue, Math.Min(255, brightness + brightnessSteps * (width - i)), saturation);
+                                        pen = ThemeEngine.Current.ResPool.GetPen(colorGrade);
+                                        graphics.DrawLine(pen, startX + i, startY + i, endX - i, endY + i);
+                                        break;
+                                    }
+
+                                case Border3DSide.Bottom:
+                                    {
+                                        colorGrade = WidgetPaint.HBS2Color(hue, Math.Max(0, brightness - brightnessDownSteps * (width - i)), saturation);
+                                        pen = ThemeEngine.Current.ResPool.GetPen(colorGrade);
+                                        graphics.DrawLine(pen, startX + i, startY - i, endX - i, endY - i);
+                                        break;
+                                    }
+                            }
+                        }
+                        break;
+                    }
+
+                case ButtonBorderStyle.Inset:
+                    {
+                        Color colorGrade;
+                        int hue, brightness, saturation;
+                        int brightnessSteps;
+                        int brightnessDownSteps;
+
+                        WidgetPaint.Color2HBS(color, out hue, out brightness, out saturation);
+
+                        brightnessDownSteps = brightness / width;
+                        if (brightness > 127)
+                        {
+                            brightnessSteps = Math.Max(6, (160 - brightness) / width);
+                        }
+                        else
+                        {
+                            brightnessSteps = (127 - brightness) / width;
+                        }
+
+                        for (int i = 0; i < width; i++)
+                        {
+                            switch (side)
+                            {
+                                case Border3DSide.Left:
+                                    {
+                                        colorGrade = WidgetPaint.HBS2Color(hue, Math.Max(0, brightness - brightnessDownSteps * (width - i)), saturation);
+                                        pen = ThemeEngine.Current.ResPool.GetPen(colorGrade);
+                                        graphics.DrawLine(pen, startX + i, startY + i, endX + i, endY - i);
+                                        break;
+                                    }
+
+                                case Border3DSide.Right:
+                                    {
+                                        colorGrade = WidgetPaint.HBS2Color(hue, Math.Min(255, brightness + brightnessSteps * (width - i)), saturation);
+                                        pen = ThemeEngine.Current.ResPool.GetPen(colorGrade);
+                                        graphics.DrawLine(pen, startX - i, startY + i, endX - i, endY - i);
+                                        break;
+                                    }
+
+                                case Border3DSide.Top:
+                                    {
+                                        colorGrade = WidgetPaint.HBS2Color(hue, Math.Max(0, brightness - brightnessDownSteps * (width - i)), saturation);
+                                        pen = ThemeEngine.Current.ResPool.GetPen(colorGrade);
+                                        graphics.DrawLine(pen, startX + i, startY + i, endX - i, endY + i);
+                                        break;
+                                    }
+
+                                case Border3DSide.Bottom:
+                                    {
+                                        colorGrade = WidgetPaint.HBS2Color(hue, Math.Min(255, brightness + brightnessSteps * (width - i)), saturation);
+                                        pen = ThemeEngine.Current.ResPool.GetPen(colorGrade);
+                                        graphics.DrawLine(pen, startX + i, startY - i, endX - i, endY - i);
+                                        break;
+                                    }
+                            }
+                        }
+                        break;
+                    }
+
+                /*
+					I decided to have the for-loop duplicated for speed reasons;
+					that way we only have to switch once (as opposed to have the
+					for-loop around the switch)
+				*/
+                default:
+                    {
+                        switch (side)
+                        {
+                            case Border3DSide.Left:
+                                {
+                                    for (int i = 0; i < width; i++)
+                                    {
+                                        graphics.DrawLine(pen, startX + i, startY + i, endX + i, endY - i);
+                                    }
+                                    break;
+                                }
+
+                            case Border3DSide.Right:
+                                {
+                                    for (int i = 0; i < width; i++)
+                                    {
+                                        graphics.DrawLine(pen, startX - i, startY + i, endX - i, endY - i);
+                                    }
+                                    break;
+                                }
+
+                            case Border3DSide.Top:
+                                {
+                                    for (int i = 0; i < width; i++)
+                                    {
+                                        graphics.DrawLine(pen, startX + i, startY + i, endX - i, endY + i);
+                                    }
+                                    break;
+                                }
+
+                            case Border3DSide.Bottom:
+                                {
+                                    for (int i = 0; i < width; i++)
+                                    {
+                                        graphics.DrawLine(pen, startX + i, startY - i, endX - i, endY - i);
+                                    }
+                                    break;
+                                }
+                        }
+                        break;
+                    }
+            }
+        }
+
+        /*
+			This function actually draws the various caption elements.
+			This way we can scale them nicely, no matter what size, and they
+			still look like MS's scaled caption buttons. (as opposed to scaling a bitmap)
+		*/
+
+        private void DrawCaptionHelper(Graphics graphics, Color color, Pen pen, int lineWidth, int shift, Rectangle captionRect, CaptionButton button)
+        {
+            switch (button)
+            {
+                case CaptionButton.Close:
+                    {
+                        if (lineWidth < 2)
+                        {
+                            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);
+                            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);
+                        }
+
+                        graphics.DrawLine(pen, captionRect.Left + 2 * lineWidth + shift, captionRect.Top + 2 * lineWidth + shift, captionRect.Right - 2 * lineWidth + shift, captionRect.Bottom - 2 * lineWidth + shift);
+                        graphics.DrawLine(pen, captionRect.Right - 2 * lineWidth + shift, captionRect.Top + 2 * lineWidth + shift, captionRect.Left + 2 * lineWidth + shift, captionRect.Bottom - 2 * lineWidth + shift);
+                        return;
+                    }
+
+                case CaptionButton.Help:
+                    {
+                        StringFormat sf = new StringFormat();
+                        Font font = new Font("Microsoft Sans Serif", captionRect.Height, FontStyle.Bold, GraphicsUnit.Pixel);
+
+                        sf.Alignment = StringAlignment.Center;
+                        sf.LineAlignment = StringAlignment.Center;
+
+
+                        graphics.DrawString("?", font, ResPool.GetSolidBrush(color), captionRect.X + captionRect.Width / 2 + shift, captionRect.Y + captionRect.Height / 2 + shift + lineWidth / 2, sf);
+
+                        sf.Dispose();
+                        font.Dispose();
+
+                        return;
+                    }
+
+                case CaptionButton.Maximize:
+                    {
+                        /* Top 'caption bar' line */
+                        for (int i = 0; i < Math.Max(2, lineWidth); i++)
+                        {
+                            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);
+                        }
+
+                        /* Left side line */
+                        for (int i = 0; i < Math.Max(1, lineWidth / 2); i++)
+                        {
+                            graphics.DrawLine(pen, captionRect.Left + lineWidth + shift + i, captionRect.Top + 2 * lineWidth + shift, captionRect.Left + lineWidth + shift + i, captionRect.Bottom - lineWidth + shift);
+                        }
+
+                        /* Right side line */
+                        for (int i = 0; i < Math.Max(1, lineWidth / 2); i++)
+                        {
+                            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);
+                        }
+
+                        /* Bottom line */
+                        for (int i = 0; i < Math.Max(1, lineWidth / 2); i++)
+                        {
+                            graphics.DrawLine(pen, captionRect.Left + lineWidth + shift, captionRect.Bottom - lineWidth + shift - i, captionRect.Right - lineWidth - lineWidth / 2 + shift, captionRect.Bottom - lineWidth + shift - i);
+                        }
+                        return;
+                    }
+
+                case CaptionButton.Minimize:
+                    {
+                        /* Bottom line */
+                        for (int i = 0; i < Math.Max(2, lineWidth); i++)
+                        {
+                            graphics.DrawLine(pen, captionRect.Left + lineWidth + shift, captionRect.Bottom - lineWidth + shift - i, captionRect.Right - 3 * lineWidth + shift, captionRect.Bottom - lineWidth + shift - i);
+                        }
+                        return;
+                    }
+
+                case CaptionButton.Restore:
+                    {
+                        /** First 'window' **/
+                        /* Top 'caption bar' line */
+                        for (int i = 0; i < Math.Max(2, lineWidth); i++)
+                        {
+                            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);
+                        }
+
+                        /* Left side line */
+                        for (int i = 0; i < Math.Max(1, lineWidth / 2); i++)
+                        {
+                            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);
+                        }
+
+                        /* Right side line */
+                        for (int i = 0; i < Math.Max(1, lineWidth / 2); i++)
+                        {
+                            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);
+                        }
+
+                        /* Bottom line */
+                        for (int i = 0; i < Math.Max(1, lineWidth / 2); i++)
+                        {
+                            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);
+                        }
+
+                        /** Second 'window' **/
+                        /* Top 'caption bar' line */
+                        for (int i = 0; i < Math.Max(2, lineWidth); i++)
+                        {
+                            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);
+                        }
+
+                        /* Left side line */
+                        for (int i = 0; i < Math.Max(1, lineWidth / 2); i++)
+                        {
+                            graphics.DrawLine(pen, captionRect.Left + lineWidth + shift + i, captionRect.Top + 4 * lineWidth + shift + 1, captionRect.Left + lineWidth + shift + i, captionRect.Bottom - lineWidth + shift);
+                        }
+
+                        /* Right side line */
+                        for (int i = 0; i < Math.Max(1, lineWidth / 2); i++)
+                        {
+                            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);
+                        }
+
+                        /* Bottom line */
+                        for (int i = 0; i < Math.Max(1, lineWidth / 2); i++)
+                        {
+                            graphics.DrawLine(pen, captionRect.Left + lineWidth + shift, captionRect.Bottom - lineWidth + shift - i, captionRect.Right - 3 * lineWidth - lineWidth / 2 + shift, captionRect.Bottom - lineWidth + shift - i);
+                        }
+
+                        return;
+                    }
+
+            }
+        }
+
+        /* Generic scroll button */
+        public void DrawScrollButtonPrimitive(Graphics dc, Rectangle area, ButtonState state)
+        {
+            if ((state & ButtonState.Pushed) == ButtonState.Pushed)
+            {
+                dc.FillRectangle(SystemBrushes.Control, area.X + 1,
+                    area.Y + 1, area.Width - 2, area.Height - 2);
+
+                dc.DrawRectangle(SystemPens.ControlDark, area.X,
+                    area.Y, area.Width, area.Height);
+
+                return;
+            }
+
+            Brush sb_control = SystemBrushes.Control;
+            Brush sb_lightlight = SystemBrushes.ControlLightLight;
+            Brush sb_dark = SystemBrushes.ControlDark;
+            Brush sb_darkdark = SystemBrushes.ControlDarkDark;
+
+            dc.FillRectangle(sb_control, area.X, area.Y, area.Width, 1);
+            dc.FillRectangle(sb_control, area.X, area.Y, 1, area.Height);
+
+            dc.FillRectangle(sb_lightlight, area.X + 1, area.Y + 1, area.Width - 1, 1);
+            dc.FillRectangle(sb_lightlight, area.X + 1, area.Y + 2, 1,
+                area.Height - 4);
+
+            dc.FillRectangle(sb_dark, area.X + 1, area.Y + area.Height - 2,
+                area.Width - 2, 1);
+
+            dc.FillRectangle(sb_darkdark, area.X, area.Y + area.Height - 1,
+                area.Width, 1);
+
+            dc.FillRectangle(sb_dark, area.X + area.Width - 2,
+                area.Y + 1, 1, area.Height - 3);
+
+            dc.FillRectangle(sb_darkdark, area.X + area.Width - 1,
+                area.Y, 1, area.Height - 1);
+
+            dc.FillRectangle(sb_control, area.X + 2,
+                area.Y + 2, area.Width - 4, area.Height - 4);
+
+        }
+
+        public override void CPDrawBorderStyle(Graphics dc, Rectangle area, BorderStyle border_style)
+        {
+            switch (border_style)
+            {
+                case BorderStyle.Fixed3D:
+                    dc.DrawLine(ResPool.GetPen(ColorControlDark), area.X, area.Y, area.X + area.Width, area.Y);
+                    dc.DrawLine(ResPool.GetPen(ColorControlDark), area.X, area.Y, area.X, area.Y + area.Height);
+                    dc.DrawLine(ResPool.GetPen(ColorControlLight), area.X, area.Y + area.Height - 1, area.X + area.Width,
+                        area.Y + area.Height - 1);
+                    dc.DrawLine(ResPool.GetPen(ColorControlLight), area.X + area.Width - 1, area.Y, area.X + area.Width - 1,
+                        area.Y + area.Height);
+
+                    dc.DrawLine(ResPool.GetPen(ColorActiveBorder), area.X + 1, area.Bottom - 2, area.Right - 2, area.Bottom - 2);
+                    dc.DrawLine(ResPool.GetPen(ColorActiveBorder), area.Right - 2, area.Top + 1, area.Right - 2, area.Bottom - 2);
+                    dc.DrawLine(ResPool.GetPen(ColorControlDarkDark), area.X + 1, area.Top + 1, area.X + 1, area.Bottom - 3);
+                    dc.DrawLine(ResPool.GetPen(ColorControlDarkDark), area.X + 1, area.Top + 1, area.Right - 3, area.Top + 1);
+                    break;
+                case BorderStyle.FixedSingle:
+                    dc.DrawRectangle(ResPool.GetPen(ColorWindowFrame), area.X, area.Y, area.Width - 1, area.Height - 1);
+                    break;
+                case BorderStyle.None:
+                default:
+                    break;
+            }
+
+        }
+        #endregion // WidgetPaint
+
+
+    } //class
+}