public static void DrawParentBackground (Graphics g, Rectangle bounds, Control childControl) { if (!VisualStyleRenderer.IsSupported) return; VisualStyleRenderer vsr = new VisualStyleRenderer (VisualStyleElement.Button.GroupBox.Normal); vsr.DrawParentBackground (g, bounds, childControl); }
/// <summary> /// Raises the <see cref="E:Paint"/> event. /// </summary> /// <param name="e"></param> protected override void OnPaint(PaintEventArgs e) { if (Application.RenderWithVisualStyles) { var renderer = new VisualStyleRenderer(VisualStyleElement.TextBox.TextEdit.Normal); renderer.DrawParentBackground(e.Graphics, ClientRectangle, this); } base.OnPaint(e); }
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); }
private void PaintNonClientRegion(ref Message m) { IntPtr handle = Handle; NativeMethods.RECT windowRect; NativeMethods.GetWindowRect(handle, out windowRect); windowRect = new NativeMethods.RECT( 0, 0, windowRect.Right - windowRect.Left, windowRect.Bottom - windowRect.Top); using (var deviceContext = new NativeMethods.DeviceContext(handle)) { var renderer = new VisualStyleRenderer( Enabled ? ReadOnly ? VisualStyleElement.TextBox.TextEdit.ReadOnly : VisualStyleElement.TextBox.TextEdit.Normal : VisualStyleElement.TextBox.TextEdit.Disabled); int clipResult = NativeMethods.ExcludeClipRect( deviceContext.GetHdc(), _borderRect.Left, _borderRect.Top, windowRect.Right - _borderRect.Right, windowRect.Bottom - _borderRect.Bottom); if (clipResult == NativeMethods.SIMPLEREGION || clipResult == NativeMethods.COMPLEXREGION) { if (renderer.IsBackgroundPartiallyTransparent()) renderer.DrawParentBackground(deviceContext, windowRect.ToRectangle(), this); renderer.DrawBackground(deviceContext, windowRect.ToRectangle()); } } m.Result = IntPtr.Zero; }
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); }
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 = Color.FromArgb(255, 128, 0); Color clrEnd = Color.FromArgb(0, 255, 0); 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); }
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> /// 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)); #if __MonoCS__ // Linux doesn't have the Marlett font, so use standard Unicode dingbats here. string arrowGlyph = (m_drawLeftArrowButton ? "\u25C4" : "\u25BA"); #else // In the Marlett font, '3' is the left arrow and '4' is the right. string arrowGlyph = (m_drawLeftArrowButton ? "3" : "4"); #endif Color clr = (Enabled ? SystemColors.ControlText : SystemColors.GrayText); TextRenderer.DrawText(e.Graphics, arrowGlyph, Font, rc, clr, m_txtFmtflags); }
/// <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); } } }
/// ------------------------------------------------------------------------------------ /// <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. var 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)); // In the Marlette font, '3' is the left arrow and '4' is the right. string arrowGlyph = (m_drawLeftArrowButton ? "3" : "4"); Color 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, FormatFlags); }
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> /// </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); } } }