protected override void OnRenderToolStripPanelBackground(ToolStripPanelRenderEventArgs e)
{
//Draw the background using Rebar & RP_BACKGROUND (or, if that is not available, fall back to
//Rebar.Band.Normal)
if (VisualStyleRenderer.IsElementDefined(VisualStyleElement.CreateElement(RebarClass, RP_BACKGROUND, 0)))
{
renderer.SetParameters(RebarClass, RP_BACKGROUND, 0);
}
else
{
renderer.SetParameters(RebarClass, 0, 0);
//renderer.SetParameters(VisualStyleElement.Taskbar.BackgroundBottom.Normal);
//renderer.SetParameters(Subclass(VisualStyleElement.Rebar.Band.Normal));
}
if (renderer.IsBackgroundPartiallyTransparent())
{
renderer.DrawParentBackground(e.Graphics, e.ToolStripPanel.ClientRectangle, e.ToolStripPanel);
}
renderer.DrawBackground(e.Graphics, e.ToolStripPanel.ClientRectangle);
//Draw the etched edges of each row.
//renderer.SetParameters(Subclass(VisualStyleElement.Rebar.Band.Normal));
//foreach (ToolStripPanelRow row in e.ToolStripPanel.Rows) {
// Rectangle rowBounds = row.Bounds;
// rowBounds.Offset(0, -1);
// renderer.DrawEdge(e.Graphics, rowBounds, Edges.Top, EdgeStyle.Etched, EdgeEffects.None);
//}
e.Handled = true;
}
protected override void OnRenderToolStripPanelBackground(ToolStripPanelRenderEventArgs e)
{
if (EnsureRenderer())
{
// Draw the background using Rebar & RP_BACKGROUND (or, if that is not available, fall back to
// Rebar.Band.Normal)
if (VisualStyleRenderer.IsElementDefined(VisualStyleElement.CreateElement(RebarClass, RebarBackground, 0)))
{
renderer.SetParameters(RebarClass, RebarBackground, 0);
}
else
{
renderer.SetParameters(RebarClass, 0, 0);
}
if (renderer.IsBackgroundPartiallyTransparent())
{
renderer.DrawParentBackground(e.Graphics, e.ToolStripPanel.ClientRectangle, e.ToolStripPanel);
}
renderer.DrawBackground(e.Graphics, e.ToolStripPanel.ClientRectangle);
e.Handled = true;
}
else
{
base.OnRenderToolStripPanelBackground(e);
}
}
/// <summary>
/// Paints the control using the Buffered Paint API.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void bufferedPainter_PaintVisualState(object sender, BufferedPaintEventArgs <ComboBoxState> e)
{
if (_drawWithVisualStyles && _bufferedPainter.BufferedPaintSupported && _bufferedPainter.Enabled)
{
// draw in the vista/win7 style
VisualStyleRenderer r = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
r.DrawParentBackground(e.Graphics, ClientRectangle, this);
Rectangle buttonBounds = ClientRectangle;
buttonBounds.Inflate(1, 1);
ButtonRenderer.DrawButton(e.Graphics, buttonBounds, GetPushButtonState(e.State));
Rectangle clipBounds = _dropDownButtonBounds;
clipBounds.Inflate(-2, -2);
e.Graphics.SetClip(clipBounds);
ComboBoxRenderer.DrawDropDownButton(e.Graphics, _dropDownButtonBounds, e.State);
e.Graphics.SetClip(ClientRectangle);
}
else if (_drawWithVisualStyles && ComboBoxRenderer.IsSupported)
{
// draw using the visual style renderer
ComboBoxRenderer.DrawTextBox(e.Graphics, ClientRectangle, GetTextBoxState());
ComboBoxRenderer.DrawDropDownButton(e.Graphics, _dropDownButtonBounds, e.State);
}
else
{
// draw using the legacy technique
DrawLegacyComboBox(e.Graphics, ClientRectangle, _dropDownButtonBounds, BackColor, GetPlainButtonState());
}
OnPaintContent(new DropDownPaintEventArgs(e.Graphics, ClientRectangle, GetTextBoxBounds()));
}
public override void Paint(PaintEventArgs e)
{
Layout(e);
// Get TaskDialog-PrimaryPanel
var vs = new VisualStyleRenderer(taskDialogClass, 1, 0);
vs.DrawParentBackground(e.Graphics, Control.ClientRectangle, Control);
if (Control.headerHot)
{
// Get ListView-GroupHeader-OpenHot
vs = new VisualStyleRenderer("ListView", 6, 2);
var hdrRect = Control.ClientRectangle;
hdrRect.Height = headerHeight;
vs.DrawBackground(e.Graphics, hdrRect, e.ClipRectangle);
}
// Get TaskDialog-ExpandoButton
vs = new VisualStyleRenderer(taskDialogClass, 13, ((int)Control.buttonState) + 1);
vs.DrawBackground(e.Graphics, buttonBounds);
// Get TaskDialog-MainInstructionPane
vs = new VisualStyleRenderer(taskDialogClass, 2, 0);
var tff = TextFormatFlags.SingleLine;
if (Control.GetRightToLeftProperty() == RightToLeft.Yes)
{
tff |= TextFormatFlags.RightToLeft;
}
vs.DrawText(e.Graphics, textBounds, Control.Text, !Control.Enabled, tff);
}
public void VisualStyleRenderer_DrawParentBackground_NullDc_ThrowsArgumentNullException()
{
var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
using var childControl = new Control();
Assert.Throws <ArgumentNullException>("dc", () => renderer.DrawParentBackground(null, new Rectangle(1, 2, 3, 4), childControl));
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
e.Graphics.FillRectangle(new SolidBrush(BackColor), ClientRectangle);
VisualStyleRenderer renderer = Renderer;
if (renderer != null)
{
if (renderer.IsBackgroundPartiallyTransparent())
{
renderer.DrawParentBackground(e.Graphics, ClientRectangle, this);
}
renderer.DrawBackground(e.Graphics, ClientRectangle, e.ClipRectangle);
}
else
{
using (var boxLinePen = new Pen(SystemColors.ControlDark, 1))
{
e.Graphics.DrawRectangle(boxLinePen, ClientRectangle);
int ctrY = ClientRectangle.Y + (ClientRectangle.Height / 2);
// Draw the minus sign.
e.Graphics.DrawLine(boxLinePen, ClientRectangle.X + 2, ctrY, ClientRectangle.X + ClientRectangle.Width - 2, ctrY);
if (!m_opened)
{
// Draw the vertical part of the plus, if we are collapsed.
int ctrX = ClientRectangle.X + (ClientRectangle.Width / 2);
e.Graphics.DrawLine(boxLinePen, ctrX, ClientRectangle.Y + 4, ctrX, ClientRectangle.Y + ClientRectangle.Height - 4);
}
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Draws the button with an image.
/// </summary>
/// ------------------------------------------------------------------------------------
public void DrawArrow(PaintEventArgs e)
{
Rectangle rc = ClientRectangle;
// If possible, render the button with visual styles. Otherwise,
// paint the plain Windows 2000 push button.
VisualStyleElement element = GetCorrectVisualStyleArrowElement();
if (PaintingHelper.CanPaintVisualStyle(element))
{
VisualStyleRenderer renderer = new VisualStyleRenderer(element);
renderer.DrawParentBackground(e.Graphics, rc, this);
renderer.DrawBackground(e.Graphics, rc);
return;
}
if (!Font.SizeInPoints.Equals(12))
{
Font = new Font(Font.FontFamily, 12, GraphicsUnit.Point);
}
ControlPaint.DrawButton(e.Graphics, rc,
(m_state == PaintState.HotDown ? ButtonState.Pushed : ButtonState.Normal));
// In the Marlette font, '3' is the left arrow and '4' is the right.
var arrowGlyph = (m_drawLeftArrowButton ? "3" : "4");
var clr = (Enabled ? SystemColors.ControlText : SystemColors.GrayText);
// The 'r' in the Marlette font is the close button symbol 'X'
TextRenderer.DrawText(e.Graphics, arrowGlyph, Font, rc, clr, fTxtFmtflags);
}
/// <summary>
/// Paints the control (using the Buffered Paint API).
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void _bufferedPainter_PaintVisualState(object sender, BufferedPaintEventArgs <ComboBoxState> e)
{
VisualStyleRenderer r = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
r.DrawParentBackground(e.Graphics, ClientRectangle, this);
DrawComboBox(e.Graphics, ClientRectangle, e.State);
Rectangle itemBounds = new Rectangle(0, 0, Width - 21, Height);
itemBounds.Inflate(-1, -3);
itemBounds.Offset(2, 0);
// draw the item in the editable portion
DrawItemState state = DrawItemState.ComboBoxEdit;
if (Focused && ShowFocusCues && !DroppedDown)
{
state |= DrawItemState.Focus;
}
if (!Enabled)
{
state |= DrawItemState.Disabled;
}
OnDrawItem(new DrawItemEventArgs(e.Graphics, Font, itemBounds, SelectedIndex, state));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Draws the button with an image.
/// </summary>
/// ------------------------------------------------------------------------------------
private void DrawArrow(PaintEventArgs e)
{
Rectangle rc = ClientRectangle;
// If possible, render the button with visual styles. Otherwise,
// paint the plain Windows 2000 push button.
VisualStyleElement element = GetCorrectVisualStyleArrowElement();
if (PaintingHelper.CanPaintVisualStyle(element))
{
VisualStyleRenderer renderer = new VisualStyleRenderer(element);
renderer.DrawParentBackground(e.Graphics, rc, this);
renderer.DrawBackground(e.Graphics, rc);
return;
}
if (Font.SizeInPoints != 12)
{
Font = new Font(Font.FontFamily, 12, GraphicsUnit.Point);
}
ControlPaint.DrawButton(e.Graphics, rc,
(m_state == PaintState.HotDown ? ButtonState.Pushed : ButtonState.Normal));
var arrowGlyph = Platform.IsWindows
// In the Marlett font, '3' is the left arrow and '4' is the right.
? (m_drawLeftArrowButton ? "3" : "4")
// Linux doesn't have the Marlett font, so use standard Unicode dingbats here.
: (m_drawLeftArrowButton ? "\u25C4" : "\u25BA");
Color clr = (Enabled ? SystemColors.ControlText : SystemColors.GrayText);
TextRenderer.DrawText(e.Graphics, arrowGlyph, Font, rc, clr, m_txtFmtflags);
}
/// <summary>
/// This is just a convenience wrapper for VisualStyleRenderer.DrawThemeParentBackground. For downlevel,
/// this isn't required and does nothing.
/// </summary>
public static void DrawParentBackground(Graphics g, Rectangle bounds, Control childControl)
{
if (RenderWithVisualStyles)
{
InitializeRenderer(0);
visualStyleRenderer.DrawParentBackground(g, bounds, childControl);
}
}
internal static void DrawParentBackground(IDeviceContext dc, Rectangle bounds, Control childControl)
{
if (RenderWithVisualStyles)
{
InitializeRenderer(0);
t_visualStyleRenderer.DrawParentBackground(dc, bounds, childControl);
}
}
private void DrawBackground(ToolStripRenderEventArgs e)
{
if (Renderer.IsBackgroundPartiallyTransparent())
{
Renderer.DrawParentBackground(e.Graphics, e.ToolStrip.ClientRectangle, e.ToolStrip);
}
Renderer.DrawBackground(e.Graphics, e.ToolStrip.ClientRectangle, e.AffectedBounds);
}
/// <summary>
/// </summary>
/// <param name="e">A <see cref="T:System.Windows.Forms.PaintEventArgs"/> that contains the event data.</param>
protected override void OnPaint(PaintEventArgs e)
{
if (Visible)
{
VisualStyleRenderer vs = null;
if (Application.RenderWithVisualStyles || DesktopWindowManager.IsCompositionEnabled())
{
vs = new VisualStyleRenderer(VisualStyleElement.Window.Caption.Active);
vs.DrawParentBackground(e.Graphics, base.ClientRectangle, this);
}
// Draw image
Rectangle r = DeflateRect(base.ClientRectangle, base.Padding);
if (this.Image != null)
{
Rectangle ir = CalcImageRenderBounds(this.Image, r, base.RtlTranslateAlignment(this.ImageAlign));
if (this.ImageList != null && this.ImageIndex == 0)
{
if (vs != null & !this.IsDesignMode() & DesktopWindowManager.IsCompositionEnabled())
{
vs.DrawGlassIcon(e.Graphics, r, this.ImageList, this.ImageIndex);
}
else
{
this.ImageList.Draw(e.Graphics, r.X, r.Y, r.Width, r.Height, this.ImageIndex);
}
}
else
{
if (vs != null & !this.IsDesignMode() & DesktopWindowManager.IsCompositionEnabled())
{
vs.DrawGlassImage(e.Graphics, r, this.Image);
}
else
{
e.Graphics.DrawImage(this.Image, r);
}
}
}
// Draw text
if (this.Text.Length > 0)
{
TextFormatFlags tff = CreateTextFormatFlags(this.TextAlign, this.AutoEllipsis, this.UseMnemonic);
if (this.IsDesignMode() || vs == null || !DesktopWindowManager.IsCompositionEnabled())
{
Brush br = DesktopWindowManager.IsCompositionEnabled() ? SystemBrushes.ActiveCaptionText : SystemBrushes.ControlText;
e.Graphics.DrawString(Text, Font, br, base.ClientRectangle);
}
else
{
vs.DrawGlowingText(e.Graphics, base.ClientRectangle, Text, Font, ForeColor, tff);
}
}
}
}
public static void DrawParentBackground(Graphics g, Rectangle_ bounds, Control childControl)
{
if (!VisualStyleRenderer.IsSupported)
{
return;
}
VisualStyleRenderer vsr = new VisualStyleRenderer(VisualStyleElement.Button.CheckBox.UncheckedNormal);
vsr.DrawParentBackground(g, bounds, childControl);
}
public static void DrawParentBackground(Graphics g, Rectangle bounds, Control childControl)
{
if (!VisualStyleRenderer.IsSupported)
{
return;
}
VisualStyleRenderer vsr = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Default);
vsr.DrawParentBackground(g, bounds, childControl);
}
public void VisualStyleRenderer_DrawParentBackgroundInvokeIDeviceContextRectangleChildWithoutHandle_Success(Rectangle bounds)
{
// Don't verify anything, just make sure the interop call succeeds.
var renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
using var bitmap = new Bitmap(10, 10);
using Graphics graphics = Graphics.FromImage(bitmap);
using var childControl = new Control();
renderer.DrawParentBackground(graphics, bounds, childControl);
Assert.False(childControl.IsHandleCreated);
Assert.Equal(0, renderer.LastHResult);
}
protected override void OnRenderToolStripBackground(ToolStripRenderEventArgs e)
{
if (e.ToolStrip.IsDropDown && IsSupported)
{
var renderer = new VisualStyleRenderer("menu", 9, 0);
if (renderer.IsBackgroundPartiallyTransparent())
{
renderer.DrawParentBackground(e.Graphics, e.ToolStrip.ClientRectangle, e.ToolStrip);
}
renderer.DrawBackground(e.Graphics, e.ToolStrip.ClientRectangle, e.AffectedBounds);
}
else
{
base.OnRenderToolStripBackground(e);
}
}
/// <summary>
/// Paints the control using the Buffered Paint API.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void bufferedPainter_PaintVisualState(object sender, BufferedPaintEventArgs <ComboBoxState> e)
{
if (_drawWithVisualStyles && _bufferedPainter.BufferedPaintSupported && _bufferedPainter.Enabled && (_style == DropDownControlStyles.Discrete))
{
// draw in the vista/win7 style
VisualStyleRenderer r = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
r.DrawParentBackground(e.Graphics, ClientRectangle, this);
Rectangle buttonBounds = ClientRectangle;
buttonBounds.Inflate(1, 1);
ButtonRenderer.DrawButton(e.Graphics, buttonBounds, GetPushButtonState(e.State));
Rectangle clipBounds = _dropDownButtonBounds;
clipBounds.Inflate(-2, -2);
e.Graphics.SetClip(clipBounds);
ComboBoxRenderer.DrawDropDownButton(e.Graphics, _dropDownButtonBounds, e.State);
e.Graphics.SetClip(ClientRectangle);
}
else if (_drawWithVisualStyles && ComboBoxRenderer.IsSupported)
{
// draw using the visual style renderer
if (Enabled)
{
ComboBoxRenderer.DrawTextBox(e.Graphics, ClientRectangle, GetTextBoxState());
}
else
{
Rectangle outline = ClientRectangle;
outline.Width--;
outline.Height--;
e.Graphics.FillRectangle(SystemBrushes.Control, ClientRectangle);
e.Graphics.DrawRectangle(Pens.LightGray, outline);
}
DrawDropDownGlyph(e.Graphics, _dropDownButtonBounds, e.State);
}
else
{
// draw using the legacy technique
DrawLegacyComboBox(e.Graphics, ClientRectangle, _dropDownButtonBounds, BackColor, GetPlainButtonState());
}
OnPaintContent(new DropDownPaintEventArgs(e.Graphics, ClientRectangle, GetTextBoxBounds()));
}
/// <summary>
/// Primary function for painting the button. This method should be overridden instead of OnPaint.
/// </summary>
/// <param name="graphics">The graphics.</param>
/// <param name="bounds">The bounds.</param>
protected override void PaintButton(Graphics graphics, Rectangle bounds)
{
if (Application.RenderWithVisualStyles)
{
try
{
VisualStyleRenderer rnd = new VisualStyleRenderer(StyleClass, StylePart, (int)ButtonState);
if (this.IsDesignMode() || !DesktopWindowManager.IsCompositionEnabled())
{
rnd.DrawParentBackground(graphics, bounds, this);
rnd.DrawBackground(graphics, bounds);
}
else
{
rnd.DrawGlassBackground(graphics, bounds, bounds);
}
return;
}
catch { }
}
else
{
base.PaintButton(graphics, bounds);
/*Rectangle sr = this.ClientRectangle;
* sr.Offset(0, sr.Height * ((int)ButtonState - 1));
* graphics.Clear(this.Parent.BackColor);
* if (imageStrip != null)
* {
* Bitmap bmp = imageStrip.Clone(sr, imageStrip.PixelFormat);
* if (this.IsDesignMode() || !DesktopWindowManager.IsCompositionEnabled())
* {
* base.ImageList.Draw(graphics, bounds.X, bounds.Y, bounds.Width, bounds.Height, ((int)ButtonState - 1));
* }
* else
* {
* VisualStyleRendererExtender.DrawGlassImage(null, graphics, bounds, bmp);
* }
* }
* else
* using (Brush br = new SolidBrush(this.BackColor))
* graphics.FillRectangle(br, sr);*/
}
}
protected override void WndProc(ref Message m)
{
const int WM_ERASEBKGND = 0x14;
switch (m.Msg)
{
case WM_ERASEBKGND:
if (Application.RenderWithVisualStyles)
{
VisualStyleRenderer rend = new VisualStyleRenderer(VisualStyleElement.TextBox.TextEdit.Normal);
rend.DrawParentBackground(new DeviceContext(m.WParam), this.ClientRectangle, this);
m.Result = (IntPtr)1;
return;
}
break;
}
base.WndProc(ref m);
}
/// <summary>
/// Paints the control (using the Buffered Paint API).
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void _bufferedPainter_PaintVisualState(object sender, BufferedPaintEventArgs <ComboBoxState> e)
{
var r = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
r.DrawParentBackground(e.Graphics, ClientRectangle, this);
var buttonBounds = new Rectangle(Width - 17, 0, 17, Height - (e.State != ComboBoxState.Pressed ? 1 : 0));
var bounds = ClientRectangle;
bounds.Inflate(1, 1);
ButtonRenderer.DrawButton(e.Graphics, bounds, GetPushButtonState(e.State));
Rectangle buttonClip = buttonBounds;
buttonClip.Inflate(-2, -2);
e.Graphics.SetClip(buttonClip);
ComboBoxRenderer.DrawDropDownButton(e.Graphics, buttonBounds, e.State);
e.Graphics.SetClip(ClientRectangle);
var itemBounds = new Rectangle(0, 0, Width - 21, Height);
itemBounds.Inflate(-1, -3);
itemBounds.Offset(2, 0);
// draw the item in the editable portion
var state = DrawItemState.ComboBoxEdit;
if (Focused && ShowFocusCues && !DroppedDown)
{
state |= DrawItemState.Focus;
}
if (!Enabled)
{
state |= DrawItemState.Disabled;
}
OnDrawItem(new DrawItemEventArgs(e.Graphics, Font, itemBounds, SelectedIndex, state));
}
protected override void PaintButton(Graphics graphics, Rectangle bounds)
{
if (Application.RenderWithVisualStyles || DesktopWindowManager.IsCompositionEnabled())
{
try
{
VisualStyleRenderer rnd = new VisualStyleRenderer(StyleClass, StylePart, (int)ButtonState);
if (this.IsDesignMode() || !DesktopWindowManager.IsCompositionEnabled())
{
rnd.DrawParentBackground(graphics, this.Bounds, this);
rnd.DrawBackground(graphics, this.Bounds, bounds);
}
else
{
rnd.DrawGlassBackground(graphics, this.Bounds, bounds);
}
return;
}
catch { }
}
//base.PaintButton(graphics, bounds);
Rectangle sr = this.ClientRectangle;
sr.Offset(0, sr.Height * ((int)ButtonState - 1));
graphics.Clear(this.Parent.BackColor);
if (imageStrip != null)
{
graphics.DrawImage(imageStrip, this.Bounds, sr, GraphicsUnit.Pixel);
}
else
{
using (Brush br = new SolidBrush(this.BackColor))
graphics.FillRectangle(br, sr);
}
}
/// <summary>
/// Paints the control.
/// </summary>
/// <param name="e">The <see cref="PaintEventArgs"/> instance containing the event data.</param>
protected virtual void PaintControl(PaintEventArgs e)
{
var cbi = NativeMethods.COMBOBOXINFO.FromComboBox(this);
string itemText = this.SelectedIndex >= 0 ? this.GetItemText(this.SelectedItem) : string.Empty;
ComboBoxState state = Enabled ? currentState : ComboBoxState.Disabled;
Rectangle tr = cbi.rcItem;
/*Rectangle tr = this.ClientRectangle;
* tr.Width -= (SystemInformation.VerticalScrollBarWidth + 2);
* tr.Inflate(0, -2);
* tr.Offset(1, 0);*/
Rectangle br = cbi.rcButton;
bool vsSuccess = false;
if (VisualStyleRenderer.IsSupported && Application.RenderWithVisualStyles)
{
/*Rectangle r = Rectangle.Inflate(this.ClientRectangle, 1, 1);
* if (this.DropDownStyle != ComboBoxStyle.DropDownList)
* {
* e.Graphics.Clear(this.BackColor);
* ComboBoxRenderer.DrawTextBox(e.Graphics, r, itemText, this.Font, tr, tff, state);
* ComboBoxRenderer.DrawDropDownButton(e.Graphics, br, state);
* }
* else*/
{
try
{
var vr = new VisualStyleRenderer("Combobox", this.DropDownStyle == ComboBoxStyle.DropDownList ? 5 : 4, (int)state);
vr.DrawParentBackground(e.Graphics, this.ClientRectangle, this);
vr.DrawBackground(e.Graphics, this.ClientRectangle);
if (this.DropDownStyle != ComboBoxStyle.DropDownList)
{
br.Inflate(1, 1);
}
Rectangle cr = this.DropDownStyle == ComboBoxStyle.DropDownList ? Rectangle.Inflate(br, -1, -1) : br;
vr.SetParameters("Combobox", 7, (int)(br.Contains(this.PointToClient(Cursor.Position)) ? state : ComboBoxState.Normal));
vr.DrawBackground(e.Graphics, br, cr);
if (this.Focused && State != ComboBoxState.Pressed)
{
Size sz = TextRenderer.MeasureText(e.Graphics, "Wg", this.Font, tr.Size, TextFormatFlags.Default);
Rectangle fr = Rectangle.Inflate(tr, 0, ((sz.Height - tr.Height) / 2) + 1);
ControlPaint.DrawFocusRectangle(e.Graphics, fr);
}
TextRenderer.DrawText(e.Graphics, itemText, this.Font, tr, this.ForeColor, tff);
vsSuccess = true;
}
catch { }
}
}
if (!vsSuccess)
{
System.Diagnostics.Debug.WriteLine(string.Format("CR:{0};ClR:{1};Foc:{2};St:{3};Tx:{4}", ClientRectangle, e.ClipRectangle, this.Focused, state, itemText));
e.Graphics.Clear(this.BackColor);
ControlPaint.DrawBorder3D(e.Graphics, this.ClientRectangle, Border3DStyle.Sunken);
ControlPaint.DrawComboButton(e.Graphics, br, this.Enabled ? (state == ComboBoxState.Pressed ? ButtonState.Pushed : ButtonState.Normal) : ButtonState.Inactive);
//using (var bb = new SolidBrush(this.BackColor))
// e.Graphics.FillRectangle(bb, tr);
if (this.Focused)
{
Size sz = TextRenderer.MeasureText(e.Graphics, "Wg", this.Font, tr.Size, TextFormatFlags.Default);
Rectangle fr = Rectangle.Inflate(tr, 0, ((sz.Height - tr.Height) / 2) + 1);
e.Graphics.FillRectangle(SystemBrushes.Highlight, fr);
ControlPaint.DrawFocusRectangle(e.Graphics, fr); //, this.ForeColor, SystemColors.Highlight);
}
TextRenderer.DrawText(e.Graphics, itemText, this.Font, tr, this.Focused ? SystemColors.HighlightText : this.ForeColor, tff);
}
}
private void PaintPriv(PaintEventArgs e)
{
Graphics g = e.Graphics;
if (g == null)
{
base.OnPaint(e); return;
}
int nNormPos = m_nPosition - m_nMinimum;
int nNormMax = m_nMaximum - m_nMinimum;
if (nNormMax <= 0)
{
Debug.Assert(false); nNormMax = 100;
}
if (nNormPos < 0)
{
Debug.Assert(false); nNormPos = 0;
}
if (nNormPos > nNormMax)
{
Debug.Assert(false); nNormPos = nNormMax;
}
Rectangle rectClient = this.ClientRectangle;
Rectangle rectDraw;
VisualStyleElement vse = VisualStyleElement.ProgressBar.Bar.Normal;
if (VisualStyleRenderer.IsSupported &&
VisualStyleRenderer.IsElementDefined(vse))
{
VisualStyleRenderer vsr = new VisualStyleRenderer(vse);
if (vsr.IsBackgroundPartiallyTransparent())
{
vsr.DrawParentBackground(g, rectClient, this);
}
vsr.DrawBackground(g, rectClient);
rectDraw = vsr.GetBackgroundContentRectangle(g, rectClient);
}
else
{
g.FillRectangle(SystemBrushes.Control, rectClient);
Pen penGray = SystemPens.ControlDark;
Pen penWhite = SystemPens.ControlLight;
g.DrawLine(penGray, 0, 0, rectClient.Width - 1, 0);
g.DrawLine(penGray, 0, 0, 0, rectClient.Height - 1);
g.DrawLine(penWhite, rectClient.Width - 1, 0,
rectClient.Width - 1, rectClient.Height - 1);
g.DrawLine(penWhite, 0, rectClient.Height - 1,
rectClient.Width - 1, rectClient.Height - 1);
rectDraw = new Rectangle(rectClient.X + 1, rectClient.Y + 1,
rectClient.Width - 2, rectClient.Height - 2);
}
int nDrawWidth = (int)((float)rectDraw.Width * (float)nNormPos /
(float)nNormMax);
Color clrStart = AppDefs.ColorQualityLow;
Color clrEnd = AppDefs.ColorQualityHigh;
if (!this.Enabled)
{
clrStart = UIUtil.ColorToGrayscale(SystemColors.ControlDark);
clrEnd = UIUtil.ColorToGrayscale(SystemColors.ControlLight);
}
bool bRtl = (this.RightToLeft == RightToLeft.Yes);
if (bRtl)
{
Color clrTemp = clrStart;
clrStart = clrEnd;
clrEnd = clrTemp;
}
// Workaround for Windows <= XP
Rectangle rectGrad = new Rectangle(rectDraw.X, rectDraw.Y,
rectDraw.Width, rectDraw.Height);
if (!WinUtil.IsAtLeastWindowsVista && !NativeLib.IsUnix())
{
rectGrad.Inflate(1, 0);
}
using (LinearGradientBrush brush = new LinearGradientBrush(rectGrad,
clrStart, clrEnd, LinearGradientMode.Horizontal))
{
g.FillRectangle(brush, (bRtl ? (rectDraw.Width - nDrawWidth + 1) :
rectDraw.Left), rectDraw.Top, nDrawWidth, rectDraw.Height);
}
PaintText(g, rectDraw);
}
/// <summary>
/// Paints the control (using the Buffered Paint API).
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void _bufferedPainter_PaintVisualState(object sender, BufferedPaintEventArgs<ComboBoxState> e) {
VisualStyleRenderer r = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
r.DrawParentBackground(e.Graphics, ClientRectangle, this);
DrawComboBox(e.Graphics, ClientRectangle, e.State);
Rectangle itemBounds = new Rectangle(0, 0, Width - 21, Height);
itemBounds.Inflate(-1, -3);
itemBounds.Offset(2, 0);
// draw the item in the editable portion
DrawItemState state = DrawItemState.ComboBoxEdit;
if (Focused && ShowFocusCues && !DroppedDown) state |= DrawItemState.Focus;
if (!Enabled) state |= DrawItemState.Disabled;
OnDrawItem(new DrawItemEventArgs(e.Graphics, Font, itemBounds, SelectedIndex, state));
}
/// <summary>
/// Raises the Paint event.
/// </summary>
/// <param name="e">A <see cref="T:System.Windows.Forms.PaintEventArgs" /> that contains the event data.</param>
protected override void OnPaint(PaintEventArgs e)
{
if (Visible)
{
VisualStyleRenderer vs = null;
if (Application.RenderWithVisualStyles || DesktopWindowManager.IsCompositionEnabled())
{
vs = new VisualStyleRenderer(VisualStyleElement.Window.Caption.Active);
vs.DrawParentBackground(e.Graphics, base.ClientRectangle, this);
}
// Draw image
Rectangle r = DeflateRect(base.ClientRectangle, base.Padding);
if (Image != null)
{
//Rectangle ir = CalcImageRenderBounds(this.Image, r, base.RtlTranslateAlignment(this.ImageAlign));
if (ImageList != null && ImageIndex == 0)
{
if (vs != null && !this.IsDesignMode() && DesktopWindowManager.IsCompositionEnabled())
{
vs.DrawGlassImage(e.Graphics, r, ImageList, ImageIndex);
}
else
{
ImageList.Draw(e.Graphics, r.X, r.Y, r.Width, r.Height, ImageIndex);
}
}
else
{
if (vs != null && !this.IsDesignMode() && DesktopWindowManager.IsCompositionEnabled())
{
vs.DrawGlassImage(e.Graphics, r, Image);
}
else
{
e.Graphics.DrawImage(Image, r);
}
}
}
// Draw text
if (Text.Length > 0)
{
if (this.IsDesignMode() || vs == null || !DesktopWindowManager.IsCompositionEnabled())
{
Brush br = DesktopWindowManager.IsCompositionEnabled() ? SystemBrushes.ActiveCaptionText : SystemBrushes.ControlText;
StringFormat sf = new StringFormat(StringFormat.GenericDefault);
if (this.GetRightToLeftProperty() == System.Windows.Forms.RightToLeft.Yes)
{
sf.FormatFlags |= StringFormatFlags.DirectionRightToLeft;
}
e.Graphics.DrawString(Text, Font, br, base.ClientRectangle, sf);
}
else
{
TextFormatFlags tff = CreateTextFormatFlags(base.RtlTranslateAlignment(TextAlign), AutoEllipsis, UseMnemonic);
vs.DrawGlowingText(e.Graphics, base.ClientRectangle, Text, Font, ForeColor, tff);
}
}
}
}
/// <summary>
/// Primary function for painting the button. This method should be overridden instead of OnPaint.
/// </summary>
/// <param name="graphics">The graphics.</param>
/// <param name="bounds">The bounds.</param>
protected virtual void PaintButton(Graphics graphics, Rectangle bounds)
{
VisualStyleRenderer rnd = null;
bool vsOk = Application.RenderWithVisualStyles;
if (vsOk)
{
rnd = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
rnd.DrawParentBackground(graphics, bounds, this);
}
else
{
graphics.Clear(this.Parent.BackColor);
}
if (this.Image != null || (this.ImageList != null && this.ImageList.Images.Count == 1))
{
Image img = (this.Image != null) ? this.Image : this.ImageList.Images[0];
if (Enabled)
{
if (vsOk)
{
rnd.DrawImage(graphics, bounds, img);
}
else
{
graphics.DrawImage(img, bounds);
}
}
else
{
ControlPaint.DrawImageDisabled(graphics, img, 0, 0, this.BackColor);
}
}
else if (this.ImageList != null && this.ImageList.Images.Count > 1)
{
int idx = (int)ButtonState - 1;
if (this.ImageList.Images.Count == 2)
{
idx = ButtonState == PushButtonState.Disabled ? 1 : 0;
}
if (this.ImageList.Images.Count == 3)
{
idx = ButtonState == PushButtonState.Normal ? 0 : idx - 1;
}
if (vsOk)
{
rnd.DrawImage(graphics, bounds, this.ImageList, idx);
}
else
{
graphics.DrawImage(this.ImageList.Images[idx], bounds);
}
}
else
{
if (vsOk)
{
rnd.SetParameters(rnd.Class, rnd.Part, (int)ButtonState);
rnd.DrawBackground(graphics, bounds);
}
else
{
System.Windows.Forms.ButtonState bs = System.Windows.Forms.ButtonState.Flat;
switch (this.ButtonState)
{
case PushButtonState.Disabled:
bs |= System.Windows.Forms.ButtonState.Inactive;
break;
case PushButtonState.Pressed:
bs |= System.Windows.Forms.ButtonState.Pushed;
break;
default:
break;
}
ControlPaint.DrawButton(graphics, bounds, bs);
}
}
}
protected override void OnPaint(PaintEventArgs pevent)
{
base.OnPaint(pevent);
if (pevent == null || !showSplit)
{
return;
}
Graphics g = pevent.Graphics;
Rectangle bounds = this.ClientRectangle;
// draw the button background as according to the current state.
if (State != PushButtonState.Pressed && IsDefault && !Application.RenderWithVisualStyles)
{
Rectangle backgroundBounds = bounds;
backgroundBounds.Inflate(-1, -1);
ButtonRenderer.DrawButton(g, backgroundBounds, State);
// button renderer doesnt draw the black frame when themes are off =(
g.DrawRectangle(SystemPens.WindowFrame, 0, 0, bounds.Width - 1, bounds.Height - 1);
}
else
{
if (renderer != null)
{
renderer.SetParameters(GetVisualStyleElement(State, Focused));
if (renderer.IsBackgroundPartiallyTransparent())
{
renderer.DrawParentBackground(g, bounds, this);
}
//
// We are using the visual style of a window's close button. In order to render the 'X' offset from center, we render twice:
// 1. Render the entire width of the control so the background of the dropdown arrow has the correct style
// -------------
// | X |
// -------------
// 2. Render the main button portion only which will cover up the originally centered 'X' and render the 'X' offset.
// ---------
// | X |
// ---------
//
Rectangle boundsLessArrowPart = new Rectangle(bounds.Location, new Size(bounds.Width - PushButtonWidth, bounds.Height));
if (RightToLeft == System.Windows.Forms.RightToLeft.Yes)
{
boundsLessArrowPart.X += PushButtonWidth + 1;
}
renderer.DrawBackground(g, bounds);
renderer.DrawBackground(g, boundsLessArrowPart);
}
else
{
ButtonRenderer.DrawButton(g, bounds, State);
}
}
// calculate the current dropdown rectangle.
dropDownRectangle = new Rectangle(bounds.Right - PushButtonWidth - 1, BorderSize, PushButtonWidth, bounds.Height - BorderSize * 2);
int internalBorder = BorderSize;
Rectangle focusRect =
new Rectangle(internalBorder,
internalBorder,
bounds.Width - dropDownRectangle.Width - internalBorder,
bounds.Height - (internalBorder * 2));
bool drawSplitLine = (State == PushButtonState.Hot || State == PushButtonState.Pressed || !Application.RenderWithVisualStyles);
if (RightToLeft == RightToLeft.Yes)
{
dropDownRectangle.X = bounds.Left + 1;
focusRect.X = dropDownRectangle.Right;
if (drawSplitLine && renderer == null)
{
// draw two lines at the edge of the dropdown button
g.DrawLine(SystemPens.ButtonShadow, bounds.Left + PushButtonWidth, BorderSize, bounds.Left + PushButtonWidth, bounds.Bottom - BorderSize);
g.DrawLine(SystemPens.ButtonFace, bounds.Left + PushButtonWidth + 1, BorderSize, bounds.Left + PushButtonWidth + 1, bounds.Bottom - BorderSize);
}
}
else
{
if (drawSplitLine && renderer == null)
{
// draw two lines at the edge of the dropdown button
g.DrawLine(SystemPens.ButtonShadow, bounds.Right - PushButtonWidth, BorderSize, bounds.Right - PushButtonWidth, bounds.Bottom - BorderSize);
g.DrawLine(SystemPens.ButtonFace, bounds.Right - PushButtonWidth - 1, BorderSize, bounds.Right - PushButtonWidth - 1, bounds.Bottom - BorderSize);
}
}
// Draw an arrow in the correct location
PaintArrow(g, dropDownRectangle, renderer == null ? SystemBrushes.ControlText : SystemBrushes.HighlightText);
// Paint as normal if we don't have a renderer
if (renderer == null)
{
// Figure out how to draw the text
TextFormatFlags formatFlags = TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter;
// If we dont' use mnemonic, set formatFlag to NoPrefix as this will show ampersand.
if (!UseMnemonic)
{
formatFlags = formatFlags | TextFormatFlags.NoPrefix;
}
else if (!ShowKeyboardCues)
{
formatFlags = formatFlags | TextFormatFlags.HidePrefix;
}
if (!string.IsNullOrEmpty(this.Text))
{
TextRenderer.DrawText(g, Text, Font, focusRect, SystemColors.ControlText, formatFlags);
}
// Draw the focus rectangle.
if (State != PushButtonState.Pressed && Focused)
{
ControlPaint.DrawFocusRectangle(g, focusRect);
}
}
}
/// <summary>
/// Primary function for painting the button. This method should be overridden instead of OnPaint.
/// </summary>
/// <param name="graphics">The graphics.</param>
/// <param name="bounds">The bounds.</param>
protected virtual void PaintButton(Graphics graphics, Rectangle bounds)
{
System.Diagnostics.Debug.WriteLine($"PaintButton: desMode:{this.IsDesignMode()};vsEnabled:{Application.RenderWithVisualStyles};vsOnOS:{VisualStyleInformation.IsSupportedByOS};btnState:{ButtonState};enabled:{Enabled};imgCt:{(ImageList != null ? ImageList.Images.Count : 0)}");
if (InitializeRenderer())
{
if (OnGlass)
{
rnd.DrawGlassBackground(graphics, bounds, bounds);
}
else
{
rnd.DrawParentBackground(graphics, bounds, this);
rnd.DrawBackground(graphics, bounds);
}
}
else
{
if (ImageList != null && ImageList.Images.Count > 0)
{
int idx = (int)ButtonState - 1;
if (ImageList.Images.Count == 1)
{
idx = 0;
}
else if (ImageList.Images.Count == 2)
{
idx = ButtonState == PushButtonState.Disabled ? 1 : 0;
}
else if (ImageList.Images.Count == 3)
{
idx = ButtonState == PushButtonState.Normal ? 0 : idx - 1;
}
bool forceDisabled = !Enabled && ImageList.Images.Count == 1;
if (OnGlass)
{
VisualStyleRendererExtension.DrawGlassImage(null, graphics, bounds, ImageList.Images[idx], forceDisabled);
}
else
{
if (!Application.RenderWithVisualStyles && VisualStyleInformation.IsSupportedByOS)
{
System.Drawing.Drawing2D.GraphicsContainer g = graphics.BeginContainer();
Rectangle translateRect = bounds;
graphics.TranslateTransform(-bounds.Left, -bounds.Top);
PaintEventArgs pe = new PaintEventArgs(graphics, translateRect);
InvokePaintBackground(Parent, pe);
InvokePaint(Parent, pe);
graphics.ResetTransform();
graphics.EndContainer(g);
}
else
{
graphics.Clear(Parent.BackColor);
}
if (forceDisabled)
{
ControlPaint.DrawImageDisabled(graphics, ImageList.Images[idx], 0, 0, Color.Transparent);
}
else
{
//base.ImageList.Draw(graphics, bounds.X, bounds.Y, bounds.Width, bounds.Height, idx);
//VisualStyleRendererExtender.DrawGlassImage(null, graphics, bounds, base.ImageList.Images[idx], forceDisabled); // Not 7
graphics.DrawImage(ImageList.Images[idx], bounds, bounds, GraphicsUnit.Pixel); // Works on XP, not 7, with Parent.BackColor
}
}
}
/*else if (this.ImageList != null && this.ImageList.Images.Count > 1)
* {
* int idx = (int)ButtonState - 1;
* if (this.ImageList.Images.Count == 2)
* idx = ButtonState == PushButtonState.Disabled ? 1 : 0;
* if (this.ImageList.Images.Count == 3)
* idx = ButtonState == PushButtonState.Normal ? 0 : idx - 1;
* if (rnd != null && !this.IsDesignMode() && DesktopWindowManager.IsCompositionEnabled())
* rnd.DrawGlassIcon(graphics, bounds, this.ImageList, idx);
* else
* this.ImageList.Draw(graphics, bounds.X, bounds.Y, bounds.Width, bounds.Height, idx);
* }*/
// No image so draw standard button
else
{
ButtonRenderer.DrawParentBackground(graphics, bounds, this);
ButtonRenderer.DrawButton(graphics, bounds, ButtonState);
}
}
if (Focused)
{
ControlPaint.DrawFocusRectangle(graphics, bounds);
}
}
protected override void OnPaint(PaintEventArgs args)
{
try
{
var tmpGraphics = args.Graphics;
if (tmpGraphics == null)
{
base.OnPaint(args); return;
}
int normPosition = position - minimum, normMaximum = maximum - minimum;
if (normMaximum <= 0)
{
normMaximum = 100;
System.Diagnostics.Debug.Assert(false);
}
if (normPosition < 0)
{
normPosition = 0;
System.Diagnostics.Debug.Assert(false);
}
if (normPosition > normMaximum)
{
normPosition = normMaximum;
}
Rectangle tmpDrawRectangle, tmpClientRectangle = this.ClientRectangle;
var tmpStyleElement = VisualStyleElement.ProgressBar.Bar.Normal;
if (VisualStyleRenderer.IsSupported && VisualStyleRenderer.IsElementDefined(tmpStyleElement))
{
var tmpStyleRenderer = new VisualStyleRenderer(tmpStyleElement);
if (tmpStyleRenderer.IsBackgroundPartiallyTransparent( ))
{
tmpStyleRenderer.DrawParentBackground(tmpGraphics, tmpClientRectangle, this);
}
tmpStyleRenderer.DrawBackground(tmpGraphics, tmpClientRectangle);
tmpDrawRectangle = tmpStyleRenderer.GetBackgroundContentRectangle(tmpGraphics, tmpClientRectangle);
}
else
{
tmpGraphics.FillRectangle(SystemBrushes.Control, tmpClientRectangle);
var tempGrayPen = System.Drawing.SystemPens.ControlDark;
var tmpWhitePen = System.Drawing.SystemPens.ControlLight;
tmpGraphics.DrawLine(tempGrayPen, 0, 0, tmpClientRectangle.Width - 1, 0);
tmpGraphics.DrawLine(tempGrayPen, 0, 0, 0, tmpClientRectangle.Height - 1);
tmpGraphics.DrawLine(tmpWhitePen, tmpClientRectangle.Width - 1, 0, tmpClientRectangle.Width - 1, tmpClientRectangle.Height - 1);
tmpGraphics.DrawLine(tmpWhitePen, 0, tmpClientRectangle.Height - 1, tmpClientRectangle.Width - 1, tmpClientRectangle.Height - 1);
tmpDrawRectangle = new Rectangle(tmpClientRectangle.X + 1, tmpClientRectangle.Y + 1, tmpClientRectangle.Width - 2, tmpClientRectangle.Height - 2);
}
int tmpDrawWidth = (int)((float)tmpDrawRectangle.Width * normPosition / normMaximum);
var tmpStartColor = this.qualityLowColor;
var tmpEndOfColor = this.qualityHighColor;
if (!this.Enabled)
{
tmpStartColor = HuiruiSoft.Utils.ColorUtils.ColorToGrayscale(SystemColors.ControlDark);
tmpEndOfColor = HuiruiSoft.Utils.ColorUtils.ColorToGrayscale(SystemColors.ControlLight);
}
bool tmpRightToLeft = (this.RightToLeft == RightToLeft.Yes);
if (tmpRightToLeft)
{
var tempColor = tmpStartColor; tmpStartColor = tmpEndOfColor; tmpEndOfColor = tempColor;
}
var tmpGradientBounds = new Rectangle(tmpDrawRectangle.X, tmpDrawRectangle.Y, tmpDrawRectangle.Width, tmpDrawRectangle.Height);
if (!HuiruiSoft.Utils.WindowsUtils.IsAtLeastWindowsVista)
{
tmpGradientBounds.Inflate(1, 0);
}
using (var tmpFillBrush = new LinearGradientBrush(tmpGradientBounds, tmpStartColor, tmpEndOfColor, LinearGradientMode.Horizontal))
{
tmpGraphics.FillRectangle(tmpFillBrush, tmpRightToLeft ? (tmpDrawRectangle.Width - tmpDrawWidth + 1) : tmpDrawRectangle.Left, tmpDrawRectangle.Top, tmpDrawWidth, tmpDrawRectangle.Height);
}
this.PaintText(tmpGraphics, tmpDrawRectangle, tmpRightToLeft);
}
catch (System.Exception)
{
System.Diagnostics.Debug.Assert(false);
}
}
public static void DrawCommandButton(
Graphics g,
PushButtonState state,
Rectangle rect,
Color backColor,
Control childControl)
{
VisualStyleElement element = null;
int alpha = 255;
if (OS.IsVistaOrLater)
{
const string className = "BUTTON";
const int partID = NativeConstants.BP_COMMANDLINK;
int stateID;
switch (state)
{
case PushButtonState.Default:
stateID = NativeConstants.CMDLS_DEFAULTED;
break;
case PushButtonState.Disabled:
stateID = NativeConstants.CMDLS_DISABLED;
break;
case PushButtonState.Hot:
stateID = NativeConstants.CMDLS_HOT;
break;
case PushButtonState.Normal:
stateID = NativeConstants.CMDLS_NORMAL;
break;
case PushButtonState.Pressed:
stateID = NativeConstants.CMDLS_PRESSED;
break;
default:
throw new InvalidEnumArgumentException();
}
try
{
element = VisualStyleElement.CreateElement(className, partID, stateID);
if (!VisualStyleRenderer.IsElementDefined(element))
{
element = null;
}
}
catch (InvalidOperationException)
{
element = null;
}
}
if (element == null)
{
switch (state)
{
case PushButtonState.Default:
element = VisualStyleElement.Button.PushButton.Default;
alpha = 95;
break;
case PushButtonState.Disabled:
element = VisualStyleElement.Button.PushButton.Disabled;
break;
case PushButtonState.Hot:
element = VisualStyleElement.Button.PushButton.Hot;
break;
case PushButtonState.Normal:
alpha = 0;
element = VisualStyleElement.Button.PushButton.Normal;
break;
case PushButtonState.Pressed:
element = VisualStyleElement.Button.PushButton.Pressed;
break;
default:
throw new InvalidEnumArgumentException();
}
}
if (element != null)
{
try
{
VisualStyleRenderer renderer = new VisualStyleRenderer(element);
renderer.DrawParentBackground(g, rect, childControl);
renderer.DrawBackground(g, rect);
}
catch (Exception)
{
element = null;
}
}
if (element == null)
{
ButtonRenderer.DrawButton(g, rect, state);
}
if (alpha != 255)
{
using (Brush backBrush = new SolidBrush(Color.FromArgb(255 - alpha, backColor)))
{
CompositingMode oldCM = g.CompositingMode;
try
{
g.CompositingMode = CompositingMode.SourceOver;
g.FillRectangle(backBrush, rect);
}
finally
{
g.CompositingMode = oldCM;
}
}
}
}
/// <summary>
/// Paints the control using the Buffered Paint API.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void bufferedPainter_PaintVisualState(object sender, BufferedPaintEventArgs<ComboBoxState> e)
{
if (_drawWithVisualStyles && _bufferedPainter.BufferedPaintSupported && _bufferedPainter.Enabled) {
// draw in the vista/win7 style
VisualStyleRenderer r = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal);
r.DrawParentBackground(e.Graphics, ClientRectangle, this);
Rectangle buttonBounds = ClientRectangle;
buttonBounds.Inflate(1, 1);
ButtonRenderer.DrawButton(e.Graphics, buttonBounds, GetPushButtonState(e.State));
Rectangle clipBounds = _dropDownButtonBounds;
clipBounds.Inflate(-2, -2);
e.Graphics.SetClip(clipBounds);
ComboBoxRenderer.DrawDropDownButton(e.Graphics, _dropDownButtonBounds, e.State);
e.Graphics.SetClip(ClientRectangle);
}
else if (_drawWithVisualStyles && ComboBoxRenderer.IsSupported) {
// draw using the visual style renderer
ComboBoxRenderer.DrawTextBox(e.Graphics, ClientRectangle, GetTextBoxState());
ComboBoxRenderer.DrawDropDownButton(e.Graphics, _dropDownButtonBounds, e.State);
}
else {
// draw using the legacy technique
DrawLegacyComboBox(e.Graphics, ClientRectangle, _dropDownButtonBounds, BackColor, GetPlainButtonState());
}
OnPaintContent(new DropDownPaintEventArgs(e.Graphics, ClientRectangle, GetTextBoxBounds()));
}