private void RenderItemInternal(ToolStripItemRenderEventArgs e)
{
ToolStripItem item = e.Item;
Graphics dc = e.Graphics;
ToolBarState toolBarState = GetToolBarState(item);
VisualStyleElement normal = VisualStyleElement.ToolBar.Button.Normal;
if (ToolStripManager.VisualStylesEnabled && System.Windows.Forms.VisualStyles.VisualStyleRenderer.IsElementDefined(normal))
{
System.Windows.Forms.VisualStyles.VisualStyleRenderer visualStyleRenderer = VisualStyleRenderer;
visualStyleRenderer.SetParameters(normal.ClassName, normal.Part, (int)toolBarState);
visualStyleRenderer.DrawBackground(dc, new Rectangle(Point.Empty, item.Size));
}
else
{
this.RenderSmall3DBorderInternal(dc, new Rectangle(Point.Empty, item.Size), toolBarState, item.RightToLeft == RightToLeft.Yes);
}
Rectangle contentRectangle = item.ContentRectangle;
if (item.BackgroundImage != null)
{
ControlPaint.DrawBackgroundImage(dc, item.BackgroundImage, item.BackColor, item.BackgroundImageLayout, contentRectangle, contentRectangle);
}
else
{
ToolStrip currentParent = item.GetCurrentParent();
if (((currentParent != null) && (toolBarState != ToolBarState.Checked)) && (item.BackColor != currentParent.BackColor))
{
FillBackground(dc, contentRectangle, item.BackColor);
}
}
}
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
Graphics dc = e.Graphics;
Rectangle bounds = new Rectangle(Point.Empty, e.GripBounds.Size);
bool flag = e.GripDisplayStyle == ToolStripGripDisplayStyle.Vertical;
if (ToolStripManager.VisualStylesEnabled && System.Windows.Forms.VisualStyles.VisualStyleRenderer.IsElementDefined(VisualStyleElement.Rebar.Gripper.Normal))
{
System.Windows.Forms.VisualStyles.VisualStyleRenderer visualStyleRenderer = VisualStyleRenderer;
if (flag)
{
visualStyleRenderer.SetParameters(VisualStyleElement.Rebar.Gripper.Normal);
bounds.Height = ((bounds.Height - 2) / 4) * 4;
bounds.Y = Math.Max(0, ((e.GripBounds.Height - bounds.Height) - 2) / 2);
}
else
{
visualStyleRenderer.SetParameters(VisualStyleElement.Rebar.GripperVertical.Normal);
}
visualStyleRenderer.DrawBackground(dc, bounds);
}
else
{
Color backColor = e.ToolStrip.BackColor;
FillBackground(dc, bounds, backColor);
if (flag)
{
if (bounds.Height >= 4)
{
bounds.Inflate(0, -2);
}
bounds.Width = 3;
}
else
{
if (bounds.Width >= 4)
{
bounds.Inflate(-2, 0);
}
bounds.Height = 3;
}
this.RenderSmall3DBorderInternal(dc, bounds, ToolBarState.Hot, e.ToolStrip.RightToLeft == RightToLeft.Yes);
}
}
private void RenderSeparatorInternal(Graphics g, ToolStripItem item, Rectangle bounds, bool vertical)
{
VisualStyleElement element = vertical ? VisualStyleElement.ToolBar.SeparatorHorizontal.Normal : VisualStyleElement.ToolBar.SeparatorVertical.Normal;
if (ToolStripManager.VisualStylesEnabled && System.Windows.Forms.VisualStyles.VisualStyleRenderer.IsElementDefined(element))
{
System.Windows.Forms.VisualStyles.VisualStyleRenderer visualStyleRenderer = VisualStyleRenderer;
visualStyleRenderer.SetParameters(element.ClassName, element.Part, GetItemState(item));
visualStyleRenderer.DrawBackground(g, bounds);
}
else
{
Color foreColor = item.ForeColor;
Color backColor = item.BackColor;
Pen controlDark = SystemPens.ControlDark;
bool pen = GetPen(foreColor, ref controlDark);
try
{
if (vertical)
{
if (bounds.Height >= 4)
{
bounds.Inflate(0, -2);
}
bool flag2 = item.RightToLeft == RightToLeft.Yes;
Pen pen2 = flag2 ? SystemPens.ButtonHighlight : controlDark;
Pen pen3 = flag2 ? controlDark : SystemPens.ButtonHighlight;
int num = bounds.Width / 2;
g.DrawLine(pen2, num, bounds.Top, num, bounds.Bottom);
num++;
g.DrawLine(pen3, num, bounds.Top, num, bounds.Bottom);
}
else
{
if (bounds.Width >= 4)
{
bounds.Inflate(-2, 0);
}
int num2 = bounds.Height / 2;
g.DrawLine(controlDark, bounds.Left, num2, bounds.Right, num2);
num2++;
g.DrawLine(SystemPens.ButtonHighlight, bounds.Left, num2, bounds.Right, num2);
}
}
finally
{
if (pen && (controlDark != null))
{
controlDark.Dispose();
}
}
}
}
private static void RenderStatusStripBackground(ToolStripRenderEventArgs e)
{
if (Application.RenderWithVisualStyles)
{
System.Windows.Forms.VisualStyles.VisualStyleRenderer visualStyleRenderer = VisualStyleRenderer;
visualStyleRenderer.SetParameters(VisualStyleElement.Status.Bar.Normal);
visualStyleRenderer.DrawBackground(e.Graphics, new Rectangle(0, 0, e.ToolStrip.Width - 1, e.ToolStrip.Height - 1));
}
else if (!SystemInformation.InLockedTerminalSession())
{
e.Graphics.Clear(e.BackColor);
}
}
protected override void OnRenderOverflowButtonBackground(ToolStripItemRenderEventArgs e)
{
ToolStripItem item = e.Item;
Graphics dc = e.Graphics;
if (ToolStripManager.VisualStylesEnabled && System.Windows.Forms.VisualStyles.VisualStyleRenderer.IsElementDefined(VisualStyleElement.Rebar.Chevron.Normal))
{
VisualStyleElement normal = VisualStyleElement.Rebar.Chevron.Normal;
System.Windows.Forms.VisualStyles.VisualStyleRenderer visualStyleRenderer = VisualStyleRenderer;
visualStyleRenderer.SetParameters(normal.ClassName, normal.Part, GetItemState(item));
visualStyleRenderer.DrawBackground(dc, new Rectangle(Point.Empty, item.Size));
}
else
{
this.RenderItemInternal(e);
Color arrowColor = item.Enabled ? SystemColors.ControlText : SystemColors.ControlDark;
base.DrawArrow(new ToolStripArrowRenderEventArgs(dc, item, new Rectangle(Point.Empty, item.Size), arrowColor, ArrowDirection.Down));
}
}
protected override void OnRenderToolStripBackground(ToolStripRenderEventArgs e)
{
ToolStrip toolStrip = e.ToolStrip;
Graphics g = e.Graphics;
Rectangle affectedBounds = e.AffectedBounds;
if (base.ShouldPaintBackground(toolStrip))
{
if (toolStrip is StatusStrip)
{
RenderStatusStripBackground(e);
}
else if (DisplayInformation.HighContrast)
{
FillBackground(g, affectedBounds, SystemColors.ButtonFace);
}
else if (DisplayInformation.LowResolution)
{
FillBackground(g, affectedBounds, (toolStrip is ToolStripDropDown) ? SystemColors.ControlLight : e.BackColor);
}
else if (toolStrip.IsDropDown)
{
FillBackground(g, affectedBounds, !ToolStripManager.VisualStylesEnabled ? e.BackColor : SystemColors.Menu);
}
else if (toolStrip is MenuStrip)
{
FillBackground(g, affectedBounds, !ToolStripManager.VisualStylesEnabled ? e.BackColor : SystemColors.MenuBar);
}
else if (ToolStripManager.VisualStylesEnabled && System.Windows.Forms.VisualStyles.VisualStyleRenderer.IsElementDefined(VisualStyleElement.Rebar.Band.Normal))
{
System.Windows.Forms.VisualStyles.VisualStyleRenderer visualStyleRenderer = VisualStyleRenderer;
visualStyleRenderer.SetParameters(VisualStyleElement.ToolBar.Bar.Normal);
visualStyleRenderer.DrawBackground(g, affectedBounds);
}
else
{
FillBackground(g, affectedBounds, !ToolStripManager.VisualStylesEnabled ? e.BackColor : SystemColors.MenuBar);
}
}
}
protected override void WndProc(ref Message m)
{
//if native updown is destroyed we need release our hook
if (m.Msg == NativeMethods.WM_DESTROY || m.Msg == NativeMethods.WM_NCDESTROY)
this.ReleaseHandle();
else if (m.Msg == NativeMethods.WM_WINDOWPOSCHANGING)
{
//When a scroller position is changed we should remember that new position.
NativeMethods.WINDOWPOS wp = (NativeMethods.WINDOWPOS)m.GetLParam(typeof(NativeMethods.WINDOWPOS));
this.x = wp.x;
}
else if (m.Msg == NativeMethods.WM_MOUSEMOVE && parentControl.lastHotIndex > 0 &&
parentControl.lastHotIndex != parentControl.SelectedIndex)
{
//redrawing a former hot tab as normal one
using (Graphics context = Graphics.FromHwnd(parentControl.Handle))
{
VisualStyleRenderer rend = new VisualStyleRenderer(VisualStyleElement.Tab.TabItem.Normal);
parentControl.DrawTabItem(context, parentControl.lastHotIndex, parentControl.GetTabRect(parentControl.lastHotIndex), rend);
if (parentControl.lastHotIndex - parentControl.SelectedIndex == 1)
{
Rectangle selRect = parentControl.GetTabRect(parentControl.SelectedIndex);
selRect.Inflate(2, 2);
rend.SetParameters(rend.Class, rend.Part, (int)TabItemState.Selected);
parentControl.DrawTabItem(context, parentControl.SelectedIndex, selRect, rend);
}
}
}
else if (m.Msg == NativeMethods.WM_LBUTTONDOWN)
{
Rectangle invalidRect = parentControl.GetTabRect(parentControl.SelectedIndex);
invalidRect.X = 0; invalidRect.Width = 2;
invalidRect.Inflate(0, 2);
parentControl.Invalidate(invalidRect);
}
base.WndProc(ref m);
}
private void SetLayout()
{
if (isMin6 && Application.RenderWithVisualStyles)
{
VisualStyleRenderer theme;
using (Graphics g = this.CreateGraphics())
{
// Back button
theme = new VisualStyleRenderer(VisualStyleElementEx.Navigation.BackButton.Normal);
Size bbSize = theme.GetPartSize(g, ThemeSizeType.Draw);
// Title
theme.SetParameters(VisualStyleElementEx.AeroWizard.TitleBar.Active);
titleBar.Height = Math.Max(theme.GetMargins2(g, MarginProperty.ContentMargins).Top, bbSize.Height + 2);
titleBar.ColumnStyles[0].Width = bbSize.Width + 4F;
titleBar.ColumnStyles[1].Width = titleImageIcon != null ? titleImageList.ImageSize.Width + 4F : 0;
backButton.Size = bbSize;
// Header
theme.SetParameters(VisualStyleElementEx.AeroWizard.HeaderArea.Normal);
headerLabel.Margin = theme.GetMargins2(g, MarginProperty.ContentMargins);
headerLabel.ForeColor = theme.GetColor(ColorProperty.TextColor);
// Content
theme.SetParameters(VisualStyleElementEx.AeroWizard.ContentArea.Normal);
this.BackColor = theme.GetColor(ColorProperty.FillColor);
Padding cp = theme.GetMargins2(g, MarginProperty.ContentMargins);
contentArea.ColumnStyles[0].Width = cp.Left;
contentArea.RowStyles[1].Height = cp.Bottom;
// Command
theme.SetParameters(VisualStyleElementEx.AeroWizard.CommandArea.Normal);
cp = theme.GetMargins2(g, MarginProperty.ContentMargins);
commandArea.RowStyles[0].Height = cp.Top;
commandArea.RowStyles[2].Height = cp.Bottom;
commandArea.ColumnStyles[2].Width = contentArea.ColumnStyles[2].Width = cp.Right;
}
}
else
{
backButton.Size = new Size(Properties.Resources.BackBtnStrip.Width, Properties.Resources.BackBtnStrip.Height / 4);
}
}
public override void OnRenderSplitButtonBackground (ToolStripItemRenderEventArgs e)
{
if (!ThemeVisualStyles.RenderClientAreas) {
base.OnRenderSplitButtonBackground (e);
return;
}
VisualStyleElement element, drop_down_element;
if (IsDisabled (e.Item)) {
element = VisualStyleElement.ToolBar.SplitButton.Disabled;
drop_down_element = VisualStyleElement.ToolBar.SplitButtonDropDown.Disabled;;
} else if (IsPressed (e.Item)) {
element = VisualStyleElement.ToolBar.SplitButton.Pressed;
drop_down_element = VisualStyleElement.ToolBar.SplitButtonDropDown.Pressed;
} else if (IsChecked (e.Item))
if (IsHot (e.Item)) {
element = VisualStyleElement.ToolBar.SplitButton.HotChecked;
drop_down_element = VisualStyleElement.ToolBar.SplitButtonDropDown.HotChecked;
} else {
element = VisualStyleElement.ToolBar.Button.Checked;
drop_down_element = VisualStyleElement.ToolBar.SplitButtonDropDown.Checked;
}
else if (IsHot (e.Item)) {
element = VisualStyleElement.ToolBar.SplitButton.Hot;
drop_down_element = VisualStyleElement.ToolBar.SplitButtonDropDown.Hot;
} else {
element = VisualStyleElement.ToolBar.SplitButton.Normal;
drop_down_element = VisualStyleElement.ToolBar.SplitButtonDropDown.Normal;
}
if (!VisualStyleRenderer.IsElementDefined (element) ||
!VisualStyleRenderer.IsElementDefined (drop_down_element)) {
base.OnRenderSplitButtonBackground (e);
return;
}
ToolStripSplitButton tool_strip_split_button = (ToolStripSplitButton)e.Item;
VisualStyleRenderer renderer = new VisualStyleRenderer (element);
renderer.DrawBackground (e.Graphics, tool_strip_split_button.ButtonBounds);
renderer.SetParameters (drop_down_element);
renderer.DrawBackground (e.Graphics, tool_strip_split_button.DropDownButtonBounds);
}
protected override void OnPaint(PaintEventArgs e)
{
int height = base.ClientSize.Height / 2;
if (Application.RenderWithVisualStyles)
{
VisualStyleRenderer renderer = new VisualStyleRenderer((this.mouseOver == UpDownBase.ButtonID.Up) ? VisualStyleElement.Spin.Up.Hot : VisualStyleElement.Spin.Up.Normal);
if (!base.Enabled)
{
renderer.SetParameters(VisualStyleElement.Spin.Up.Disabled);
}
else if (this.pushed == UpDownBase.ButtonID.Up)
{
renderer.SetParameters(VisualStyleElement.Spin.Up.Pressed);
}
renderer.DrawBackground(e.Graphics, new Rectangle(0, 0, 0x10, height));
if (!base.Enabled)
{
renderer.SetParameters(VisualStyleElement.Spin.Down.Disabled);
}
else if (this.pushed == UpDownBase.ButtonID.Down)
{
renderer.SetParameters(VisualStyleElement.Spin.Down.Pressed);
}
else
{
renderer.SetParameters((this.mouseOver == UpDownBase.ButtonID.Down) ? VisualStyleElement.Spin.Down.Hot : VisualStyleElement.Spin.Down.Normal);
}
renderer.DrawBackground(e.Graphics, new Rectangle(0, height, 0x10, height));
}
else
{
ControlPaint.DrawScrollButton(e.Graphics, new Rectangle(0, 0, 0x10, height), ScrollButton.Up, (this.pushed == UpDownBase.ButtonID.Up) ? ButtonState.Pushed : (base.Enabled ? ButtonState.Normal : ButtonState.Inactive));
ControlPaint.DrawScrollButton(e.Graphics, new Rectangle(0, height, 0x10, height), ScrollButton.Down, (this.pushed == UpDownBase.ButtonID.Down) ? ButtonState.Pushed : (base.Enabled ? ButtonState.Normal : ButtonState.Inactive));
}
if (height != ((base.ClientSize.Height + 1) / 2))
{
using (Pen pen = new Pen(this.parent.BackColor))
{
Rectangle clientRectangle = base.ClientRectangle;
e.Graphics.DrawLine(pen, clientRectangle.Left, clientRectangle.Bottom - 1, clientRectangle.Right - 1, clientRectangle.Bottom - 1);
}
}
base.OnPaint(e);
}
/// <summary>
/// Gets the background image of the current visual style element within the specified background color. If <paramref name="states"/> is set, the resulting image will contain each of the state images side by side.
/// </summary>
/// <param name="rnd">The <see cref="VisualStyleRenderer"/> instance.</param>
/// <param name="clr">The background color. This color cannot have an alpha channel.</param>
/// <param name="states">The optional list of states to render side by side.</param>
/// <returns>The background image.</returns>
public static Bitmap GetBackgroundBitmap(this VisualStyleRenderer rnd, Color clr, int[] states = null)
{
const int wh = 200;
if (rnd == null)
{
throw new ArgumentNullException(nameof(rnd));
}
rnd.SetParameters(rnd.Class, rnd.Part, 0);
if (states == null)
{
states = new[] { rnd.State }
}
;
var i = states.Length;
// Get image size
Size imgSz;
using (var sg = Graphics.FromHwnd(IntPtr.Zero))
imgSz = rnd.GetPartSize(sg, new Rectangle(0, 0, wh, wh), ThemeSizeType.Draw);
if (imgSz.Width == 0 || imgSz.Height == 0)
{
imgSz = new Size(rnd.GetInteger(IntegerProperty.Width), rnd.GetInteger(IntegerProperty.Height));
}
var bounds = new Rectangle(0, 0, imgSz.Width * i, imgSz.Height);
// Draw each background linearly down the bitmap
using (var memoryHdc = SafeDCHandle.ScreenCompatibleDCHandle)
{
// Create a device-independent bitmap and select it into our DC
var info = new BITMAPINFO(bounds.Width, -bounds.Height);
IntPtr ppv;
using (new SafeDCObjectHandle(memoryHdc, CreateDIBSection(SafeDCHandle.Null, ref info, DIBColorMode.DIB_RGB_COLORS, out ppv, IntPtr.Zero, 0)))
{
using (var memoryGraphics = Graphics.FromHdc(memoryHdc.DangerousGetHandle()))
{
// Setup graphics
memoryGraphics.CompositingMode = CompositingMode.SourceOver;
memoryGraphics.CompositingQuality = CompositingQuality.HighQuality;
memoryGraphics.SmoothingMode = SmoothingMode.HighQuality;
memoryGraphics.Clear(clr);
// Draw each background linearly down the bitmap
var rect = new Rectangle(0, 0, imgSz.Width, imgSz.Height);
foreach (var state in states)
{
rnd.SetParameters(rnd.Class, rnd.Part, state);
rnd.DrawBackground(memoryGraphics, rect);
rect.X += imgSz.Width;
}
}
// Copy DIB to Bitmap
var bmp = new Bitmap(bounds.Width, bounds.Height, PixelFormat.Format32bppArgb);
using (var primaryHdc = new SafeDCHandle(Graphics.FromImage(bmp)))
BitBlt(primaryHdc, bounds.Left, bounds.Top, bounds.Width, bounds.Height, memoryHdc, 0, 0, RasterOperationMode.SRCCOPY);
return(bmp);
}
}
}
protected override void OnPaint(PaintEventArgs e)
{
if (Application.RenderWithVisualStyles)
{
VisualStyleRenderer vsr;
// ReSharper disable AssignNullToNotNullAttribute
if (IsUp)
{
vsr = new VisualStyleRenderer(
_captured
? VisualStyleElement.Spin.Up.Hot
: VisualStyleElement.Spin.Up.Normal);
if (!Enabled)
vsr.SetParameters(VisualStyleElement.Spin.Up.Disabled);
else if (_pushed)
vsr.SetParameters(VisualStyleElement.Spin.Up.Pressed);
}
else
{
vsr = new VisualStyleRenderer(
_captured
? VisualStyleElement.Spin.Down.Hot
: VisualStyleElement.Spin.Down.Normal);
if (!Enabled)
vsr.SetParameters(VisualStyleElement.Spin.Down.Disabled);
else if (_pushed)
vsr.SetParameters(VisualStyleElement.Spin.Down.Pressed);
}
// ReSharper restore AssignNullToNotNullAttribute
vsr.DrawBackground(e.Graphics, new Rectangle(0, 0, Width, Height));
}
else
{
ControlPaint.DrawScrollButton(
e.Graphics,
new Rectangle(0, 0, Width, Height),
IsUp ? ScrollButton.Up : ScrollButton.Down,
_pushed
? ButtonState.Pushed
: (Enabled
? ButtonState.Normal
: ButtonState.Inactive));
}
}
protected override void OnRenderItemCheck(ToolStripItemImageRenderEventArgs e)
{
if (e.Item.IsOnDropDown && IsSupported)
{
var renderer = new VisualStyleRenderer("menu", 12, e.Item.Enabled ? 2 : 1);
var bounds = new Rectangle(e.Item.ContentRectangle.X + 1, 0, e.Item.Bounds.Height, e.Item.Bounds.Height);
if (e.Item.RightToLeft == RightToLeft.Yes)
bounds = new Rectangle(e.ToolStrip.ClientSize.Width - bounds.X - bounds.Width, bounds.Y, bounds.Width, bounds.Height);
renderer.DrawBackground(e.Graphics, bounds);
var imageRectangle = e.ImageRectangle;
imageRectangle.X = bounds.X + bounds.Width / 2 - imageRectangle.Width / 2;
imageRectangle.Y = bounds.Y + bounds.Height / 2 - imageRectangle.Height / 2;
renderer.SetParameters("menu", 11, e.Item.Enabled ? 1 : 2);
renderer.DrawBackground(e.Graphics, imageRectangle);
}
else
{
base.OnRenderItemCheck(e);
}
}
/// <include file='doc\UpDownBase.uex' path='docs/doc[@for="UpDownBase.UpDownButtons.OnPaint"]/*' />
/// <devdoc>
/// Handles painting the buttons on the control.
///
/// </devdoc>
protected override void OnPaint(PaintEventArgs e) {
int half_height = ClientSize.Height / 2;
/* Draw the up and down buttons */
if (Application.RenderWithVisualStyles) {
VisualStyleRenderer vsr = new VisualStyleRenderer(mouseOver == ButtonID.Up ? VisualStyleElement.Spin.Up.Hot : VisualStyleElement.Spin.Up.Normal);
if (!Enabled) {
vsr.SetParameters(VisualStyleElement.Spin.Up.Disabled);
}
else if (pushed == ButtonID.Up) {
vsr.SetParameters(VisualStyleElement.Spin.Up.Pressed);
}
vsr.DrawBackground(e.Graphics, new Rectangle(0, 0, DefaultButtonsWidth, half_height));
if (!Enabled) {
vsr.SetParameters(VisualStyleElement.Spin.Down.Disabled);
}
else if (pushed == ButtonID.Down) {
vsr.SetParameters(VisualStyleElement.Spin.Down.Pressed);
}
else {
vsr.SetParameters(mouseOver == ButtonID.Down ? VisualStyleElement.Spin.Down.Hot : VisualStyleElement.Spin.Down.Normal);
}
vsr.DrawBackground(e.Graphics, new Rectangle(0, half_height, DefaultButtonsWidth, half_height));
}
else {
ControlPaint.DrawScrollButton(e.Graphics,
new Rectangle(0, 0, DefaultButtonsWidth, half_height),
ScrollButton.Up,
pushed == ButtonID.Up ? ButtonState.Pushed : (Enabled ? ButtonState.Normal : ButtonState.Inactive));
ControlPaint.DrawScrollButton(e.Graphics,
new Rectangle(0, half_height, DefaultButtonsWidth, half_height),
ScrollButton.Down,
pushed == ButtonID.Down ? ButtonState.Pushed : (Enabled ? ButtonState.Normal : ButtonState.Inactive));
}
if (half_height != (ClientSize.Height + 1) / 2) {
// When control has odd height, a line needs to be drawn below the buttons with the backcolor.
using (Pen pen = new Pen(this.parent.BackColor)) {
Rectangle clientRect = ClientRectangle;
e.Graphics.DrawLine(pen, clientRect.Left, clientRect.Bottom - 1, clientRect.Right - 1, clientRect.Bottom - 1);
}
}
base.OnPaint(e); // raise paint event, just in case this inner class goes public some day
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="TriStateTreeView"/> class.
/// </summary>
/// ------------------------------------------------------------------------------------
public TriStateTreeView()
{
// This call is required by the Windows.Forms Form Designer.
InitializeComponent();
if (Application.RenderWithVisualStyles)
{
using (Bitmap bmp = new Bitmap(m_TriStateImages.ImageSize.Width,
m_TriStateImages.ImageSize.Height))
{
Rectangle rc = new Rectangle(0, 0, bmp.Width, bmp.Height);
using (Graphics graphics = Graphics.FromImage(bmp))
{
VisualStyleRenderer renderer =
new VisualStyleRenderer(VisualStyleElement.Button.CheckBox.CheckedDisabled);
renderer.DrawBackground(graphics, rc, rc);
m_TriStateImages.Images[0] = bmp;
renderer.SetParameters(VisualStyleElement.Button.CheckBox.UncheckedNormal);
renderer.DrawBackground(graphics, rc, rc);
m_TriStateImages.Images[1] = bmp;
renderer.SetParameters(VisualStyleElement.Button.CheckBox.CheckedNormal);
renderer.DrawBackground(graphics, rc, rc);
m_TriStateImages.Images[2] = bmp;
}
}
}
int index = GetCheckImageIndex(CheckState.Unchecked);
ImageList = m_TriStateImages;
ImageIndex = index;
SelectedImageIndex = index;
}
private static void CalcSize(Graphics g)
{
if (VisualStyleInformation.IsEnabledByUser) {
VisualStyleRenderer renderer = new VisualStyleRenderer(_elementTop.VSElement);
_markSizeTopBottom = renderer.GetPartSize(g, ThemeSizeType.True);
renderer.SetParameters(_elementLeft.VSElement);
_markSizeLeftRight = renderer.GetPartSize(g, ThemeSizeType.True);
}
else {
_markSizeTopBottom = new Size(16, 16); //���̃T�C�Y�ł͐ݒ�ɂ���Ă̓_������
_markSizeLeftRight = new Size(16, 16);
}
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
const int thumbPadding = 2;
const int trackPadding = 2;
var left = ClientRectangle.Left;
var top = ClientRectangle.Top;
var width = ClientRectangle.Width;
var height = ClientRectangle.Height;
var cursor = PointToClient(MousePosition);
// paint focus rectangle
if (ShowFocusRectangle && Focused) ControlPaint.DrawFocusRectangle(e.Graphics, ClientRectangle);
if (!IsLeftMouseButtonDown()) _thumbDragging = false;
// compute object bounds
if (Orientation == Orientation.Horizontal)
{
_trackBounds = new Rectangle(left + trackPadding, top + height/2 - _trackSize/2, width - 2*trackPadding, _trackSize);
_thumbBounds = new Rectangle(ValueToPoint(Value).X - _thumbSize/2, top + thumbPadding, _thumbSize, height - 2*thumbPadding);
}
else
{
_trackBounds = new Rectangle(left + width/2 - _trackSize/2, top + trackPadding, _trackSize, height - 2*trackPadding);
_thumbBounds = new Rectangle(left + thumbPadding, ValueToPoint(Value).Y - _thumbSize/2, width - 2*thumbPadding, _thumbSize);
}
if (System.Windows.Forms.Application.RenderWithVisualStyles)
{
if (Orientation == Orientation.Horizontal)
{
// paint track
var renderer = new VisualStyleRenderer(VisualStyleElement.TrackBar.Track.Normal);
renderer.DrawBackground(e.Graphics, _trackBounds);
// paint thumb
if (!Enabled)
renderer.SetParameters(VisualStyleElement.TrackBar.Thumb.Disabled);
else if (_thumbDragging)
renderer.SetParameters(VisualStyleElement.TrackBar.Thumb.Pressed);
else if (!_thumbBounds.Contains(cursor))
renderer.SetParameters(Focused ? VisualStyleElement.TrackBar.Thumb.Focused : VisualStyleElement.TrackBar.Thumb.Normal);
else
renderer.SetParameters(IsLeftMouseButtonDown() ? VisualStyleElement.TrackBar.Thumb.Pressed : VisualStyleElement.TrackBar.Thumb.Hot);
renderer.DrawBackground(e.Graphics, _thumbBounds);
}
else
{
// paint track
var renderer = new VisualStyleRenderer(VisualStyleElement.TrackBar.TrackVertical.Normal);
renderer.DrawBackground(e.Graphics, _trackBounds);
// paint thumb
if (!Enabled)
renderer.SetParameters(VisualStyleElement.TrackBar.ThumbVertical.Disabled);
else if (_thumbDragging)
renderer.SetParameters(VisualStyleElement.TrackBar.ThumbVertical.Pressed);
else if (!_thumbBounds.Contains(cursor))
renderer.SetParameters(Focused ? VisualStyleElement.TrackBar.ThumbVertical.Focused : VisualStyleElement.TrackBar.ThumbVertical.Normal);
else
renderer.SetParameters(IsLeftMouseButtonDown() ? VisualStyleElement.TrackBar.ThumbVertical.Pressed : VisualStyleElement.TrackBar.ThumbVertical.Hot);
renderer.DrawBackground(e.Graphics, _thumbBounds);
}
}
else
{
// paint track
ControlPaint.DrawBorder3D(e.Graphics, _trackBounds, Border3DStyle.Sunken);
// paint thumb
if (!Enabled)
ControlPaint.DrawButton(e.Graphics, _thumbBounds, ButtonState.Inactive);
else
ControlPaint.DrawButton(e.Graphics, _thumbBounds, ButtonState.Normal);
}
}
/// <summary>Sets the state of the <see cref="VisualStyleRenderer"/>.</summary> /// <param name="rnd">The <see cref="VisualStyleRenderer"/> instance.</param> /// <param name="state">The state.</param> public static void SetState(this VisualStyleRenderer rnd, int state) => rnd.SetParameters(rnd.Class, rnd.Part, state);
protected override void OnPaint(PaintEventArgs e)
{
var clientRect = this.ClientRectangle;
var fillRect = clientRect;
fillRect.Width = (int)(_value / 100.0 * clientRect.Width);
try
{
// draw background
var renderer = new VisualStyleRenderer(VisualStyleElement.ProgressBar.Bar.Normal);
renderer.SetParameters(VsStyles.ProgressBar.Progress,
VsStyles.ProgressBar.ProgressParts.PP_BAR,
VsStyles.ProgressBar.FillStates.PBFS_NORMAL);
renderer.DrawBackground(e.Graphics, this.ClientRectangle);
// draw filled portion
renderer.SetParameters(VsStyles.ProgressBar.Progress,
VsStyles.ProgressBar.ProgressParts.PP_FILL, (int)_fillState);
renderer.DrawBackground(e.Graphics, fillRect);
}
catch(Exception)
{
// the VisualStyles stuff can fail when the OS is < Win7, in which case
// draw a very basic progress bar manually
e.Graphics.DrawRectangle(Pens.DarkGray, 0, 0, clientRect.Width - 1, clientRect.Height - 1);
e.Graphics.FillRectangle(GetStateBrush(), 1, 1,
Math.Min(fillRect.Width, clientRect.Width - 2), clientRect.Height - 2);
}
base.OnPaint(e);
}
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;
}
protected override void OnRenderSplitButtonBackground(ToolStripItemRenderEventArgs e)
{
ToolStripSplitButton item = e.Item as ToolStripSplitButton;
Graphics dc = e.Graphics;
bool rightToLeft = item.RightToLeft == RightToLeft.Yes;
Color arrowColor = item.Enabled ? SystemColors.ControlText : SystemColors.ControlDark;
VisualStyleElement element = rightToLeft ? VisualStyleElement.ToolBar.SplitButton.Normal : VisualStyleElement.ToolBar.SplitButtonDropDown.Normal;
VisualStyleElement element2 = rightToLeft ? VisualStyleElement.ToolBar.DropDownButton.Normal : VisualStyleElement.ToolBar.SplitButton.Normal;
Rectangle bounds = new Rectangle(Point.Empty, item.Size);
if ((ToolStripManager.VisualStylesEnabled && System.Windows.Forms.VisualStyles.VisualStyleRenderer.IsElementDefined(element)) && System.Windows.Forms.VisualStyles.VisualStyleRenderer.IsElementDefined(element2))
{
System.Windows.Forms.VisualStyles.VisualStyleRenderer visualStyleRenderer = VisualStyleRenderer;
visualStyleRenderer.SetParameters(element2.ClassName, element2.Part, GetSplitButtonItemState(item));
Rectangle buttonBounds = item.ButtonBounds;
if (rightToLeft)
{
buttonBounds.Inflate(2, 0);
}
visualStyleRenderer.DrawBackground(dc, buttonBounds);
visualStyleRenderer.SetParameters(element.ClassName, element.Part, GetSplitButtonDropDownItemState(item));
visualStyleRenderer.DrawBackground(dc, item.DropDownButtonBounds);
Rectangle contentRectangle = item.ContentRectangle;
if (item.BackgroundImage != null)
{
ControlPaint.DrawBackgroundImage(dc, item.BackgroundImage, item.BackColor, item.BackgroundImageLayout, contentRectangle, contentRectangle);
}
this.RenderSeparatorInternal(dc, item, item.SplitterBounds, true);
if (rightToLeft || (item.BackgroundImage != null))
{
base.DrawArrow(new ToolStripArrowRenderEventArgs(dc, item, item.DropDownButtonBounds, arrowColor, ArrowDirection.Down));
}
}
else
{
Rectangle rectangle4 = item.ButtonBounds;
if (item.BackgroundImage != null)
{
Rectangle clipRect = item.Selected ? item.ContentRectangle : bounds;
if (item.BackgroundImage != null)
{
ControlPaint.DrawBackgroundImage(dc, item.BackgroundImage, item.BackColor, item.BackgroundImageLayout, bounds, clipRect);
}
}
else
{
FillBackground(dc, rectangle4, item.BackColor);
}
ToolBarState splitButtonToolBarState = GetSplitButtonToolBarState(item, false);
this.RenderSmall3DBorderInternal(dc, rectangle4, splitButtonToolBarState, rightToLeft);
Rectangle dropDownButtonBounds = item.DropDownButtonBounds;
if (item.BackgroundImage == null)
{
FillBackground(dc, dropDownButtonBounds, item.BackColor);
}
splitButtonToolBarState = GetSplitButtonToolBarState(item, true);
switch (splitButtonToolBarState)
{
case ToolBarState.Pressed:
case ToolBarState.Hot:
this.RenderSmall3DBorderInternal(dc, dropDownButtonBounds, splitButtonToolBarState, rightToLeft);
break;
}
base.DrawArrow(new ToolStripArrowRenderEventArgs(dc, item, dropDownButtonBounds, arrowColor, ArrowDirection.Down));
}
}
/// <summary>
/// Draws our tab control.
/// </summary>
/// <param name="g">The <see cref="System.Drawing.Graphics"/> object used to draw tab control.</param>
/// <param name="clipRect">The <see cref="System.Drawing.Rectangle"/> that specifies clipping rectangle
/// of the control.</param>
private void DrawCustomTabControl(Graphics g, Rectangle clipRect)
{
/* In this method we draw only those parts of the control which intersects with the
* clipping rectangle. It's some kind of optimization.*/
if (!this.Visible) return;
//selected tab index and rectangle
int iSel = this.SelectedIndex;
Rectangle selRect = iSel != -1 ? this.GetTabRect(iSel) : Rectangle.Empty;
Rectangle rcPage = this.ClientRectangle;
//correcting page rectangle
switch (this.Alignment)
{
case TabAlignment.Top:
{
int trunc = selRect.Height * this.RowCount + 2;
rcPage.Y += trunc; rcPage.Height -= trunc;
} break;
case TabAlignment.Bottom: rcPage.Height -= (selRect.Height + XPTabControl.sAdjHeight) * this.RowCount; break;
}
//draw page itself
if (rcPage.IntersectsWith(clipRect)) TabRenderer.DrawTabPage(g, rcPage);
int tabCount = this.TabCount;
if (tabCount == 0) return;
//drawing unselected tabs
this.lastHotIndex = HitTest();//hot tab
VisualStyleRenderer tabRend = new VisualStyleRenderer(VisualStyleElement.Tab.TabItem.Normal);
for (int iTab = 0; iTab < tabCount; iTab++)
if (iTab != iSel)
{
Rectangle tabRect = this.GetTabRect(iTab);
if (tabRect.Right >= 3 && tabRect.IntersectsWith(clipRect))
{
TabItemState state = iTab == this.lastHotIndex ? TabItemState.Hot : TabItemState.Normal;
tabRend.SetParameters(tabRend.Class, tabRend.Part, (int)state);
DrawTabItem(g, iTab, tabRect, tabRend);
}
}
/* Drawing selected tab. We'll also increase selected tab's rectangle. It should be a little
* bigger than other tabs.*/
selRect.Inflate(2, 2);
if (iSel != -1 && selRect.IntersectsWith(clipRect))
{
tabRend.SetParameters(tabRend.Class, tabRend.Part, (int)TabItemState.Selected);
DrawTabItem(g, iSel, selRect, tabRend);
}
}
protected override void OnPaint(PaintEventArgs e)
{
// Draw the background
_ownerPropertyEnum.Property.ParentGrid.DrawManager.DrawPropertyValueBackground(e.Graphics,
ClientRectangle, _ownerPropertyEnum);
// Draw the combobox arrow
Rectangle buttonRect = GetButtonRect(e.Graphics);
if (Application.RenderWithVisualStyles)
{
VisualStyleRenderer renderer1 = new VisualStyleRenderer(_mouseOver ? VisualStyleElement.ComboBox.DropDownButton.Hot : VisualStyleElement.ComboBox.DropDownButton.Normal);
if (_pushed)
renderer1.SetParameters(VisualStyleElement.ComboBox.DropDownButton.Pressed);
renderer1.DrawBackground(e.Graphics, buttonRect);
}
else
{
ControlPaint.DrawComboButton(e.Graphics, buttonRect, _mouseOver ? ButtonState.Pushed : ButtonState.Normal);
}
if (Focused && (_ownerPropertyEnum.Property.InPlaceCtrlInAction == null))
{
Rectangle focusRect = buttonRect;
focusRect.Inflate(-3, -3);
ControlPaint.DrawFocusRectangle(e.Graphics, focusRect);
}
// Draw the value
if (_edit == null)
{
Rectangle valueRect = ClientRectangle;
valueRect.Width -= buttonRect.Width + 1;
if (Focused && (_ownerPropertyEnum.Property.InPlaceCtrlInAction == null))
{
Rectangle fillRect = _ownerPropertyEnum.Property.Value.GetStringValueRect(e.Graphics, valueRect, Point.Empty);
fillRect.Y++;
fillRect.Height-=2;
fillRect.X -= PropertyGrid.GlobalTextMargin / 2;
fillRect.Width = buttonRect.Left - 1 - fillRect.Left;
e.Graphics.FillRectangle(SystemBrushes.FromSystemColor(SystemColors.Highlight), fillRect);
}
Color valueColor;
if (_ownerPropertyEnum.Property.Enabled == false)
valueColor = SystemColors.GrayText;
else
{
if (Focused && (_ownerPropertyEnum.Property.InPlaceCtrlInAction == null))
valueColor = SystemColors.HighlightText;
else
valueColor = _ownerPropertyEnum.Property.Value.ForeColor;
}
_ownerPropertyEnum.Property.Value.DrawValue(e.Graphics, valueRect, valueColor, _ownerPropertyEnum, Text);
}
base.OnPaint(e);
}