Move ShiftUI source code to ShiftOS

This'll be a lot easier to work on.

1 files changed, 2162 insertions, 0 deletions

diff --git a/source/ShiftUI/Theming/ThemeVisualStyles.cs b/source/ShiftUI/Theming/ThemeVisualStyles.cs
new file mode 100644
index 0000000..d0bd4ea
--- /dev/null
+++ b/source/ShiftUI/Theming/ThemeVisualStyles.cs
@@ -0,0 +1,2162 @@
+// 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) 2008 George Giolfan
+// Copyright (c) 2004-2006 Novell, Inc.
+//
+// Authors:
+//	George Giolfan, [email protected]
+//	Ernesto Carrea, [email protected]
+
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using ShiftUI.VisualStyles;
+using System;
+
+namespace ShiftUI
+{
+	/// <summary>
+	/// VisualStyles theme.
+	/// </summary>
+	/// <remarks>
+	/// This theme uses only the managed VisualStyles API.
+	/// To select it, set MONO_THEME to VisualStyles and call <see cref="Application.EnableVisualStyles"/>.
+	/// </remarks>
+	class ThemeVisualStyles : ThemeWin32Classic
+	{
+		static bool render_client_areas;
+		static bool render_non_client_areas;
+
+		public ThemeVisualStyles ()
+		{
+			Update ();
+		}
+
+		public override void ResetDefaults ()
+		{
+			base.ResetDefaults ();
+			Update ();
+		}
+
+		static void Update ()
+		{
+			bool visual_styles_is_enabled_by_user = VisualStyleInformation.IsEnabledByUser;
+			render_client_areas =
+				visual_styles_is_enabled_by_user &&
+				(Application.VisualStyleState == VisualStyleState.ClientAndNonClientAreasEnabled ||
+				Application.VisualStyleState == VisualStyleState.ClientAreaEnabled);
+			render_non_client_areas =
+				visual_styles_is_enabled_by_user &&
+				(Application.VisualStyleState == VisualStyleState.ClientAndNonClientAreasEnabled/* ||
+				Application.VisualStyleState == VisualStyleState.NonClientAreaEnabled*/);
+		}
+
+		public static bool RenderClientAreas {
+			get { return render_client_areas; }
+		}
+
+		#region Widgets
+		#region ButtonBase
+		public override void DrawButtonBase (Graphics dc, Rectangle clip_area, ButtonBase button)
+		{
+			if (button.FlatStyle == FlatStyle.System) {
+				ButtonRenderer.DrawButton (
+					dc,
+					new Rectangle (Point.Empty, button.Size),
+					button.Text,
+					button.Font,
+					button.TextFormatFlags,
+					null,
+					Rectangle.Empty,
+					ShouldPaintFocusRectagle (button),
+					GetPushButtonState (button)
+				);
+				return;
+			}
+			base.DrawButtonBase (dc, clip_area, button);
+		}
+		static PushButtonState GetPushButtonState (ButtonBase button)
+		{
+			if (!button.Enabled)
+				return PushButtonState.Disabled;
+			if (button.Pressed)
+				return PushButtonState.Pressed;
+			if (button.Entered)
+				return PushButtonState.Hot;
+			if (button.IsDefault || button.Focused || button.paint_as_acceptbutton)
+				return PushButtonState.Default;
+			return PushButtonState.Normal;
+		}
+		#endregion
+
+		#region Button 2.0
+		public override void DrawButtonBackground (Graphics g, Button button, Rectangle clipArea)
+		{
+			if (!RenderClientAreas ||
+				!button.UseVisualStyleBackColor) {
+				base.DrawButtonBackground (g, button, clipArea);
+				return;
+			}
+			ButtonRenderer.GetPushButtonRenderer (GetPushButtonState (button)).DrawBackground (g, new Rectangle (Point.Empty, button.Size));
+		}
+		#endregion
+
+		#region CheckBox
+		protected override void CheckBox_DrawCheckBox (Graphics dc, CheckBox checkbox, ButtonState state, Rectangle checkbox_rectangle)
+		{
+			if (checkbox.Appearance == Appearance.Normal && checkbox.FlatStyle == FlatStyle.System) {
+				CheckBoxRenderer.DrawCheckBox (
+					dc,
+					new Point (checkbox_rectangle.Left, checkbox_rectangle.Top),
+					GetCheckBoxState (checkbox)
+				);
+				return;
+			}
+			base.CheckBox_DrawCheckBox(dc, checkbox, state, checkbox_rectangle);
+		}
+		static CheckBoxState GetCheckBoxState (CheckBox checkBox)
+		{
+			switch (checkBox.CheckState) {
+			case CheckState.Checked:
+				if (!checkBox.Enabled)
+					return CheckBoxState.CheckedDisabled;
+				else if (checkBox.Pressed)
+					return CheckBoxState.CheckedPressed;
+				else if (checkBox.Entered)
+					return CheckBoxState.CheckedHot;
+				return CheckBoxState.CheckedNormal;
+			case CheckState.Indeterminate:
+				if (!checkBox.Enabled)
+					return CheckBoxState.MixedDisabled;
+				else if (checkBox.Pressed)
+					return CheckBoxState.MixedPressed;
+				else if (checkBox.Entered)
+					return CheckBoxState.MixedHot;
+				return CheckBoxState.MixedNormal;
+			default:
+				if (!checkBox.Enabled)
+					return CheckBoxState.UncheckedDisabled;
+				else if (checkBox.Pressed)
+					return CheckBoxState.UncheckedPressed;
+				else if (checkBox.Entered)
+					return CheckBoxState.UncheckedHot;
+				return CheckBoxState.UncheckedNormal;
+			}
+		}
+		#endregion
+		#region ComboBox
+		static VisualStyleElement ComboBoxGetVisualStyleElement (ComboBox comboBox, ButtonState state)
+		{
+			if (state == ButtonState.Inactive)
+				return VisualStyleElement.ComboBox.DropDownButton.Disabled;
+			if (state == ButtonState.Pushed)
+				return VisualStyleElement.ComboBox.DropDownButton.Pressed;
+			if (comboBox.DropDownButtonEntered)
+				return VisualStyleElement.ComboBox.DropDownButton.Hot;
+			return VisualStyleElement.ComboBox.DropDownButton.Normal;
+		}
+		public override void ComboBoxDrawNormalDropDownButton (ComboBox comboBox, Graphics g, Rectangle clippingArea, Rectangle area, ButtonState state)
+		{
+			if (!RenderClientAreas) {
+				base.ComboBoxDrawNormalDropDownButton (comboBox, g, clippingArea, area, state);
+				return;
+			}
+			VisualStyleElement element = ComboBoxGetVisualStyleElement (comboBox, state);
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.ComboBoxDrawNormalDropDownButton (comboBox, g, clippingArea, area, state);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (g, area, clippingArea);
+		}
+		public override bool ComboBoxNormalDropDownButtonHasTransparentBackground (ComboBox comboBox, ButtonState state)
+		{
+			if (!RenderClientAreas)
+				return base.ComboBoxNormalDropDownButtonHasTransparentBackground (comboBox, state);
+			VisualStyleElement element = ComboBoxGetVisualStyleElement (comboBox, state);
+			if (!VisualStyleRenderer.IsElementDefined (element))
+				return base.ComboBoxNormalDropDownButtonHasTransparentBackground (comboBox, state);
+			return new VisualStyleRenderer (element).IsBackgroundPartiallyTransparent ();
+		}
+		public override bool ComboBoxDropDownButtonHasHotElementStyle (ComboBox comboBox)
+		{
+			if (!RenderClientAreas)
+				return base.ComboBoxDropDownButtonHasHotElementStyle (comboBox);
+			switch (comboBox.FlatStyle) {
+			case FlatStyle.Flat:
+			case FlatStyle.Popup:
+				return base.ComboBoxDropDownButtonHasHotElementStyle (comboBox);
+			}
+			return true;
+		}
+		static bool ComboBoxShouldPaintBackground (ComboBox comboBox)
+		{
+			if (comboBox.DropDownStyle == ComboBoxStyle.Simple)
+				return false;
+			switch (comboBox.FlatStyle) {
+			case FlatStyle.Flat:
+			case FlatStyle.Popup:
+				return false;
+			}
+			return true;
+		}
+		public override void ComboBoxDrawBackground (ComboBox comboBox, Graphics g, Rectangle clippingArea, FlatStyle style)
+		{
+			if (!RenderClientAreas || !ComboBoxShouldPaintBackground (comboBox)) {
+				base.ComboBoxDrawBackground (comboBox, g, clippingArea, style);
+				return;
+			}
+			VisualStyleElement element;
+			if (!comboBox.Enabled)
+				element = VisualStyleElement.ComboBox.Border.Disabled;
+			else if (comboBox.Entered)
+				element = VisualStyleElement.ComboBox.Border.Hot;
+			else if (comboBox.Focused)
+				element = VisualStyleElement.ComboBox.Border.Focused;
+			else
+				element = VisualStyleElement.ComboBox.Border.Normal;
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.ComboBoxDrawBackground (comboBox, g, clippingArea, style);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (g, new Rectangle (Point.Empty, comboBox.Size), clippingArea);
+		}
+		public override bool CombBoxBackgroundHasHotElementStyle (ComboBox comboBox)
+		{
+			if (RenderClientAreas &&
+				ComboBoxShouldPaintBackground (comboBox) &&
+				comboBox.Enabled &&
+				VisualStyleRenderer.IsElementDefined (VisualStyleElement.ComboBox.Border.Hot))
+				return true;
+			return base.CombBoxBackgroundHasHotElementStyle (comboBox);
+		}
+		#endregion
+		#region WidgetPaint
+		#region DrawButton
+		public override void CPDrawButton (Graphics dc, Rectangle rectangle, ButtonState state)
+		{
+			if (!RenderClientAreas ||
+				(state & ButtonState.Flat) == ButtonState.Flat ||
+				(state & ButtonState.Checked) == ButtonState.Checked) {
+				base.CPDrawButton (dc, rectangle, state);
+				return;
+			}
+			VisualStyleElement element;
+			if ((state & ButtonState.Inactive) == ButtonState.Inactive)
+				element = VisualStyleElement.Button.PushButton.Disabled;
+			else if ((state & ButtonState.Pushed) == ButtonState.Pushed)
+				element = VisualStyleElement.Button.PushButton.Pressed;
+			else
+				element = VisualStyleElement.Button.PushButton.Normal;
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.CPDrawButton (dc, rectangle, state);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (dc, rectangle);
+		}
+		#endregion
+		#region DrawCaptionButton
+		public override void CPDrawCaptionButton (Graphics graphics, Rectangle rectangle, CaptionButton button, ButtonState state)
+		{
+			if (!RenderClientAreas ||
+				(state & ButtonState.Flat) == ButtonState.Flat ||
+				(state & ButtonState.Checked) == ButtonState.Checked) {
+				base.CPDrawCaptionButton (graphics, rectangle, button, state);
+				return;
+			}
+			VisualStyleElement element = GetCaptionButtonVisualStyleElement (button, state);
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.CPDrawCaptionButton (graphics, rectangle, button, state);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (graphics, rectangle);
+		}
+		static VisualStyleElement GetCaptionButtonVisualStyleElement (CaptionButton button, ButtonState state)
+		{
+			switch (button) {
+			case CaptionButton.Minimize:
+				if ((state & ButtonState.Inactive) == ButtonState.Inactive)
+					return VisualStyleElement.Window.MinButton.Disabled;
+				else if ((state & ButtonState.Pushed) == ButtonState.Pushed)
+					return VisualStyleElement.Window.MinButton.Pressed;
+				else
+					return VisualStyleElement.Window.MinButton.Normal;
+			case CaptionButton.Maximize:
+				if ((state & ButtonState.Inactive) == ButtonState.Inactive)
+					return VisualStyleElement.Window.MaxButton.Disabled;
+				else if ((state & ButtonState.Pushed) == ButtonState.Pushed)
+					return VisualStyleElement.Window.MaxButton.Pressed;
+				else
+					return VisualStyleElement.Window.MaxButton.Normal;
+			case CaptionButton.Close:
+				if ((state & ButtonState.Inactive) == ButtonState.Inactive)
+					return VisualStyleElement.Window.CloseButton.Disabled;
+				else if ((state & ButtonState.Pushed) == ButtonState.Pushed)
+					return VisualStyleElement.Window.CloseButton.Pressed;
+				else
+					return VisualStyleElement.Window.CloseButton.Normal;
+			case CaptionButton.Restore:
+				if ((state & ButtonState.Inactive) == ButtonState.Inactive)
+					return VisualStyleElement.Window.RestoreButton.Disabled;
+				else if ((state & ButtonState.Pushed) == ButtonState.Pushed)
+					return VisualStyleElement.Window.RestoreButton.Pressed;
+				else
+					return VisualStyleElement.Window.RestoreButton.Normal;
+			default:
+				if ((state & ButtonState.Inactive) == ButtonState.Inactive)
+					return VisualStyleElement.Window.HelpButton.Disabled;
+				else if ((state & ButtonState.Pushed) == ButtonState.Pushed)
+					return VisualStyleElement.Window.HelpButton.Pressed;
+				else
+					return VisualStyleElement.Window.HelpButton.Normal;
+			}
+		}
+		#endregion
+		#region DrawCheckBox
+		public override void CPDrawCheckBox (Graphics dc, Rectangle rectangle, ButtonState state)
+		{
+			if (!RenderClientAreas ||
+				(state & ButtonState.Flat) == ButtonState.Flat) {
+				base.CPDrawCheckBox (dc, rectangle, state);
+				return;
+			}
+			VisualStyleElement element;
+			if ((state & ButtonState.Checked) == ButtonState.Checked)
+				if ((state & ButtonState.Inactive) == ButtonState.Inactive)
+					element = VisualStyleElement.Button.CheckBox.CheckedDisabled;
+				else if ((state & ButtonState.Pushed) == ButtonState.Pushed)
+					element = VisualStyleElement.Button.CheckBox.CheckedPressed;
+				else
+					element = VisualStyleElement.Button.CheckBox.CheckedNormal;
+			else
+				if ((state & ButtonState.Inactive) == ButtonState.Inactive)
+					element = VisualStyleElement.Button.CheckBox.UncheckedDisabled;
+				else if ((state & ButtonState.Pushed) == ButtonState.Pushed)
+					element = VisualStyleElement.Button.CheckBox.UncheckedPressed;
+				else
+					element = VisualStyleElement.Button.CheckBox.UncheckedNormal;
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.CPDrawCheckBox (dc, rectangle, state);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (dc, rectangle);
+		}
+		#endregion
+		#region DrawComboButton
+		public override void CPDrawComboButton (Graphics graphics, Rectangle rectangle, ButtonState state)
+		{
+			if (!RenderClientAreas ||
+				(state & ButtonState.Flat) == ButtonState.Flat ||
+				(state & ButtonState.Checked) == ButtonState.Checked) {
+				base.CPDrawComboButton (graphics, rectangle, state);
+				return;
+			}
+			VisualStyleElement element;
+			if ((state & ButtonState.Inactive) == ButtonState.Inactive)
+				element = VisualStyleElement.ComboBox.DropDownButton.Disabled;
+			else if ((state & ButtonState.Pushed) == ButtonState.Pushed)
+				element = VisualStyleElement.ComboBox.DropDownButton.Pressed;
+			else
+				element = VisualStyleElement.ComboBox.DropDownButton.Normal;
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.CPDrawComboButton (graphics, rectangle, state);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (graphics, rectangle);
+		}
+		#endregion
+		#region DrawMixedCheckBox
+		public override void CPDrawMixedCheckBox (Graphics dc, Rectangle rectangle, ButtonState state)
+		{
+			if (!RenderClientAreas ||
+				(state & ButtonState.Flat) == ButtonState.Flat) {
+				base.CPDrawMixedCheckBox (dc, rectangle, state);
+				return;
+			}
+			VisualStyleElement element;
+			if ((state & ButtonState.Checked) == ButtonState.Checked)
+				if ((state & ButtonState.Inactive) == ButtonState.Inactive)
+					element = VisualStyleElement.Button.CheckBox.MixedDisabled;
+				else if ((state & ButtonState.Pushed) == ButtonState.Pushed)
+					element = VisualStyleElement.Button.CheckBox.MixedPressed;
+				else
+					element = VisualStyleElement.Button.CheckBox.MixedNormal;
+			else
+				if ((state & ButtonState.Inactive) == ButtonState.Inactive)
+					element = VisualStyleElement.Button.CheckBox.UncheckedDisabled;
+				else if ((state & ButtonState.Pushed) == ButtonState.Pushed)
+					element = VisualStyleElement.Button.CheckBox.UncheckedPressed;
+				else
+					element = VisualStyleElement.Button.CheckBox.UncheckedNormal;
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.CPDrawMixedCheckBox (dc, rectangle, state);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (dc, rectangle);
+		}
+		#endregion
+		#region DrawRadioButton
+		public override void CPDrawRadioButton (Graphics dc, Rectangle rectangle, ButtonState state)
+		{
+			if (!RenderClientAreas ||
+				(state & ButtonState.Flat) == ButtonState.Flat) {
+				base.CPDrawRadioButton (dc, rectangle, state);
+				return;
+			}
+			VisualStyleElement element;
+			if ((state & ButtonState.Checked) == ButtonState.Checked)
+				if ((state & ButtonState.Inactive) == ButtonState.Inactive)
+					element = VisualStyleElement.Button.RadioButton.CheckedDisabled;
+				else if ((state & ButtonState.Pushed) == ButtonState.Pushed)
+					element = VisualStyleElement.Button.RadioButton.CheckedPressed;
+				else
+					element = VisualStyleElement.Button.RadioButton.CheckedNormal;
+			else
+				if ((state & ButtonState.Inactive) == ButtonState.Inactive)
+					element = VisualStyleElement.Button.RadioButton.UncheckedDisabled;
+				else if ((state & ButtonState.Pushed) == ButtonState.Pushed)
+					element = VisualStyleElement.Button.RadioButton.UncheckedPressed;
+				else
+					element = VisualStyleElement.Button.RadioButton.UncheckedNormal;
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.CPDrawRadioButton (dc, rectangle, state);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (dc, rectangle);
+		}
+		#endregion
+		#region DrawScrollButton
+		public override void CPDrawScrollButton (Graphics dc, Rectangle area, ScrollButton type, ButtonState state)
+		{
+			if (!RenderClientAreas ||
+				(state & ButtonState.Flat) == ButtonState.Flat ||
+				(state & ButtonState.Checked) == ButtonState.Checked) {
+				base.CPDrawScrollButton (dc, area, type, state);
+				return;
+			}
+			VisualStyleElement element = GetScrollButtonVisualStyleElement (type, state);
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.CPDrawScrollButton (dc, area, type, state);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (dc, area);
+		}
+		static VisualStyleElement GetScrollButtonVisualStyleElement (ScrollButton type, ButtonState state)
+		{
+			switch (type) {
+			case ScrollButton.Left:
+				if (IsDisabled (state))
+					return VisualStyleElement.ScrollBar.ArrowButton.LeftDisabled;
+				else if (IsPressed (state))
+					return VisualStyleElement.ScrollBar.ArrowButton.LeftPressed;
+				else
+					return VisualStyleElement.ScrollBar.ArrowButton.LeftNormal;
+			case ScrollButton.Right:
+				if (IsDisabled (state))
+					return VisualStyleElement.ScrollBar.ArrowButton.RightDisabled;
+				else if (IsPressed (state))
+					return VisualStyleElement.ScrollBar.ArrowButton.RightPressed;
+				else
+					return VisualStyleElement.ScrollBar.ArrowButton.RightNormal;
+			case ScrollButton.Up:
+				if (IsDisabled (state))
+					return VisualStyleElement.ScrollBar.ArrowButton.UpDisabled;
+				else if (IsPressed (state))
+					return VisualStyleElement.ScrollBar.ArrowButton.UpPressed;
+				else
+					return VisualStyleElement.ScrollBar.ArrowButton.UpNormal;
+			default:
+				if (IsDisabled (state))
+					return VisualStyleElement.ScrollBar.ArrowButton.DownDisabled;
+				else if (IsPressed (state))
+					return VisualStyleElement.ScrollBar.ArrowButton.DownPressed;
+				else
+					return VisualStyleElement.ScrollBar.ArrowButton.DownNormal;
+			}
+		}
+		static bool IsDisabled (ButtonState state)
+		{
+			return (state & ButtonState.Inactive) == ButtonState.Inactive;
+		}
+		static bool IsPressed (ButtonState state)
+		{
+			return (state & ButtonState.Pushed) == ButtonState.Pushed;
+		}
+		#endregion
+		#endregion
+		/* FIXME: I SAID NO.
+		#region DataGridView
+		#region DataGridViewHeaderCell
+		#region DataGridViewRowHeaderCell
+		public override bool DataGridViewRowHeaderCellDrawBackground (DataGridViewRowHeaderCell cell, Graphics g, Rectangle bounds)
+		{
+			if (!RenderClientAreas ||
+				!cell.DataGridView.EnableHeadersVisualStyles)
+				return base.DataGridViewRowHeaderCellDrawBackground (cell, g, bounds);
+			VisualStyleElement element = DataGridViewRowHeaderCellGetVisualStyleElement (cell);
+			if (!VisualStyleRenderer.IsElementDefined (element))
+				return base.DataGridViewRowHeaderCellDrawBackground (cell, g, bounds);
+			bounds.Width--;
+			Bitmap bitmap = new Bitmap (bounds.Height, bounds.Width);
+			Graphics bitmap_g = Graphics.FromImage (bitmap);
+			Rectangle bitmap_rectangle = new Rectangle (Point.Empty, bitmap.Size);
+			VisualStyleRenderer renderer = new VisualStyleRenderer (element);
+			if (!AreEqual (element, VisualStyleElement.Header.Item.Normal) && renderer.IsBackgroundPartiallyTransparent ())
+				new VisualStyleRenderer (VisualStyleElement.Header.Item.Normal).DrawBackground (bitmap_g, bitmap_rectangle);
+			renderer.DrawBackground (bitmap_g, bitmap_rectangle);
+			bitmap_g.Dispose ();
+			g.Transform = new Matrix(0, 1, 1, 0, 0, 0);
+			g.DrawImage (bitmap, bounds.Y, bounds.X);
+			bitmap.Dispose ();
+			g.ResetTransform ();
+			return true;
+		}
+		public override bool DataGridViewRowHeaderCellDrawSelectionBackground (DataGridViewRowHeaderCell cell)
+		{
+			if (!RenderClientAreas ||
+				!cell.DataGridView.EnableHeadersVisualStyles || !VisualStyleRenderer.IsElementDefined (DataGridViewRowHeaderCellGetVisualStyleElement (cell)))
+				return base.DataGridViewRowHeaderCellDrawSelectionBackground (cell);
+			return true;
+		}
+		public override bool DataGridViewRowHeaderCellDrawBorder (DataGridViewRowHeaderCell cell, Graphics g, Rectangle bounds)
+		{
+			if (!RenderClientAreas ||
+				!cell.DataGridView.EnableHeadersVisualStyles || !VisualStyleRenderer.IsElementDefined (DataGridViewRowHeaderCellGetVisualStyleElement (cell)))
+				return base.DataGridViewRowHeaderCellDrawBorder (cell, g, bounds);
+			g.DrawLine (cell.GetBorderPen (), bounds.Right - 1, bounds.Top, bounds.Right - 1, bounds.Bottom - 1);
+			return true;
+		}
+		static VisualStyleElement DataGridViewRowHeaderCellGetVisualStyleElement (DataGridViewRowHeaderCell cell)
+		{
+			if (cell.DataGridView.PressedHeaderCell == cell)
+				return VisualStyleElement.Header.Item.Pressed;
+			if (cell.DataGridView.EnteredHeaderCell == cell)
+				return VisualStyleElement.Header.Item.Hot;
+			if (cell.OwningRow.SelectedInternal)
+				return VisualStyleElement.Header.Item.Pressed;
+			return VisualStyleElement.Header.Item.Normal;
+		}
+		#endregion
+		#region DataGridViewColumnHeaderCell
+		public override bool DataGridViewColumnHeaderCellDrawBackground (DataGridViewColumnHeaderCell cell, Graphics g, Rectangle bounds)
+		{
+			if (!RenderClientAreas ||
+				!cell.DataGridView.EnableHeadersVisualStyles || cell is DataGridViewTopLeftHeaderCell)
+				return base.DataGridViewColumnHeaderCellDrawBackground (cell, g, bounds);
+			VisualStyleElement element = DataGridViewColumnHeaderCellGetVisualStyleElement (cell);
+			if (!VisualStyleRenderer.IsElementDefined (element))
+				return base.DataGridViewColumnHeaderCellDrawBackground (cell, g, bounds);
+			bounds.Height--;
+			VisualStyleRenderer renderer = new VisualStyleRenderer (element);
+			if (!AreEqual (element, VisualStyleElement.Header.Item.Normal) && renderer.IsBackgroundPartiallyTransparent ())
+			    new VisualStyleRenderer (VisualStyleElement.Header.Item.Normal).DrawBackground (g, bounds);
+			renderer.DrawBackground (g, bounds);
+			return true;
+		}
+		public override bool DataGridViewColumnHeaderCellDrawBorder (DataGridViewColumnHeaderCell cell, Graphics g, Rectangle bounds)
+		{
+			if (!RenderClientAreas ||
+				!cell.DataGridView.EnableHeadersVisualStyles ||
+				cell is DataGridViewTopLeftHeaderCell ||
+				!VisualStyleRenderer.IsElementDefined (VisualStyleElement.Header.Item.Normal))
+				return base.DataGridViewColumnHeaderCellDrawBorder (cell, g, bounds);
+			g.DrawLine (cell.GetBorderPen (), bounds.Left, bounds.Bottom - 1, bounds.Right - 1, bounds.Bottom - 1);
+			return true;
+		}
+		static VisualStyleElement DataGridViewColumnHeaderCellGetVisualStyleElement (DataGridViewColumnHeaderCell cell)
+		{
+			if (cell.DataGridView.PressedHeaderCell == cell)
+				return VisualStyleElement.Header.Item.Pressed;
+			if (cell.DataGridView.EnteredHeaderCell == cell)
+				return VisualStyleElement.Header.Item.Hot;
+			return VisualStyleElement.Header.Item.Normal;
+		}
+		#endregion
+		public override bool DataGridViewHeaderCellHasPressedStyle (DataGridView dataGridView)
+		{
+			if (!RenderClientAreas ||
+				!dataGridView.EnableHeadersVisualStyles ||
+				!VisualStyleRenderer.IsElementDefined (VisualStyleElement.Header.Item.Pressed))
+				return base.DataGridViewHeaderCellHasPressedStyle (dataGridView);
+			return true;
+		}
+		public override bool DataGridViewHeaderCellHasHotStyle (DataGridView dataGridView)
+		{
+			if (!RenderClientAreas ||
+				!dataGridView.EnableHeadersVisualStyles ||
+				!VisualStyleRenderer.IsElementDefined (VisualStyleElement.Header.Item.Hot))
+				return base.DataGridViewHeaderCellHasHotStyle (dataGridView);
+			return true;
+		}
+		#endregion
+		#endregion*/
+
+		#region DateTimePicker
+		#region Border
+		protected override void DateTimePickerDrawBorder (DateTimePicker dateTimePicker, Graphics g, Rectangle clippingArea)
+		{
+			if (!RenderClientAreas) {
+				base.DateTimePickerDrawBorder (dateTimePicker, g, clippingArea);
+				return;
+			}
+			VisualStyleElement element;
+			if (!dateTimePicker.Enabled)
+				element = VisualStyleElement.DatePicker.DateBorder.Disabled;
+			else if (dateTimePicker.Entered)
+				element = VisualStyleElement.DatePicker.DateBorder.Hot;
+			else if (dateTimePicker.Focused)
+				element = VisualStyleElement.DatePicker.DateBorder.Focused;
+			else
+				element = VisualStyleElement.DatePicker.DateBorder.Normal;
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.DateTimePickerDrawBorder (dateTimePicker, g, clippingArea);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (g, new Rectangle (Point.Empty, dateTimePicker.Size), clippingArea);
+		}
+		public override bool DateTimePickerBorderHasHotElementStyle {
+			get {
+				if (RenderClientAreas &&
+					VisualStyleRenderer.IsElementDefined (VisualStyleElement.DatePicker.DateBorder.Hot))
+					return true;
+				return base.DateTimePickerBorderHasHotElementStyle;
+			}
+		}
+		#endregion
+		#region Drop down button
+		protected override void DateTimePickerDrawDropDownButton (DateTimePicker dateTimePicker, Graphics g, Rectangle clippingArea)
+		{
+			if (!RenderClientAreas) {
+				base.DateTimePickerDrawDropDownButton (dateTimePicker, g, clippingArea);
+				return;
+			}
+			VisualStyleElement element;
+			if (!dateTimePicker.Enabled)
+				element = VisualStyleElement.DatePicker.ShowCalendarButtonRight.Disabled;
+			else if (dateTimePicker.is_drop_down_visible)
+				element = VisualStyleElement.DatePicker.ShowCalendarButtonRight.Pressed;
+			else if (dateTimePicker.DropDownButtonEntered)
+				element = VisualStyleElement.DatePicker.ShowCalendarButtonRight.Hot;
+			else
+				element = VisualStyleElement.DatePicker.ShowCalendarButtonRight.Normal;
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.DateTimePickerDrawDropDownButton (dateTimePicker, g, clippingArea);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (g, dateTimePicker.drop_down_arrow_rect, clippingArea);
+		}
+		//TODO: Until somebody figures out how to obtain the proper width this will need to be updated when new Windows versions/themes are released.
+		const int DateTimePickerDropDownWidthOnWindowsVista = 34;
+		const int DateTimePickerDropDownHeightOnWindowsVista = 20;
+		public override Rectangle DateTimePickerGetDropDownButtonArea (DateTimePicker dateTimePicker)
+		{
+			if (!RenderClientAreas)
+				return base.DateTimePickerGetDropDownButtonArea (dateTimePicker);
+			VisualStyleElement element = VisualStyleElement.DatePicker.ShowCalendarButtonRight.Pressed;
+			if (!VisualStyleRenderer.IsElementDefined (element))
+				return base.DateTimePickerGetDropDownButtonArea (dateTimePicker);
+			Size size = new Size (DateTimePickerDropDownWidthOnWindowsVista, DateTimePickerDropDownHeightOnWindowsVista);
+			return new Rectangle (dateTimePicker.Width - size.Width, 0, size.Width, size.Height);
+		}
+		public override Rectangle DateTimePickerGetDateArea (DateTimePicker dateTimePicker)
+		{
+			if (!RenderClientAreas ||
+				dateTimePicker.ShowUpDown)
+				return base.DateTimePickerGetDateArea (dateTimePicker);
+			VisualStyleElement element = VisualStyleElement.DatePicker.DateBorder.Normal;
+			if (!VisualStyleRenderer.IsElementDefined (element))
+				return base.DateTimePickerGetDateArea (dateTimePicker);
+			Graphics g = dateTimePicker.CreateGraphics ();
+			Rectangle result = new VisualStyleRenderer (element).GetBackgroundContentRectangle (g, dateTimePicker.ClientRectangle);
+			g.Dispose ();
+			result.Width -= DateTimePickerDropDownWidthOnWindowsVista;
+			return result;
+		}
+		public override bool DateTimePickerDropDownButtonHasHotElementStyle {
+			get {
+				if (RenderClientAreas &&
+					VisualStyleRenderer.IsElementDefined (VisualStyleElement.DatePicker.ShowCalendarButtonRight.Hot))
+					return true;
+				return base.DateTimePickerDropDownButtonHasHotElementStyle;
+			}
+		}
+		#endregion
+		#endregion
+		#region ListView
+		protected override void ListViewDrawColumnHeaderBackground (ListView listView, ColumnHeader columnHeader, Graphics g, Rectangle area, Rectangle clippingArea)
+		{
+			if (!RenderClientAreas) {
+				base.ListViewDrawColumnHeaderBackground (listView, columnHeader, g, area, clippingArea);
+				return;
+			}
+			VisualStyleElement element;
+			if (listView.HeaderStyle == ColumnHeaderStyle.Clickable)
+				if (columnHeader.Pressed)
+					element = VisualStyleElement.Header.Item.Pressed;
+				else if (columnHeader == listView.EnteredColumnHeader)
+					element = VisualStyleElement.Header.Item.Hot;
+				else
+					element = VisualStyleElement.Header.Item.Normal;
+			else
+				element = VisualStyleElement.Header.Item.Normal;
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.ListViewDrawColumnHeaderBackground (listView, columnHeader, g, area, clippingArea);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (g, area, clippingArea);
+		}
+		protected override void ListViewDrawUnusedHeaderBackground (ListView listView, Graphics g, Rectangle area, Rectangle clippingArea)
+		{
+			if (!RenderClientAreas) {
+				base.ListViewDrawUnusedHeaderBackground (listView, g, area, clippingArea);
+				return;
+			}
+			VisualStyleElement element = VisualStyleElement.Header.Item.Normal;
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.ListViewDrawUnusedHeaderBackground (listView, g, area, clippingArea);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (g, area, clippingArea);
+		}
+		public override bool ListViewHasHotHeaderStyle {
+			get {
+				if (!RenderClientAreas ||
+					!VisualStyleRenderer.IsElementDefined (VisualStyleElement.Header.Item.Hot))
+					return base.ListViewHasHotHeaderStyle;
+				return true;
+			}
+		}
+		public override int ListViewGetHeaderHeight (ListView listView, Font font)
+		{
+			if (!RenderClientAreas)
+				return base.ListViewGetHeaderHeight (listView, font);
+			VisualStyleElement element = VisualStyleElement.Header.Item.Normal;
+			if (!VisualStyleRenderer.IsElementDefined (element))
+				return base.ListViewGetHeaderHeight (listView, font);
+			Widget control = null;
+			Graphics g;
+			if (listView == null) {
+				control = new Widget ();
+				g = control.CreateGraphics ();
+			} else
+				g = listView.CreateGraphics ();
+			int result = new VisualStyleRenderer (element).GetPartSize (g, ThemeSizeType.True).Height;
+			g.Dispose ();
+			if (listView == null)
+				control.Dispose ();
+			return result;
+		}
+		#endregion
+		#region GroupBox
+		public override void DrawGroupBox (Graphics dc, Rectangle area, GroupBox box)
+		{
+			GroupBoxRenderer.DrawGroupBox (
+				dc,
+				new Rectangle (Point.Empty, box.Size),
+				box.Text,
+				box.Font,
+				box.ForeColor == GroupBox.DefaultForeColor ? Color.Empty : box.ForeColor,
+				box.Enabled ? GroupBoxState.Normal : GroupBoxState.Disabled);
+		}
+		#endregion
+		#region Managed window
+		Rectangle ManagedWindowGetTitleBarRectangle (InternalWindowManager wm)
+		{
+			return new Rectangle (0, 0, wm.Form.Width, ManagedWindowTitleBarHeight (wm) + ManagedWindowBorderWidth (wm) * (wm.IsMinimized ? 2 : 1));
+		}
+		Region ManagedWindowGetWindowRegion (Form form)
+		{
+			if (form.WindowManager is MdiWindowManager && form.WindowManager.IsMaximized)
+				return null;
+			VisualStyleElement title_bar_element = ManagedWindowGetTitleBarVisualStyleElement (form.WindowManager);
+			if (!VisualStyleRenderer.IsElementDefined (title_bar_element))
+				return null;
+			VisualStyleRenderer renderer = new VisualStyleRenderer (title_bar_element);
+			if (!renderer.IsBackgroundPartiallyTransparent ())
+				return null;
+			IDeviceContext dc = GetMeasurementDeviceContext ();
+			Rectangle title_bar_rectangle = ManagedWindowGetTitleBarRectangle (form.WindowManager);
+			Region region = renderer.GetBackgroundRegion (dc, title_bar_rectangle);
+			ReleaseMeasurementDeviceContext (dc);
+			region.Union (new Rectangle (0, title_bar_rectangle.Bottom, form.Width, form.Height));
+			return region;
+		}
+		public override void ManagedWindowOnSizeInitializedOrChanged (Form form)
+		{
+			base.ManagedWindowOnSizeInitializedOrChanged (form);
+			if (!render_non_client_areas)
+				return;
+			form.Region = ManagedWindowGetWindowRegion (form);
+		}
+		protected override Rectangle ManagedWindowDrawTitleBarAndBorders (Graphics dc, Rectangle clip, InternalWindowManager wm)
+		{
+			if (!render_non_client_areas)
+				return base.ManagedWindowDrawTitleBarAndBorders (dc, clip, wm);
+			VisualStyleElement title_bar_element = ManagedWindowGetTitleBarVisualStyleElement (wm);
+			VisualStyleElement left_border_element;
+			VisualStyleElement right_border_element;
+			VisualStyleElement bottom_border_element;
+			ManagedWindowGetBorderVisualStyleElements (wm, out left_border_element, out right_border_element, out bottom_border_element);
+			if (!VisualStyleRenderer.IsElementDefined (title_bar_element) ||
+				(!wm.IsMinimized && (
+				!VisualStyleRenderer.IsElementDefined (left_border_element) ||
+				!VisualStyleRenderer.IsElementDefined (right_border_element) ||
+				!VisualStyleRenderer.IsElementDefined (bottom_border_element))))
+				return base.ManagedWindowDrawTitleBarAndBorders (dc, clip, wm);
+			VisualStyleRenderer renderer = new VisualStyleRenderer (title_bar_element);
+			Rectangle title_bar_rectangle = ManagedWindowGetTitleBarRectangle (wm);
+			renderer.DrawBackground (dc, title_bar_rectangle, clip);
+			if (!wm.IsMinimized) {
+				int border_width = ManagedWindowBorderWidth (wm);
+				renderer.SetParameters (left_border_element);
+				renderer.DrawBackground (dc, new Rectangle (
+					0,
+					title_bar_rectangle.Bottom,
+					border_width,
+					wm.Form.Height - title_bar_rectangle.Bottom
+					), clip);
+				renderer.SetParameters (right_border_element);
+				renderer.DrawBackground (dc, new Rectangle (
+					wm.Form.Width - border_width,
+					title_bar_rectangle.Bottom,
+					border_width,
+					wm.Form.Height - title_bar_rectangle.Bottom
+					), clip);
+				renderer.SetParameters (bottom_border_element);
+				renderer.DrawBackground (dc, new Rectangle (
+					0,
+					wm.Form.Height - border_width,
+					wm.Form.Width,
+					border_width
+					), clip);
+			}
+			return title_bar_rectangle;
+		}
+		static FormWindowState ManagedWindowGetWindowState (InternalWindowManager wm)
+		{
+			return wm.GetWindowState ();
+		}
+		static bool ManagedWindowIsDisabled (InternalWindowManager wm)
+		{
+			return !wm.Form.Enabled;
+		}
+		static bool ManagedWindowIsActive (InternalWindowManager wm)
+		{
+			return wm.IsActive;
+		}
+		static VisualStyleElement ManagedWindowGetTitleBarVisualStyleElement (InternalWindowManager wm)
+		{
+			if (wm.IsToolWindow)
+				#region Small window
+				switch (ManagedWindowGetWindowState (wm)) {
+				case FormWindowState.Minimized:
+					if (ManagedWindowIsDisabled (wm))
+						return VisualStyleElement.Window.SmallMinCaption.Disabled;
+					else if (ManagedWindowIsActive (wm))
+						return VisualStyleElement.Window.SmallMinCaption.Active;
+					return VisualStyleElement.Window.SmallMinCaption.Inactive;
+				case FormWindowState.Maximized:
+					if (ManagedWindowIsDisabled (wm))
+						return VisualStyleElement.Window.SmallMaxCaption.Disabled;
+					else if (ManagedWindowIsActive (wm))
+						return VisualStyleElement.Window.SmallMaxCaption.Active;
+					return VisualStyleElement.Window.SmallMaxCaption.Inactive;
+				default:
+					if (ManagedWindowIsDisabled (wm))
+						return VisualStyleElement.Window.SmallCaption.Disabled;
+					else if (ManagedWindowIsActive (wm))
+						return VisualStyleElement.Window.SmallCaption.Active;
+					return VisualStyleElement.Window.SmallCaption.Inactive;
+				}
+				#endregion
+			else
+				#region Normal window
+				switch (ManagedWindowGetWindowState (wm)) {
+				case FormWindowState.Minimized:
+					if (ManagedWindowIsDisabled (wm))
+						return VisualStyleElement.Window.MinCaption.Disabled;
+					else if (ManagedWindowIsActive (wm))
+						return VisualStyleElement.Window.MinCaption.Active;
+					return VisualStyleElement.Window.MinCaption.Inactive;
+				case FormWindowState.Maximized:
+					if (ManagedWindowIsDisabled (wm))
+						return VisualStyleElement.Window.MaxCaption.Disabled;
+					else if (ManagedWindowIsActive (wm))
+						return VisualStyleElement.Window.MaxCaption.Active;
+					return VisualStyleElement.Window.MaxCaption.Inactive;
+				default:
+					if (ManagedWindowIsDisabled (wm))
+						return VisualStyleElement.Window.Caption.Disabled;
+					else if (ManagedWindowIsActive (wm))
+						return VisualStyleElement.Window.Caption.Active;
+					return VisualStyleElement.Window.Caption.Inactive;
+				}
+				#endregion
+		}
+		static void ManagedWindowGetBorderVisualStyleElements (InternalWindowManager wm, out VisualStyleElement left, out VisualStyleElement right, out VisualStyleElement bottom)
+		{
+			bool active = !ManagedWindowIsDisabled (wm) && ManagedWindowIsActive (wm);
+			if (wm.IsToolWindow) {
+				if (active) {
+					left = VisualStyleElement.Window.SmallFrameLeft.Active;
+					right = VisualStyleElement.Window.SmallFrameRight.Active;
+					bottom = VisualStyleElement.Window.SmallFrameBottom.Active;
+				} else {
+					left = VisualStyleElement.Window.SmallFrameLeft.Inactive;
+					right = VisualStyleElement.Window.SmallFrameRight.Inactive;
+					bottom = VisualStyleElement.Window.SmallFrameBottom.Inactive;
+				}
+			} else {
+				if (active) {
+					left = VisualStyleElement.Window.FrameLeft.Active;
+					right = VisualStyleElement.Window.FrameRight.Active;
+					bottom = VisualStyleElement.Window.FrameBottom.Active;
+				} else {
+					left = VisualStyleElement.Window.FrameLeft.Inactive;
+					right = VisualStyleElement.Window.FrameRight.Inactive;
+					bottom = VisualStyleElement.Window.FrameBottom.Inactive;
+				}
+			}
+		}
+		public override bool ManagedWindowTitleButtonHasHotElementStyle (TitleButton button, Form form)
+		{
+			if (render_non_client_areas && (button.State & ButtonState.Inactive) != ButtonState.Inactive) {
+				VisualStyleElement element;
+				if (ManagedWindowIsMaximizedMdiChild (form))
+					switch (button.Caption) {
+					case CaptionButton.Close:
+						element = VisualStyleElement.Window.MdiCloseButton.Hot;
+						break;
+					case CaptionButton.Help:
+						element = VisualStyleElement.Window.MdiHelpButton.Hot;
+						break;
+					case CaptionButton.Minimize:
+						element = VisualStyleElement.Window.MdiMinButton.Hot;
+						break;
+					default:
+						element = VisualStyleElement.Window.MdiRestoreButton.Hot;
+						break;
+					}
+				else if (form.WindowManager.IsToolWindow)
+					element = VisualStyleElement.Window.SmallCloseButton.Hot;
+				else
+					switch (button.Caption) {
+					case CaptionButton.Close:
+						element = VisualStyleElement.Window.CloseButton.Hot;
+						break;
+					case CaptionButton.Help:
+						element = VisualStyleElement.Window.HelpButton.Hot;
+						break;
+					case CaptionButton.Maximize:
+						element = VisualStyleElement.Window.MaxButton.Hot;
+						break;
+					case CaptionButton.Minimize:
+						element = VisualStyleElement.Window.MinButton.Hot;
+						break;
+					default:
+						element = VisualStyleElement.Window.RestoreButton.Hot;
+						break;
+					}
+				if (VisualStyleRenderer.IsElementDefined (element))
+					return true;
+			}
+			return base.ManagedWindowTitleButtonHasHotElementStyle (button, form);
+		}
+		static bool ManagedWindowIsMaximizedMdiChild (Form form)
+		{
+			return form.WindowManager is MdiWindowManager &&
+				ManagedWindowGetWindowState (form.WindowManager) == FormWindowState.Maximized;
+		}
+		static bool ManagedWindowTitleButtonIsDisabled (TitleButton button, InternalWindowManager wm)
+		{
+			return (button.State & ButtonState.Inactive) == ButtonState.Inactive;
+		}
+		static bool ManagedWindowTitleButtonIsPressed (TitleButton button)
+		{
+			return (button.State & ButtonState.Pushed) == ButtonState.Pushed;
+		}
+		static VisualStyleElement ManagedWindowGetTitleButtonVisualStyleElement (TitleButton button, Form form)
+		{
+			if (form.WindowManager.IsToolWindow) {
+				if (ManagedWindowTitleButtonIsDisabled (button, form.WindowManager))
+					return VisualStyleElement.Window.SmallCloseButton.Disabled;
+				if (ManagedWindowTitleButtonIsPressed (button))
+					return VisualStyleElement.Window.SmallCloseButton.Pressed;
+				if (button.Entered)
+					return VisualStyleElement.Window.SmallCloseButton.Hot;
+				return VisualStyleElement.Window.SmallCloseButton.Normal;
+			}
+			switch (button.Caption) {
+			case CaptionButton.Close:
+				if (ManagedWindowTitleButtonIsDisabled (button, form.WindowManager))
+					return VisualStyleElement.Window.CloseButton.Disabled;
+				if (ManagedWindowTitleButtonIsPressed (button))
+					return VisualStyleElement.Window.CloseButton.Pressed;
+				if (button.Entered)
+					return VisualStyleElement.Window.CloseButton.Hot;
+				return VisualStyleElement.Window.CloseButton.Normal;
+			case CaptionButton.Help:
+				if (ManagedWindowTitleButtonIsDisabled (button, form.WindowManager))
+					return VisualStyleElement.Window.HelpButton.Disabled;
+				if (ManagedWindowTitleButtonIsPressed (button))
+					return VisualStyleElement.Window.HelpButton.Pressed;
+				if (button.Entered)
+					return VisualStyleElement.Window.HelpButton.Hot;
+				return VisualStyleElement.Window.HelpButton.Normal;
+			case CaptionButton.Maximize:
+				if (ManagedWindowTitleButtonIsDisabled (button, form.WindowManager))
+					return VisualStyleElement.Window.MaxButton.Disabled;
+				if (ManagedWindowTitleButtonIsPressed (button))
+					return VisualStyleElement.Window.MaxButton.Pressed;
+				if (button.Entered)
+					return VisualStyleElement.Window.MaxButton.Hot;
+				return VisualStyleElement.Window.MaxButton.Normal;
+			case CaptionButton.Minimize:
+				if (ManagedWindowTitleButtonIsDisabled (button, form.WindowManager))
+					return VisualStyleElement.Window.MinButton.Disabled;
+				if (ManagedWindowTitleButtonIsPressed (button))
+					return VisualStyleElement.Window.MinButton.Pressed;
+				if (button.Entered)
+					return VisualStyleElement.Window.MinButton.Hot;
+				return VisualStyleElement.Window.MinButton.Normal;
+			default:
+				if (ManagedWindowTitleButtonIsDisabled (button, form.WindowManager))
+					return VisualStyleElement.Window.RestoreButton.Disabled;
+				if (ManagedWindowTitleButtonIsPressed (button))
+					return VisualStyleElement.Window.RestoreButton.Pressed;
+				if (button.Entered)
+					return VisualStyleElement.Window.RestoreButton.Hot;
+				return VisualStyleElement.Window.RestoreButton.Normal;
+			}
+		}
+		protected override void ManagedWindowDrawTitleButton (Graphics dc, TitleButton button, Rectangle clip, Form form)
+		{
+			if (!render_non_client_areas) {
+				base.ManagedWindowDrawTitleButton (dc, button, clip, form);
+				return;
+			}
+			VisualStyleElement element = ManagedWindowGetTitleButtonVisualStyleElement (button, form);
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.ManagedWindowDrawTitleButton (dc, button, clip, form);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (dc, button.Rectangle, clip);
+		}
+		public override Size ManagedWindowButtonSize (InternalWindowManager wm)
+		{
+			if (!render_non_client_areas)
+				return base.ManagedWindowButtonSize (wm);
+			VisualStyleElement element = wm.IsToolWindow && !wm.IsMinimized ?
+				VisualStyleElement.Window.SmallCloseButton.Normal :
+				VisualStyleElement.Window.CloseButton.Normal;
+			if (!VisualStyleRenderer.IsElementDefined (element))
+				return base.ManagedWindowButtonSize (wm);
+			IDeviceContext dc = GetMeasurementDeviceContext ();
+			Size result = new VisualStyleRenderer (element).GetPartSize (dc, ThemeSizeType.True);
+			ReleaseMeasurementDeviceContext (dc);
+			return result;
+		}
+		public override void ManagedWindowDrawMenuButton (Graphics dc, TitleButton button, Rectangle clip, InternalWindowManager wm)
+		{
+			if (!render_non_client_areas) {
+				base.ManagedWindowDrawMenuButton (dc, button, clip, wm);
+				return;
+			}
+			VisualStyleElement element = ManagedWindowGetMenuButtonVisualStyleElement (button, wm);
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.ManagedWindowDrawMenuButton (dc, button, clip, wm);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (dc, button.Rectangle, clip);
+		}
+		static VisualStyleElement ManagedWindowGetMenuButtonVisualStyleElement (TitleButton button, InternalWindowManager wm)
+		{
+			switch (button.Caption) {
+			case CaptionButton.Close:
+				if (ManagedWindowTitleButtonIsDisabled (button, wm))
+					return VisualStyleElement.Window.MdiCloseButton.Disabled;
+				if (ManagedWindowTitleButtonIsPressed (button))
+					return VisualStyleElement.Window.MdiCloseButton.Pressed;
+				if (button.Entered)
+					return VisualStyleElement.Window.MdiCloseButton.Hot;
+				return VisualStyleElement.Window.MdiCloseButton.Normal;
+			case CaptionButton.Help:
+				if (ManagedWindowTitleButtonIsDisabled (button, wm))
+					return VisualStyleElement.Window.MdiHelpButton.Disabled;
+				if (ManagedWindowTitleButtonIsPressed (button))
+					return VisualStyleElement.Window.MdiHelpButton.Pressed;
+				if (button.Entered)
+					return VisualStyleElement.Window.MdiHelpButton.Hot;
+				return VisualStyleElement.Window.MdiHelpButton.Normal;
+			case CaptionButton.Minimize:
+				if (ManagedWindowTitleButtonIsDisabled (button, wm))
+					return VisualStyleElement.Window.MdiMinButton.Disabled;
+				if (ManagedWindowTitleButtonIsPressed (button))
+					return VisualStyleElement.Window.MdiMinButton.Pressed;
+				if (button.Entered)
+					return VisualStyleElement.Window.MdiMinButton.Hot;
+				return VisualStyleElement.Window.MdiMinButton.Normal;
+			default:
+				if (ManagedWindowTitleButtonIsDisabled (button, wm))
+					return VisualStyleElement.Window.MdiRestoreButton.Disabled;
+				if (ManagedWindowTitleButtonIsPressed (button))
+					return VisualStyleElement.Window.MdiRestoreButton.Pressed;
+				if (button.Entered)
+					return VisualStyleElement.Window.MdiRestoreButton.Hot;
+				return VisualStyleElement.Window.MdiRestoreButton.Normal;
+			}
+		}
+		#endregion
+		#region ProgressBar
+		public override void DrawProgressBar (Graphics dc, Rectangle clip_rect, ProgressBar ctrl)
+		{
+			if (!RenderClientAreas ||
+				!VisualStyleRenderer.IsElementDefined (VisualStyleElement.ProgressBar.Bar.Normal) ||
+				!VisualStyleRenderer.IsElementDefined (VisualStyleElement.ProgressBar.Chunk.Normal)) {
+				base.DrawProgressBar (dc, clip_rect, ctrl);
+				return;
+			}
+			VisualStyleRenderer renderer = new VisualStyleRenderer (VisualStyleElement.ProgressBar.Bar.Normal);
+			renderer.DrawBackground (dc, ctrl.ClientRectangle, clip_rect);
+			Rectangle client_area = renderer.GetBackgroundContentRectangle (dc, new Rectangle (Point.Empty, ctrl.Size));
+			renderer = new VisualStyleRenderer (VisualStyleElement.ProgressBar.Chunk.Normal);
+			/* 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
+				client_area.Width = (int)(client_area.Width * ((double)(ctrl.Value - ctrl.Minimum) / (double)(Math.Max (ctrl.Maximum - ctrl.Minimum, 1))));
+				renderer.DrawBackground (dc, client_area, clip_rect);
+				break;
+			case 2: // Marquee
+				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 default;
+			default: // Blocks
+				int block_width = renderer.GetInteger (IntegerProperty.ProgressChunkSize);
+				block_width = Math.Max (block_width, 0); // block_width is used to break out the loop below, it must be >= 0!
+				int first_pixel_outside_filled_area = (int)(((double)(ctrl.Value - ctrl.Minimum) * client_area.Width) / (Math.Max (ctrl.Maximum - ctrl.Minimum, 1))) + client_area.X;
+				int block_count = 0;
+				int increment = block_width + renderer.GetInteger (IntegerProperty.ProgressSpaceSize);
+				Rectangle 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.Right >= client_area.Width)
+							block_rect.X -= client_area.Width;
+					} else {
+						if (block_rect.X >= first_pixel_outside_filled_area)
+							break;
+						if (block_rect.Right >= first_pixel_outside_filled_area)
+							if (first_pixel_outside_filled_area == client_area.Right)
+								block_rect.Width = first_pixel_outside_filled_area - block_rect.X;
+							else
+								break;
+					}
+					if (clip_rect.IntersectsWith (block_rect))
+						renderer.DrawBackground (dc, block_rect, clip_rect);
+					block_rect.X += increment;
+					block_count++;
+				}
+				break;
+			}
+		}
+		#endregion
+		#region RadioButton
+		protected override void RadioButton_DrawButton (RadioButton radio_button, Graphics dc, ButtonState state, Rectangle radiobutton_rectangle) {
+			if (radio_button.Appearance == Appearance.Normal && radio_button.FlatStyle == FlatStyle.System) {
+				RadioButtonRenderer.DrawRadioButton (
+					dc,
+					new Point (radiobutton_rectangle.Left, radiobutton_rectangle.Top),
+					GetRadioButtonState (radio_button)
+				);
+				return;
+			}
+			base.RadioButton_DrawButton(radio_button, dc, state, radiobutton_rectangle);
+		}
+		static RadioButtonState GetRadioButtonState (RadioButton checkBox)
+		{
+			if (checkBox.Checked) {
+				if (!checkBox.Enabled)
+					return RadioButtonState.CheckedDisabled;
+				else if (checkBox.Pressed)
+					return RadioButtonState.CheckedPressed;
+				else if (checkBox.Entered)
+					return RadioButtonState.CheckedHot;
+				return RadioButtonState.CheckedNormal;
+			} else {
+				if (!checkBox.Enabled)
+					return RadioButtonState.UncheckedDisabled;
+				else if (checkBox.Pressed)
+					return RadioButtonState.UncheckedPressed;
+				else if (checkBox.Entered)
+					return RadioButtonState.UncheckedHot;
+				return RadioButtonState.UncheckedNormal;
+			}
+		}
+		#endregion
+		#region ScrollBar
+		public override void DrawScrollBar (Graphics dc, Rectangle clip, ScrollBar bar)
+		{
+			if (!RenderClientAreas ||
+				!ScrollBarAreElementsDefined) {
+				base.DrawScrollBar (dc, clip, bar);
+				return;
+			}
+			VisualStyleElement element;
+			VisualStyleRenderer renderer;
+			int scroll_button_width = bar.scrollbutton_width;
+			int scroll_button_height = bar.scrollbutton_height;
+			if (bar.vert) {
+				bar.FirstArrowArea = new Rectangle (0, 0, bar.Width, scroll_button_height);
+				bar.SecondArrowArea = new Rectangle (
+					0,
+					bar.ClientRectangle.Height - scroll_button_height,
+					bar.Width,
+					scroll_button_height);
+				Rectangle thumb_pos = bar.ThumbPos;
+				thumb_pos.Width = bar.Width;
+				bar.ThumbPos = thumb_pos;
+				#region Background, upper track
+				if (bar.thumb_moving == ScrollBar.ThumbMoving.Backwards)
+					element = VisualStyleElement.ScrollBar.LowerTrackVertical.Pressed;
+				else
+					element = bar.Enabled ?
+						VisualStyleElement.ScrollBar.LowerTrackVertical.Normal :
+						VisualStyleElement.ScrollBar.LowerTrackVertical.Disabled;
+				renderer = new VisualStyleRenderer (element);
+				Rectangle upper_track_rect = new Rectangle (
+					0,
+					0,
+					bar.ClientRectangle.Width,
+					bar.ThumbPos.Top);
+				if (clip.IntersectsWith (upper_track_rect))
+					renderer.DrawBackground (dc, upper_track_rect, clip);
+				#endregion
+				#region Background, lower track
+				if (bar.thumb_moving == ScrollBar.ThumbMoving.Forward)
+					element = VisualStyles.VisualStyleElement.ScrollBar.LowerTrackVertical.Pressed;
+				else
+					element = bar.Enabled ?
+						VisualStyleElement.ScrollBar.LowerTrackVertical.Normal :
+						VisualStyleElement.ScrollBar.LowerTrackVertical.Disabled;
+				renderer = new VisualStyleRenderer (element);
+				Rectangle lower_track_rect = new Rectangle (
+					0,
+					bar.ThumbPos.Bottom,
+					bar.ClientRectangle.Width,
+					bar.ClientRectangle.Height - bar.ThumbPos.Bottom);
+				if (clip.IntersectsWith (lower_track_rect))
+					renderer.DrawBackground (dc, lower_track_rect, clip);
+				#endregion
+				#region Buttons
+				if (clip.IntersectsWith (bar.FirstArrowArea)) {
+					if (!bar.Enabled)
+						element = VisualStyleElement.ScrollBar.ArrowButton.UpDisabled;
+					else if (bar.firstbutton_state == ButtonState.Pushed)
+						element = VisualStyleElement.ScrollBar.ArrowButton.UpPressed;
+					else if (bar.FirstButtonEntered)
+						element = VisualStyleElement.ScrollBar.ArrowButton.UpHot;
+					else if (ScrollBarHasHoverArrowButtonStyleVisualStyles && bar.Entered)
+						element = VisualStyleElement.ScrollBar.ArrowButton.UpHover;
+					else
+						element = VisualStyleElement.ScrollBar.ArrowButton.UpNormal;
+					renderer = new VisualStyleRenderer (element);
+					renderer.DrawBackground (dc, bar.FirstArrowArea);
+				}
+				if (clip.IntersectsWith (bar.SecondArrowArea)) {
+					if (!bar.Enabled)
+						element = VisualStyleElement.ScrollBar.ArrowButton.DownDisabled;
+					else if (bar.secondbutton_state == ButtonState.Pushed)
+						element = VisualStyleElement.ScrollBar.ArrowButton.DownPressed;
+					else if (bar.SecondButtonEntered)
+						element = VisualStyleElement.ScrollBar.ArrowButton.DownHot;
+					else if (ScrollBarHasHoverArrowButtonStyleVisualStyles && bar.Entered)
+						element = VisualStyleElement.ScrollBar.ArrowButton.DownHover;
+					else
+						element = VisualStyleElement.ScrollBar.ArrowButton.DownNormal;
+					renderer = new VisualStyleRenderer (element);
+					renderer.DrawBackground (dc, bar.SecondArrowArea);
+				}
+				#endregion
+				#region Thumb and grip
+				if (!bar.Enabled)
+					element = VisualStyleElement.ScrollBar.LowerTrackVertical.Disabled;
+				else if (bar.ThumbPressed)
+					element = VisualStyleElement.ScrollBar.ThumbButtonVertical.Pressed;
+				else if (bar.ThumbEntered)
+					element = VisualStyleElement.ScrollBar.ThumbButtonVertical.Hot;
+				else
+					element = VisualStyleElement.ScrollBar.ThumbButtonVertical.Normal;
+				renderer = new VisualStyleRenderer (element);
+				renderer.DrawBackground (dc, bar.ThumbPos, clip);
+
+				if (bar.Enabled && bar.ThumbPos.Height >= 20) {
+					element = VisualStyleElement.ScrollBar.GripperVertical.Normal;
+					if (VisualStyleRenderer.IsElementDefined (element)) {
+						renderer = new VisualStyleRenderer (element);
+						renderer.DrawBackground (dc, bar.ThumbPos, clip);
+					}
+				}
+				#endregion
+			} else {
+				bar.FirstArrowArea = new Rectangle (0, 0, scroll_button_width, bar.Height);
+				bar.SecondArrowArea = new Rectangle (
+					bar.ClientRectangle.Width - scroll_button_width,
+					0,
+					scroll_button_width,
+					bar.Height);
+				Rectangle thumb_pos = bar.ThumbPos;
+				thumb_pos.Height = bar.Height;
+				bar.ThumbPos = thumb_pos;
+				#region Background, left track
+				if (bar.thumb_moving == ScrollBar.ThumbMoving.Backwards)
+					element = VisualStyleElement.ScrollBar.LeftTrackHorizontal.Pressed;
+				else
+					element = bar.Enabled ?
+						VisualStyleElement.ScrollBar.LeftTrackHorizontal.Normal :
+						VisualStyleElement.ScrollBar.LeftTrackHorizontal.Disabled;
+				renderer = new VisualStyleRenderer (element);
+				Rectangle left_track_rect = new Rectangle (
+					0,
+					0,
+					bar.ThumbPos.Left,
+					bar.ClientRectangle.Height);
+				if (clip.IntersectsWith (left_track_rect))
+					renderer.DrawBackground (dc, left_track_rect, clip);
+				#endregion
+				#region Background, right track
+				if (bar.thumb_moving == ScrollBar.ThumbMoving.Forward)
+					element = VisualStyleElement.ScrollBar.RightTrackHorizontal.Pressed;
+				else
+					element = bar.Enabled ?
+						VisualStyleElement.ScrollBar.RightTrackHorizontal.Normal :
+						VisualStyleElement.ScrollBar.RightTrackHorizontal.Disabled;
+				renderer = new VisualStyleRenderer (element);
+				Rectangle right_track_rect = new Rectangle (
+					bar.ThumbPos.Right,
+					0,
+					bar.ClientRectangle.Width - bar.ThumbPos.Right,
+					bar.ClientRectangle.Height);
+				if (clip.IntersectsWith (right_track_rect))
+					renderer.DrawBackground (dc, right_track_rect, clip);
+				#endregion
+				#region Buttons
+				if (clip.IntersectsWith (bar.FirstArrowArea)) {
+					if (!bar.Enabled)
+						element = VisualStyleElement.ScrollBar.ArrowButton.LeftDisabled;
+					else if (bar.firstbutton_state == ButtonState.Pushed)
+						element = VisualStyleElement.ScrollBar.ArrowButton.LeftPressed;
+					else if (bar.FirstButtonEntered)
+						element = VisualStyleElement.ScrollBar.ArrowButton.LeftHot;
+					else if (ScrollBarHasHoverArrowButtonStyleVisualStyles && bar.Entered)
+						element = VisualStyleElement.ScrollBar.ArrowButton.LeftHover;
+					else
+						element = VisualStyleElement.ScrollBar.ArrowButton.LeftNormal;
+					renderer = new VisualStyleRenderer (element);
+					renderer.DrawBackground (dc, bar.FirstArrowArea);
+				}
+				if (clip.IntersectsWith (bar.SecondArrowArea)) {
+					if (!bar.Enabled)
+						element = VisualStyleElement.ScrollBar.ArrowButton.RightDisabled;
+					else if (bar.secondbutton_state == ButtonState.Pushed)
+						element = VisualStyleElement.ScrollBar.ArrowButton.RightPressed;
+					else if (bar.SecondButtonEntered)
+						element = VisualStyleElement.ScrollBar.ArrowButton.RightHot;
+					else if (ScrollBarHasHoverArrowButtonStyleVisualStyles && bar.Entered)
+						element = VisualStyleElement.ScrollBar.ArrowButton.RightHover;
+					else
+						element = VisualStyleElement.ScrollBar.ArrowButton.RightNormal;
+					renderer = new VisualStyleRenderer (element);
+					renderer.DrawBackground (dc, bar.SecondArrowArea);
+				}
+				#endregion
+				#region Thumb and grip
+				if (!bar.Enabled)
+					element = VisualStyleElement.ScrollBar.RightTrackHorizontal.Disabled;
+				else if (bar.ThumbPressed)
+					element = VisualStyleElement.ScrollBar.ThumbButtonHorizontal.Pressed;
+				else if (bar.ThumbEntered)
+					element = VisualStyleElement.ScrollBar.ThumbButtonHorizontal.Hot;
+				else
+					element = VisualStyleElement.ScrollBar.ThumbButtonHorizontal.Normal;
+				renderer = new VisualStyleRenderer (element);
+				renderer.DrawBackground (dc, bar.ThumbPos, clip);
+
+				if (bar.Enabled && bar.ThumbPos.Height >= 20) {
+					element = VisualStyleElement.ScrollBar.GripperHorizontal.Normal;
+					if (VisualStyleRenderer.IsElementDefined (element)) {
+						renderer = new VisualStyleRenderer (element);
+						renderer.DrawBackground (dc, bar.ThumbPos, clip);
+					}
+				}
+				#endregion
+			}
+		}
+		public override bool ScrollBarHasHotElementStyles {
+			get {
+				if (!RenderClientAreas)
+					return base.ScrollBarHasHotElementStyles;
+				return ScrollBarAreElementsDefined;
+			}
+		}
+		public override bool ScrollBarHasPressedThumbStyle {
+			get {
+				if (!RenderClientAreas)
+					return base.ScrollBarHasPressedThumbStyle;
+				return ScrollBarAreElementsDefined;
+			}
+		}
+		const int WindowsVistaMajorVersion = 6;
+		static bool ScrollBarHasHoverArrowButtonStyleVisualStyles =
+			Environment.OSVersion.Version.Major >= WindowsVistaMajorVersion;
+		public override bool ScrollBarHasHoverArrowButtonStyle {
+			get {
+				if (RenderClientAreas &&
+					ScrollBarHasHoverArrowButtonStyleVisualStyles)
+					return ScrollBarAreElementsDefined;
+				return base.ScrollBarHasHoverArrowButtonStyle;
+			}
+		}
+		static bool ScrollBarAreElementsDefined {
+			get {
+				return
+					VisualStyleRenderer.IsElementDefined (VisualStyleElement.ScrollBar.ArrowButton.DownDisabled) &&
+					VisualStyleRenderer.IsElementDefined (VisualStyleElement.ScrollBar.LeftTrackHorizontal.Disabled) &&
+					VisualStyleRenderer.IsElementDefined (VisualStyleElement.ScrollBar.LowerTrackVertical.Disabled) &&
+					VisualStyleRenderer.IsElementDefined (VisualStyleElement.ScrollBar.RightTrackHorizontal.Disabled) &&
+					VisualStyleRenderer.IsElementDefined (VisualStyleElement.ScrollBar.ThumbButtonHorizontal.Disabled) &&
+					VisualStyleRenderer.IsElementDefined (VisualStyleElement.ScrollBar.ThumbButtonVertical.Disabled) &&
+					VisualStyleRenderer.IsElementDefined (VisualStyleElement.ScrollBar.UpperTrackVertical.Disabled);
+			}
+		}
+		#endregion
+		#region StatusBar
+		protected override void DrawStatusBarBackground(Graphics dc, Rectangle clip, StatusBar sb) {
+			if (!RenderClientAreas) {
+				base.DrawStatusBarBackground (dc, clip, sb);
+				return;
+			}
+			VisualStyleElement element = VisualStyleElement.Status.Bar.Normal;
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.DrawStatusBarBackground (dc, clip, sb);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (dc, sb.ClientRectangle, clip);
+		}
+		protected override void DrawStatusBarSizingGrip (Graphics dc, Rectangle clip, StatusBar sb, Rectangle area)
+		{
+			if (!RenderClientAreas) {
+				base.DrawStatusBarSizingGrip (dc, clip, sb, area);
+				return;
+			}
+			VisualStyleElement element = VisualStyleElement.Status.Gripper.Normal;
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.DrawStatusBarSizingGrip (dc, clip, sb, area);
+				return;
+			}
+			VisualStyleRenderer renderer = new VisualStyleRenderer (element);
+			Rectangle sizing_grip_rectangle = new Rectangle (Point.Empty, renderer.GetPartSize (dc, ThemeSizeType.True));
+			sizing_grip_rectangle.X = sb.Width - sizing_grip_rectangle.Width;
+			sizing_grip_rectangle.Y = sb.Height - sizing_grip_rectangle.Height;
+			renderer.DrawBackground (dc, sizing_grip_rectangle, clip);
+		}
+		protected override void DrawStatusBarPanelBackground (Graphics dc, Rectangle area, StatusBarPanel panel)
+		{
+			if (!RenderClientAreas) {
+				base.DrawStatusBarPanelBackground (dc, area, panel);
+				return;
+			}
+			VisualStyleElement element = VisualStyleElement.Status.Pane.Normal;
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.DrawStatusBarPanelBackground (dc, area, panel);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (dc, area);
+		}
+		#endregion
+		#region TextBoxBase
+		static bool TextBoxBaseShouldPaint (TextBoxBase textBoxBase)
+		{
+			return textBoxBase.BorderStyle == BorderStyle.Fixed3D;
+		}
+		static VisualStyleElement TextBoxBaseGetVisualStyleElement (TextBoxBase textBoxBase)
+		{
+			if (!textBoxBase.Enabled)
+				return VisualStyleElement.TextBox.TextEdit.Disabled;
+			if (textBoxBase.ReadOnly)
+				return VisualStyleElement.TextBox.TextEdit.ReadOnly;
+			if (textBoxBase.Entered)
+				return VisualStyleElement.TextBox.TextEdit.Hot;
+			if (textBoxBase.Focused)
+				return VisualStyleElement.TextBox.TextEdit.Focused;
+			return VisualStyleElement.TextBox.TextEdit.Normal;
+		}
+		public override void TextBoxBaseFillBackground (TextBoxBase textBoxBase, Graphics g, Rectangle clippingArea)
+		{
+			if (!RenderClientAreas ||
+				!TextBoxBaseShouldPaint (textBoxBase)) {
+				base.TextBoxBaseFillBackground (textBoxBase, g, clippingArea);
+				return;
+			}
+			VisualStyleElement element = TextBoxBaseGetVisualStyleElement (textBoxBase);
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.TextBoxBaseFillBackground (textBoxBase, g, clippingArea);
+				return;
+			}
+			Rectangle bounds = new Rectangle(Point.Empty, textBoxBase.Size);
+			bounds.X -= (bounds.Width - textBoxBase.ClientSize.Width) / 2;
+			bounds.Y -= (bounds.Height - textBoxBase.ClientSize.Height) / 2;
+			new VisualStyleRenderer (element).DrawBackground (g, bounds, clippingArea);
+		}
+		public override bool TextBoxBaseHandleWmNcPaint (TextBoxBase textBoxBase, ref Message m)
+		{
+			if (!RenderClientAreas ||
+				!TextBoxBaseShouldPaint (textBoxBase))
+				return base.TextBoxBaseHandleWmNcPaint (textBoxBase, ref m);
+			VisualStyleElement element = TextBoxBaseGetVisualStyleElement (textBoxBase);
+			if (!VisualStyleRenderer.IsElementDefined (element))
+				return base.TextBoxBaseHandleWmNcPaint (textBoxBase, ref m);
+			PaintEventArgs e = XplatUI.PaintEventStart (ref m, textBoxBase.Handle, false);
+			new VisualStyleRenderer (element).DrawBackgroundExcludingArea (
+				e.Graphics,
+				new Rectangle (Point.Empty, textBoxBase.Size),
+				new Rectangle (new Point ((textBoxBase.Width - textBoxBase.ClientSize.Width) / 2,
+					(textBoxBase.Height - textBoxBase.ClientSize.Height) / 2),
+					textBoxBase.ClientSize));
+			XplatUI.PaintEventEnd (ref m, textBoxBase.Handle, false);
+			return true;
+		}
+		public override bool TextBoxBaseShouldPaintBackground (TextBoxBase textBoxBase)
+		{
+			if (!RenderClientAreas ||
+				!TextBoxBaseShouldPaint (textBoxBase))
+				return base.TextBoxBaseShouldPaintBackground (textBoxBase);
+			VisualStyleElement element = TextBoxBaseGetVisualStyleElement (textBoxBase);
+			if (!VisualStyleRenderer.IsElementDefined (element))
+				return base.TextBoxBaseShouldPaintBackground (textBoxBase);
+			return new VisualStyleRenderer (element).IsBackgroundPartiallyTransparent ();
+		}
+		#endregion
+		/* FIXME: I SAID NO.
+		#region ToolBar
+		static bool ToolBarIsDisabled (ToolBarItem item)
+		{
+			return !item.Button.Enabled;
+		}
+		static bool ToolBarIsPressed (ToolBarItem item)
+		{
+			return item.Pressed;
+		}
+		static bool ToolBarIsChecked (ToolBarItem item)
+		{
+			return item.Button.Pushed;
+		}
+		static bool ToolBarIsHot (ToolBarItem item)
+		{
+			return item.Hilight;
+		}
+		#region Border
+		protected override void DrawToolBarButtonBorder (Graphics dc, ToolBarItem item, bool is_flat)
+		{
+			if (!RenderClientAreas) {
+				base.DrawToolBarButtonBorder (dc, item, is_flat);
+				return;
+			}
+			if (item.Button.Style == ToolBarButtonStyle.Separator)
+				return;
+			VisualStyleElement element;
+			if (item.Button.Style == ToolBarButtonStyle.DropDownButton)
+				element = ToolBarGetDropDownButtonVisualStyleElement (item);
+			else
+				element = ToolBarGetButtonVisualStyleElement (item);
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.DrawToolBarButtonBorder (dc, item, is_flat);
+				return;
+			}
+			Rectangle rectangle = item.Rectangle;
+			if (item.Button.Style == ToolBarButtonStyle.DropDownButton && item.Button.Parent.DropDownArrows)
+				rectangle.Width -= ToolBarDropDownWidth;
+			new VisualStyleRenderer (element).DrawBackground (dc, rectangle);
+		}
+		private static VisualStyleElement ToolBarGetDropDownButtonVisualStyleElement (ToolBarItem item)
+		{
+			if (item.Button.Parent.DropDownArrows) {
+				if (ToolBarIsDisabled (item))
+					return VisualStyleElement.ToolBar.SplitButton.Disabled;
+				if (ToolBarIsPressed (item))
+					return VisualStyleElement.ToolBar.SplitButton.Pressed;
+				if (ToolBarIsChecked (item))
+					if (ToolBarIsHot (item))
+						return VisualStyleElement.ToolBar.SplitButton.HotChecked;
+					else
+						return VisualStyleElement.ToolBar.SplitButton.Checked;
+				if (ToolBarIsHot (item))
+					return VisualStyleElement.ToolBar.SplitButton.Hot;
+				return VisualStyleElement.ToolBar.SplitButton.Normal;
+			} else {
+				if (ToolBarIsDisabled (item))
+					return VisualStyleElement.ToolBar.DropDownButton.Disabled;
+				if (ToolBarIsPressed (item))
+					return VisualStyleElement.ToolBar.DropDownButton.Pressed;
+				if (ToolBarIsChecked (item))
+					if (ToolBarIsHot (item))
+						return VisualStyleElement.ToolBar.DropDownButton.HotChecked;
+					else
+						return VisualStyleElement.ToolBar.DropDownButton.Checked;
+				if (ToolBarIsHot (item))
+					return VisualStyleElement.ToolBar.DropDownButton.Hot;
+				return VisualStyleElement.ToolBar.DropDownButton.Normal;
+			}
+		}
+		private static VisualStyleElement ToolBarGetButtonVisualStyleElement (ToolBarItem item)
+		{
+			if (ToolBarIsDisabled (item))
+				return VisualStyleElement.ToolBar.Button.Disabled;
+			if (ToolBarIsPressed (item))
+				return VisualStyleElement.ToolBar.Button.Pressed;
+			if (ToolBarIsChecked (item))
+				if (ToolBarIsHot (item))
+					return VisualStyleElement.ToolBar.Button.HotChecked;
+				else
+					return VisualStyleElement.ToolBar.Button.Checked;
+			if (ToolBarIsHot (item))
+				return VisualStyleElement.ToolBar.Button.Hot;
+			return VisualStyleElement.ToolBar.Button.Normal;
+		}
+		#endregion
+		#region Separator
+		protected override void DrawToolBarSeparator (Graphics dc, ToolBarItem item)
+		{
+			if (!RenderClientAreas) {
+				base.DrawToolBarSeparator (dc, item);
+				return;
+			}
+			VisualStyleElement element = ToolBarGetSeparatorVisualStyleElement (item);
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.DrawToolBarSeparator (dc, item);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (dc, item.Rectangle);
+		}
+		static VisualStyleElement ToolBarGetSeparatorVisualStyleElement (ToolBarItem toolBarItem)
+		{
+			return toolBarItem.Button.Parent.Vertical ?
+				VisualStyleElement.ToolBar.SeparatorVertical.Normal :
+				VisualStyleElement.ToolBar.SeparatorHorizontal.Normal;
+		}
+		#endregion
+		#region Toggle button background
+		protected override void DrawToolBarToggleButtonBackground (Graphics dc, ToolBarItem item)
+		{
+			if (!RenderClientAreas ||
+				!VisualStyleRenderer.IsElementDefined (ToolBarGetButtonVisualStyleElement (item)))
+				base.DrawToolBarToggleButtonBackground (dc, item);
+		}
+		#endregion
+		#region Drop down arrow
+		protected override void DrawToolBarDropDownArrow (Graphics dc, ToolBarItem item, bool is_flat)
+		{
+			if (!RenderClientAreas) {
+				base.DrawToolBarDropDownArrow (dc, item, is_flat);
+				return;
+			}
+			VisualStyleElement element = ToolBarGetDropDownArrowVisualStyleElement (item);
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.DrawToolBarDropDownArrow (dc, item, is_flat);
+				return;
+			}
+			Rectangle rect = item.Rectangle;
+			rect.X = item.Rectangle.Right - ToolBarDropDownWidth;
+			rect.Width = ToolBarDropDownWidth;
+			new VisualStyleRenderer (element).DrawBackground (dc, rect);
+		}
+		private static VisualStyleElement ToolBarGetDropDownArrowVisualStyleElement (ToolBarItem item)
+		{
+			if (ToolBarIsDisabled (item))
+				return VisualStyleElement.ToolBar.SplitButtonDropDown.Disabled;
+			if (ToolBarIsPressed (item))
+				return VisualStyleElement.ToolBar.SplitButtonDropDown.Pressed;
+			if (ToolBarIsChecked (item))
+				if (ToolBarIsHot (item))
+					return VisualStyleElement.ToolBar.SplitButtonDropDown.HotChecked;
+				else
+					return VisualStyleElement.ToolBar.SplitButtonDropDown.Checked;
+			if (ToolBarIsHot (item))
+				return VisualStyleElement.ToolBar.SplitButtonDropDown.Hot;
+			return VisualStyleElement.ToolBar.SplitButtonDropDown.Normal;
+		}
+		#endregion
+		public override bool ToolBarHasHotElementStyles (ToolBar toolBar)
+		{
+			if (!RenderClientAreas)
+				return base.ToolBarHasHotElementStyles (toolBar);
+			return true;
+		}
+		public override bool ToolBarHasHotCheckedElementStyles {
+			get {
+				if (!RenderClientAreas)
+					return base.ToolBarHasHotCheckedElementStyles;
+				return true;
+			}
+		}
+		#endregion*/
+		#region ToolTip
+		protected override void ToolTipDrawBackground (Graphics dc, Rectangle clip_rectangle, ToolTip.ToolTipWindow control)
+		{
+			if (!RenderClientAreas) {
+				base.ToolTipDrawBackground (dc, clip_rectangle, control);
+				return;
+			}
+			VisualStyleElement element = VisualStyleElement.ToolTip.Standard.Normal;
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.ToolTipDrawBackground (dc, clip_rectangle, control);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (dc, control.ClientRectangle);
+		}
+		public override bool ToolTipTransparentBackground {
+			get {
+				if (!RenderClientAreas)
+					return base.ToolTipTransparentBackground;
+				VisualStyleElement element = VisualStyleElement.ToolTip.Standard.Normal;
+				if (!VisualStyleRenderer.IsElementDefined (element))
+					return base.ToolTipTransparentBackground;
+				return new VisualStyleRenderer (element).IsBackgroundPartiallyTransparent ();
+			}
+		}
+		#endregion
+		#region TrackBar
+		protected override Size TrackBarGetThumbSize (TrackBar trackBar)
+		{
+			if (!RenderClientAreas)
+				return base.TrackBarGetThumbSize (trackBar);
+			VisualStyleElement element = TrackBarGetThumbVisualStyleElement (trackBar);
+			if (!VisualStyleRenderer.IsElementDefined (element))
+				return base.TrackBarGetThumbSize (trackBar);
+			Graphics g = trackBar.CreateGraphics ();
+			Size result = new VisualStyleRenderer (element).GetPartSize (g, ThemeSizeType.True);
+			g.Dispose ();
+			return trackBar.Orientation == Orientation.Horizontal ? result : TrackBarRotateVerticalThumbSize (result);
+		}
+		static VisualStyleElement TrackBarGetThumbVisualStyleElement (TrackBar trackBar)
+		{
+			if (trackBar.Orientation == Orientation.Horizontal)
+				switch (trackBar.TickStyle) {
+				case TickStyle.BottomRight:
+				case TickStyle.None:
+					return TrackBarGetHorizontalThumbBottomVisualStyleElement (trackBar);
+				case TickStyle.TopLeft:
+					return TrackBarGetHorizontalThumbTopVisualStyleElement (trackBar);
+				default:
+					return TrackBarGetHorizontalThumbVisualStyleElement (trackBar);
+				}
+			else
+				switch (trackBar.TickStyle) {
+				case TickStyle.BottomRight:
+				case TickStyle.None:
+					return TrackBarGetVerticalThumbRightVisualStyleElement (trackBar);
+				case TickStyle.TopLeft:
+					return TrackBarGetVerticalThumbLeftVisualStyleElement (trackBar);
+				default:
+					return TrackBarGetVerticalThumbVisualStyleElement (trackBar);
+				}
+		}
+		static Size TrackBarRotateVerticalThumbSize (Size value)
+		{
+			int temporary = value.Width;
+			value.Width = value.Height;
+			value.Height = temporary;
+			return value;
+		}
+		#region Track
+		protected override void TrackBarDrawHorizontalTrack (Graphics dc, Rectangle thumb_area, Point channel_startpoint, Rectangle clippingArea)
+		{
+			if (!RenderClientAreas) {
+				base.TrackBarDrawHorizontalTrack (dc, thumb_area, channel_startpoint, clippingArea);
+				return;
+			}
+			VisualStyleElement element = VisualStyleElement.TrackBar.Track.Normal;
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.TrackBarDrawHorizontalTrack (dc, thumb_area, channel_startpoint, clippingArea);
+				return;
+			}
+			VisualStyleRenderer renderer = new VisualStyleRenderer (element);
+			renderer.DrawBackground (dc, new Rectangle (channel_startpoint, new Size (thumb_area.Width, renderer.GetPartSize (dc, ThemeSizeType.True).Height)), clippingArea);
+		}
+		protected override void TrackBarDrawVerticalTrack (Graphics dc, Rectangle thumb_area, Point channel_startpoint, Rectangle clippingArea)
+		{
+			if (!RenderClientAreas) {
+				base.TrackBarDrawVerticalTrack (dc, thumb_area, channel_startpoint, clippingArea);
+				return;
+			}
+			VisualStyleElement element = VisualStyleElement.TrackBar.TrackVertical.Normal;
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.TrackBarDrawVerticalTrack (dc, thumb_area, channel_startpoint, clippingArea);
+				return;
+			}
+			VisualStyleRenderer renderer = new VisualStyleRenderer (element);
+			renderer.DrawBackground (dc, new Rectangle (channel_startpoint, new Size (renderer.GetPartSize (dc, ThemeSizeType.True).Width, thumb_area.Height)), clippingArea);
+		}
+		#endregion
+		#region Thumb
+		static bool TrackBarIsDisabled (TrackBar trackBar)
+		{
+			return !trackBar.Enabled;
+		}
+		static bool TrackBarIsHot (TrackBar trackBar)
+		{
+			return trackBar.ThumbEntered;
+		}
+		static bool TrackBarIsPressed (TrackBar trackBar)
+		{
+			return trackBar.thumb_pressed;
+		}
+		static bool TrackBarIsFocused (TrackBar trackBar)
+		{
+			return trackBar.Focused;
+		}
+		#region Horizontal
+		protected override void TrackBarDrawHorizontalThumbBottom (Graphics dc, Rectangle thumb_pos, Brush br_thumb, Rectangle clippingArea, TrackBar trackBar)
+		{
+			if (!RenderClientAreas) {
+				base.TrackBarDrawHorizontalThumbBottom (dc, thumb_pos, br_thumb, clippingArea, trackBar);
+				return;
+			}
+			VisualStyleElement element = TrackBarGetHorizontalThumbBottomVisualStyleElement (trackBar);
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.TrackBarDrawHorizontalThumbBottom (dc, thumb_pos, br_thumb, clippingArea, trackBar);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (dc, thumb_pos, clippingArea);
+		}
+		static VisualStyleElement TrackBarGetHorizontalThumbBottomVisualStyleElement (TrackBar trackBar)
+		{
+			if (TrackBarIsDisabled (trackBar))
+				return VisualStyleElement.TrackBar.ThumbBottom.Disabled;
+			else if (TrackBarIsPressed (trackBar))
+				return VisualStyleElement.TrackBar.ThumbBottom.Pressed;
+			else if (TrackBarIsHot (trackBar))
+				return VisualStyleElement.TrackBar.ThumbBottom.Hot;
+			else if (TrackBarIsFocused (trackBar))
+				return VisualStyleElement.TrackBar.ThumbBottom.Focused;
+			return VisualStyleElement.TrackBar.ThumbBottom.Normal;
+		}
+		protected override void TrackBarDrawHorizontalThumbTop (Graphics dc, Rectangle thumb_pos, Brush br_thumb, Rectangle clippingArea, TrackBar trackBar)
+		{
+			if (!RenderClientAreas) {
+				base.TrackBarDrawHorizontalThumbTop (dc, thumb_pos, br_thumb, clippingArea, trackBar);
+				return;
+			}
+			VisualStyleElement element = TrackBarGetHorizontalThumbTopVisualStyleElement (trackBar);
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.TrackBarDrawHorizontalThumbTop (dc, thumb_pos, br_thumb, clippingArea, trackBar);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (dc, thumb_pos, clippingArea);
+		}
+		static VisualStyleElement TrackBarGetHorizontalThumbTopVisualStyleElement (TrackBar trackBar)
+		{
+			if (TrackBarIsDisabled (trackBar))
+				return VisualStyleElement.TrackBar.ThumbTop.Disabled;
+			else if (TrackBarIsPressed (trackBar))
+				return VisualStyleElement.TrackBar.ThumbTop.Pressed;
+			else if (TrackBarIsHot (trackBar))
+				return VisualStyleElement.TrackBar.ThumbTop.Hot;
+			else if (TrackBarIsFocused (trackBar))
+				return VisualStyleElement.TrackBar.ThumbTop.Focused;
+			return VisualStyleElement.TrackBar.ThumbTop.Normal;
+		}
+		protected override void TrackBarDrawHorizontalThumb (Graphics dc, Rectangle thumb_pos, Brush br_thumb, Rectangle clippingArea, TrackBar trackBar)
+		{
+			if (!RenderClientAreas) {
+				base.TrackBarDrawHorizontalThumb (dc, thumb_pos, br_thumb, clippingArea, trackBar);
+				return;
+			}
+			VisualStyleElement element = TrackBarGetHorizontalThumbVisualStyleElement (trackBar);
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.TrackBarDrawHorizontalThumb (dc, thumb_pos, br_thumb, clippingArea, trackBar);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (dc, thumb_pos, clippingArea);
+		}
+		static VisualStyleElement TrackBarGetHorizontalThumbVisualStyleElement (TrackBar trackBar)
+		{
+			if (TrackBarIsDisabled (trackBar))
+				return VisualStyleElement.TrackBar.Thumb.Disabled;
+			else if (TrackBarIsPressed (trackBar))
+				return VisualStyleElement.TrackBar.Thumb.Pressed;
+			else if (TrackBarIsHot (trackBar))
+				return VisualStyleElement.TrackBar.Thumb.Hot;
+			else if (TrackBarIsFocused (trackBar))
+				return VisualStyleElement.TrackBar.Thumb.Focused;
+			return VisualStyleElement.TrackBar.Thumb.Normal;
+		}
+		#endregion
+		#region Vertical
+		static Rectangle TrackBarRotateVerticalThumbSize (Rectangle value)
+		{
+			int temporary = value.Width;
+			value.Width = value.Height;
+			value.Height = temporary;
+			return value;
+		}
+		protected override void TrackBarDrawVerticalThumbRight (Graphics dc, Rectangle thumb_pos, Brush br_thumb, Rectangle clippingArea, TrackBar trackBar)
+		{
+			if (!RenderClientAreas) {
+				base.TrackBarDrawVerticalThumbRight (dc, thumb_pos, br_thumb, clippingArea, trackBar);
+				return;
+			}
+			VisualStyleElement element = TrackBarGetVerticalThumbRightVisualStyleElement (trackBar);
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.TrackBarDrawVerticalThumbRight (dc, thumb_pos, br_thumb, clippingArea, trackBar);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (dc, TrackBarRotateVerticalThumbSize (thumb_pos), clippingArea);
+		}
+		static VisualStyleElement TrackBarGetVerticalThumbRightVisualStyleElement (TrackBar trackBar)
+		{
+			if (TrackBarIsDisabled (trackBar))
+				return VisualStyleElement.TrackBar.ThumbRight.Disabled;
+			else if (TrackBarIsPressed (trackBar))
+				return VisualStyleElement.TrackBar.ThumbRight.Pressed;
+			else if (TrackBarIsHot (trackBar))
+				return VisualStyleElement.TrackBar.ThumbRight.Hot;
+			else if (TrackBarIsFocused (trackBar))
+				return VisualStyleElement.TrackBar.ThumbRight.Focused;
+			return VisualStyleElement.TrackBar.ThumbRight.Normal;
+		}
+		protected override void TrackBarDrawVerticalThumbLeft (Graphics dc, Rectangle thumb_pos, Brush br_thumb, Rectangle clippingArea, TrackBar trackBar)
+		{
+			if (!RenderClientAreas) {
+				base.TrackBarDrawVerticalThumbLeft (dc, thumb_pos, br_thumb, clippingArea, trackBar);
+				return;
+			}
+			VisualStyleElement element = TrackBarGetVerticalThumbLeftVisualStyleElement (trackBar);
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.TrackBarDrawVerticalThumbLeft (dc, thumb_pos, br_thumb, clippingArea, trackBar);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (dc, TrackBarRotateVerticalThumbSize (thumb_pos), clippingArea);
+		}
+		static VisualStyleElement TrackBarGetVerticalThumbLeftVisualStyleElement (TrackBar trackBar)
+		{
+			if (TrackBarIsDisabled (trackBar))
+				return VisualStyleElement.TrackBar.ThumbLeft.Disabled;
+			else if (TrackBarIsPressed (trackBar))
+				return VisualStyleElement.TrackBar.ThumbLeft.Pressed;
+			else if (TrackBarIsHot (trackBar))
+				return VisualStyleElement.TrackBar.ThumbLeft.Hot;
+			else if (TrackBarIsFocused (trackBar))
+				return VisualStyleElement.TrackBar.ThumbLeft.Focused;
+			return VisualStyleElement.TrackBar.ThumbLeft.Normal;
+		}
+		protected override void TrackBarDrawVerticalThumb (Graphics dc, Rectangle thumb_pos, Brush br_thumb, Rectangle clippingArea, TrackBar trackBar)
+		{
+			if (!RenderClientAreas) {
+				base.TrackBarDrawVerticalThumb (dc, thumb_pos, br_thumb, clippingArea, trackBar);
+				return;
+			}
+			VisualStyleElement element = TrackBarGetVerticalThumbVisualStyleElement (trackBar);
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.TrackBarDrawVerticalThumb (dc, thumb_pos, br_thumb, clippingArea, trackBar);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (dc, TrackBarRotateVerticalThumbSize (thumb_pos), clippingArea);
+		}
+		static VisualStyleElement TrackBarGetVerticalThumbVisualStyleElement (TrackBar trackBar)
+		{
+			if (TrackBarIsDisabled (trackBar))
+				return VisualStyleElement.TrackBar.ThumbVertical.Disabled;
+			else if (TrackBarIsPressed (trackBar))
+				return VisualStyleElement.TrackBar.ThumbVertical.Pressed;
+			else if (TrackBarIsHot (trackBar))
+				return VisualStyleElement.TrackBar.ThumbVertical.Hot;
+			else if (TrackBarIsFocused (trackBar))
+				return VisualStyleElement.TrackBar.ThumbVertical.Focused;
+			return VisualStyleElement.TrackBar.ThumbVertical.Normal;
+		}
+		#endregion
+		#endregion
+		#region Ticks
+		const EdgeStyle TrackBarTickEdgeStyle = EdgeStyle.Bump;
+		const EdgeEffects TrackBarTickEdgeEffects = EdgeEffects.None;
+		#region Horizontal
+		protected override ITrackBarTickPainter TrackBarGetHorizontalTickPainter (Graphics g)
+		{
+			if (!RenderClientAreas ||
+				!VisualStyleRenderer.IsElementDefined (VisualStyleElement.TrackBar.Ticks.Normal))
+				return base.TrackBarGetHorizontalTickPainter (g);
+			return new TrackBarHorizontalTickPainter (g);
+		}
+		class TrackBarHorizontalTickPainter : ITrackBarTickPainter
+		{
+			readonly Graphics g;
+			readonly VisualStyleRenderer renderer;
+			public TrackBarHorizontalTickPainter (Graphics g)
+			{
+				this.g = g;
+				renderer = new VisualStyleRenderer (VisualStyleElement.TrackBar.Ticks.Normal);
+			}
+			public void Paint (float x1, float y1, float x2, float y2)
+			{
+				renderer.DrawEdge (g, new Rectangle (
+					(int)Math.Round (x1),
+					(int)Math.Round (y1),
+					1,
+					(int)Math.Round (y2 - y1) + 1), Edges.Left, TrackBarTickEdgeStyle, TrackBarTickEdgeEffects);
+			}
+		}
+		#endregion
+		#region Vertical
+		protected override ITrackBarTickPainter TrackBarGetVerticalTickPainter (Graphics g)
+		{
+			if (!RenderClientAreas ||
+				!VisualStyleRenderer.IsElementDefined (VisualStyleElement.TrackBar.TicksVertical.Normal))
+				return base.TrackBarGetVerticalTickPainter (g);
+			return new TrackBarVerticalTickPainter (g);
+		}
+		class TrackBarVerticalTickPainter : ITrackBarTickPainter
+		{
+			readonly Graphics g;
+			readonly VisualStyleRenderer renderer;
+			public TrackBarVerticalTickPainter (Graphics g)
+			{
+				this.g = g;
+				renderer = new VisualStyleRenderer (VisualStyleElement.TrackBar.TicksVertical.Normal);
+			}
+			public void Paint (float x1, float y1, float x2, float y2)
+			{
+				renderer.DrawEdge (g, new Rectangle (
+					(int)Math.Round (x1),
+					(int)Math.Round (y1),
+					(int)Math.Round (x2 - x1) + 1,
+					1), Edges.Top, TrackBarTickEdgeStyle, TrackBarTickEdgeEffects);
+			}
+		}
+		#endregion
+		#endregion
+		public override bool TrackBarHasHotThumbStyle {
+			get {
+				if (!RenderClientAreas)
+					return base.TrackBarHasHotThumbStyle;
+				return true;
+			}
+		}
+		#endregion
+		#region TreeView
+		[MonoInternalNote ("Use the sizing information provided by the VisualStyles API.")]
+		public override void TreeViewDrawNodePlusMinus (TreeView treeView, TreeNode node, Graphics dc, int x, int middle)
+		{
+			if (!RenderClientAreas) {
+				base.TreeViewDrawNodePlusMinus (treeView, node, dc, x, middle);
+				return;
+			}
+			VisualStyleElement element = node.IsExpanded ?
+				VisualStyleElement.TreeView.Glyph.Opened : 
+				VisualStyleElement.TreeView.Glyph.Closed;
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.TreeViewDrawNodePlusMinus (treeView, node, dc, x, middle);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (dc, new Rectangle (x, middle - 4, 9, 9));
+		}
+		#endregion
+		#region UpDownBase
+		public override void UpDownBaseDrawButton (Graphics g, Rectangle bounds, bool top, PushButtonState state)
+		{
+			if (!RenderClientAreas) {
+				base.UpDownBaseDrawButton (g, bounds, top, state);
+				return;
+			}
+			VisualStyleElement element;
+			if (top)
+				switch (state) {
+				case PushButtonState.Disabled:
+					element = VisualStyleElement.Spin.Up.Disabled;
+					break;
+				case PushButtonState.Pressed:
+					element = VisualStyleElement.Spin.Up.Pressed;
+					break;
+				case PushButtonState.Hot:
+					element = VisualStyleElement.Spin.Up.Hot;
+					break;
+				default:
+					element = VisualStyleElement.Spin.Up.Normal;
+					break;
+				}
+			else
+				switch (state) {
+				case PushButtonState.Disabled:
+					element = VisualStyleElement.Spin.Down.Disabled;
+					break;
+				case PushButtonState.Pressed:
+					element = VisualStyleElement.Spin.Down.Pressed;
+					break;
+				case PushButtonState.Hot:
+					element = VisualStyleElement.Spin.Down.Hot;
+					break;
+				default:
+					element = VisualStyleElement.Spin.Down.Normal;
+					break;
+				}
+			if (!VisualStyleRenderer.IsElementDefined (element)) {
+				base.UpDownBaseDrawButton (g, bounds, top, state);
+				return;
+			}
+			new VisualStyleRenderer (element).DrawBackground (g, bounds);
+		}
+		public override bool UpDownBaseHasHotButtonStyle {
+			get {
+				if (!RenderClientAreas)
+					return base.UpDownBaseHasHotButtonStyle;
+				return true;
+			}
+		}
+		#endregion
+		#endregion
+
+		static bool AreEqual (VisualStyleElement value1, VisualStyleElement value2)
+		{
+			return
+				value1.ClassName == value1.ClassName &&
+				value1.Part == value2.Part &&
+				value1.State == value2.State;
+		}
+
+		#region Measurement device context
+		static Widget control;
+		static IDeviceContext GetMeasurementDeviceContext ()
+		{
+			if (control == null)
+				control = new Widget ();
+			return control.CreateGraphics ();
+		}
+		static void ReleaseMeasurementDeviceContext (IDeviceContext dc)
+		{
+			dc.Dispose ();
+		}
+		#endregion
+	}
+}