public override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
if (!ThemeVisualStyles.RenderClientAreas)
{
base.OnRenderGrip(e);
return;
}
if (e.GripStyle == ToolStripGripStyle.Hidden)
{
return;
}
VisualStyleElement element = e.GripDisplayStyle == ToolStripGripDisplayStyle.Vertical ?
VisualStyleElement.Rebar.Gripper.Normal :
VisualStyleElement.Rebar.GripperVertical.Normal;
if (!VisualStyleRenderer.IsElementDefined(element))
{
base.OnRenderGrip(e);
return;
}
new VisualStyleRenderer(element).DrawBackground(e.Graphics, e.GripDisplayStyle == ToolStripGripDisplayStyle.Vertical ?
// GetPartSize seems to return useless values.
new Rectangle(2, 0, 5, 20) :
new Rectangle(0, 2, 20, 5));
}
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
if (renderGrip)
{
base.OnRenderGrip(e);
}
}
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
using (var brush = new SolidBrush(ColorTable.Grip))
{
var x = e.GripBounds.X + 1;
var y = e.GripBounds.Y + 2;
switch (e.GripDisplayStyle)
{
case ToolStripGripDisplayStyle.Horizontal:
x += 4;
while (x < e.GripBounds.Right - 4)
{
e.Graphics.FillRectangle(brush, new Rectangle(x, y, 2, 2));
x += 4;
}
break;
case ToolStripGripDisplayStyle.Vertical:
y += 4;
while (y < e.GripBounds.Bottom - 4)
{
e.Graphics.FillRectangle(brush, new Rectangle(x, y, 2, 2));
y += 4;
}
break;
}
}
}
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
LinearGradientMode lgm = default(LinearGradientMode);
Rectangle r = default(Rectangle);
if (e.GripDisplayStyle == ToolStripGripDisplayStyle.Horizontal)
{
lgm = LinearGradientMode.Vertical;
r = new Rectangle(e.GripBounds.Left + 2, e.GripBounds.Top, e.GripBounds.Width - 6, e.GripBounds.Height - 3);
}
else
{
lgm = LinearGradientMode.Horizontal;
r = new Rectangle(e.GripBounds.Left, e.GripBounds.Top + 2, e.GripBounds.Width - 3, e.GripBounds.Height - 6);
}
using (LinearGradientBrush lgb = new LinearGradientBrush(r, ScaleColorPct(this.m_color1, 80), ScaleColorPct(this.m_color2, 80), lgm))
{
e.Graphics.FillRectangle(lgb, r);
}
using (Pen p = new Pen(this.m_itemBorderColor))
{
e.Graphics.DrawRectangle(p, r);
}
}
public void ToolStripRenderer_OnRenderGrip_Invoke_Nop(ToolStripGripRenderEventArgs e)
{
var renderer = new SubToolStripRenderer();
int callCount = 0;
renderer.RenderGrip += (sender, e) => callCount++;
renderer.OnRenderGrip(e);
Assert.Equal(0, callCount);
}
// ---- METHODS (PROTECTED) ------------------------------------------------------------------------------------
/// <summary>
/// </summary>
/// <param name="e">A <see cref="ToolStripGripRenderEventArgs" /> that contains the event data.</param>
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
using (HatchBrush brush = new HatchBrush(HatchStyle.Percent20, ColorTable.GripDark, ColorTable.GripLight))
{
Rectangle patternRectangle = e.GripBounds;
patternRectangle.Inflate(2, -4);
e.Graphics.FillRectangle(brush, patternRectangle);
}
}
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
using (Pen pen = new Pen(AppearanceSettings.BorderColor))
{
pen.DashStyle = DashStyle.Dot;
e.Graphics.DrawLine(pen, e.GripBounds.X, e.GripBounds.Y + 5, e.GripBounds.X, e.GripBounds.Bottom - 7);
e.Graphics.DrawLine(pen, e.GripBounds.X + 2, e.GripBounds.Y + 5, e.GripBounds.X + 2, e.GripBounds.Bottom - 7);
}
}
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
Graphics g = e.Graphics;
using (Pen pen = new Pen(ToolStripBorderColor.Lighten(10))) {
//pen.DashStyle = DashStyle.Dot;
g.DrawLine(pen, e.GripBounds.X, e.GripBounds.Y + 1, e.GripBounds.X, e.GripBounds.Bottom);
g.DrawLine(pen, e.GripBounds.X + 2, e.GripBounds.Y + 1, e.GripBounds.X + 2, e.GripBounds.Bottom);
}
}
public void Ctor_Graphics_ToolStrip(Graphics g, ToolStrip toolStrip)
{
var e = new ToolStripGripRenderEventArgs(g, toolStrip);
Assert.Equal(g, e.Graphics);
Assert.Equal(toolStrip, e.ToolStrip);
Assert.Equal(new Rectangle(Point.Empty, toolStrip.Size), e.AffectedBounds);
Assert.Equal(toolStrip.GripRectangle, e.GripBounds);
Assert.Equal(toolStrip.GripDisplayStyle, e.GripDisplayStyle);
Assert.Equal(toolStrip.GripStyle, e.GripStyle);
}
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
if (currentRenderer != null)
{
currentRenderer.DrawGrip(e);
}
else
{
base.OnRenderGrip(e);
}
}
public void TestToolStripGripRenderEventArgs()
{
Graphics g = Graphics.FromImage(new Bitmap(5, 5));
ToolStrip ts = new ToolStrip();
ToolStripGripRenderEventArgs e = new ToolStripGripRenderEventArgs(g, ts);
Assert.AreEqual(new Rectangle(2, 0, 3, 25), e.GripBounds, "CCC1");
Assert.AreEqual(ToolStripGripDisplayStyle.Vertical, e.GripDisplayStyle, "CCC1");
Assert.AreEqual(ToolStripGripStyle.Visible, e.GripStyle, "CCC3");
Assert.AreEqual(g, e.Graphics, "CCC4");
Assert.AreEqual(ts, e.ToolStrip, "CCC5");
}
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
if (e.GripStyle == ToolStripGripStyle.Hidden)
{
return;
}
Graphics g = e.Graphics;
using Bitmap img = Properties.Resources.grip.SetColor(ThemeProvider.Theme.Colors.LightBorder);
g.DrawImageUnscaled(img, new Point(e.AffectedBounds.Left, e.AffectedBounds.Top));
}
/// <summary>
/// Used to render the toolstrip's grip handle.
/// </summary>
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
using (Pen linePen = new Pen(Color.FromArgb(98, 113, 140), 2))
{
linePen.DashPattern = new float[] { 1f, 1f };
// Top position is determined by the toolstrip's padding, the inner border and the grip's size,
// which we shorten by 8 pixels to make it more appealing.
Point gripStart = new Point(e.GripBounds.X, e.GripBounds.Y + e.ToolStrip.GripMargin.Top);
Point gripEnd = new Point(gripStart.X, e.GripBounds.Y + e.GripBounds.Height - e.ToolStrip.GripMargin.Bottom);
e.Graphics.DrawLine(linePen, gripStart, gripEnd);
}
}
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
if (e.GripStyle == ToolStripGripStyle.Hidden)
{
return;
}
var g = e.Graphics;
using (var img = MenuIcons.grip.SetColor(Colors.LightBorder))
{
g.DrawImage(img, new Point(e.AffectedBounds.Left, e.AffectedBounds.Top));
}
}
protected override void OnRenderGrip(
ToolStripGripRenderEventArgs e)
{
if (e.GripStyle == ToolStripGripStyle.Visible)
{
Rectangle bounds = e.GripBounds;
bool vert = e.GripDisplayStyle == ToolStripGripDisplayStyle.Vertical;
ToolStrip toolStrip = e.ToolStrip;
Graphics g = e.Graphics;
if (vert)
{
bounds.X = e.AffectedBounds.X;
bounds.Width = e.AffectedBounds.Width;
if (toolStrip is MenuStrip)
{
if (e.AffectedBounds.Height > e.AffectedBounds.Width)
{
vert = false;
bounds.Y = e.AffectedBounds.Y;
}
else
{
toolStrip.GripMargin = new Padding(0, 2, 0, 2);
bounds.Y = e.AffectedBounds.Y;
bounds.Height = e.AffectedBounds.Height;
}
}
else
{
toolStrip.GripMargin = new Padding(2, 2, 4, 2);
bounds.X++;
bounds.Width++;
}
}
else
{
bounds.Y = e.AffectedBounds.Y;
bounds.Height = e.AffectedBounds.Height;
}
DrawDottedGrip(
g,
bounds,
vert,
false,
ColorTable.BackNormal,
ControlPaint.Dark(ColorTable.Base, 0.3F));
}
}
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
const int GripSize = 5;
if (e.GripStyle != ToolStripGripStyle.Visible)
{
return;
}
var graphics = e.Graphics;
var client = e.GripBounds;
switch (e.GripDisplayStyle)
{
case ToolStripGripDisplayStyle.Horizontal:
client.Y += (client.Width - GripSize) / 2;
client.Height = 5;
break;
case ToolStripGripDisplayStyle.Vertical:
client.X += (client.Width - GripSize) / 2;
client.Width = 5;
break;
}
if (client.Width <= 0 || client.Height <= 0)
{
return;
}
using (var brush = new HatchBrush(HatchStyle.Percent20, ColorTable.Grip, ColorTable.ToolStripBackground))
{
var ro = default(Point);
try
{
ro = graphics.RenderingOrigin;
graphics.RenderingOrigin = new Point(client.X % 4, client.Y % 4);
}
catch (NotImplementedException)
{
}
graphics.FillRectangle(brush, client);
try
{
graphics.RenderingOrigin = ro;
}
catch (NotImplementedException)
{
}
}
}
public virtual void OnRenderGrip (ToolStripGripRenderEventArgs e)
{
if (e.GripStyle == ToolStripGripStyle.Hidden)
return;
if (e.GripDisplayStyle == ToolStripGripDisplayStyle.Vertical) {
e.Graphics.DrawLine (Pens.White, 0, 2, 1, 2);
e.Graphics.DrawLine (Pens.White, 0, 2, 0, e.GripBounds.Height - 3);
e.Graphics.DrawLine (SystemPens.ControlDark, 2, 2, 2, e.GripBounds.Height - 3);
e.Graphics.DrawLine (SystemPens.ControlDark, 2, e.GripBounds.Height - 3, 0, e.GripBounds.Height - 3);
}
else {
e.Graphics.DrawLine (Pens.White, 2, 0, e.GripBounds.Width - 3, 0);
e.Graphics.DrawLine (Pens.White, 2, 0, 2, 1);
e.Graphics.DrawLine (SystemPens.ControlDark, e.GripBounds.Width - 3, 0, e.GripBounds.Width - 3, 2);
e.Graphics.DrawLine (SystemPens.ControlDark, 2, 2, e.GripBounds.Width - 3, 2);
}
}
/// <summary>
/// Raises the <see cref="E:System.Windows.Forms.ToolStripRenderer.RenderGrip"/> event.
/// </summary>
/// <param name="e">A <see cref="T:System.Windows.Forms.ToolStripGripRenderEventArgs"/> that contains the event data.</param>
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
base.OnRenderGrip(e);
if (e.GripStyle == ToolStripGripStyle.Hidden)
{
return;
}
if (e.GripDisplayStyle == ToolStripGripDisplayStyle.Horizontal)
{
e.Graphics.DrawLine(Pens.White, new Point(e.AffectedBounds.Left, e.AffectedBounds.Top), new Point(e.AffectedBounds.Right, e.AffectedBounds.Top));
e.Graphics.DrawLine(Pens.White, new Point(e.AffectedBounds.Left, e.AffectedBounds.Top + 2), new Point(e.AffectedBounds.Right, e.AffectedBounds.Top + 2));
}
else
{
e.Graphics.DrawLine(Pens.White, new Point(e.AffectedBounds.Left, e.AffectedBounds.Top), new Point(e.AffectedBounds.Left, e.AffectedBounds.Bottom));
e.Graphics.DrawLine(Pens.White, new Point(e.AffectedBounds.Left + 2, e.AffectedBounds.Top), new Point(e.AffectedBounds.Left + 2, e.AffectedBounds.Bottom));
}
}
public void ToolStripRenderer_DrawGrip_Invoke_CallsRenderGrip(ToolStripGripRenderEventArgs eventArgs)
{
var renderer = new SubToolStripRenderer();
int callCount = 0;
ToolStripGripRenderEventHandler handler = (sender, e) =>
{
Assert.Same(renderer, sender);
Assert.Same(eventArgs, e);
callCount++;
};
// Call with handler.
renderer.RenderGrip += handler;
renderer.DrawGrip(eventArgs);
Assert.Equal(1, callCount);
// Remove handler.
renderer.RenderGrip -= handler;
renderer.DrawGrip(eventArgs);
Assert.Equal(1, callCount);
}
protected override void OnPaint(PaintEventArgs e)
{
try
{
using (var tempToolStrip = new ToolStrip())
{
Type t = typeof(ToolStrip).Assembly.GetType("System.Windows.Forms.ToolStripGrip");
var ctor = t.GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic)[0];
using (var fakeGrip = (ToolStripButton)ctor.Invoke(new object[] { }))
{
typeof(ToolStripItem).GetField("bounds", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(fakeGrip, e.ClipRectangle);
tempToolStrip.GetType().GetField("toolStripGrip", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(tempToolStrip, fakeGrip);
var args = new ToolStripGripRenderEventArgs(e.Graphics, tempToolStrip);
Owner.Renderer.DrawGrip(args);
}
}
}
catch
{
base.OnPaint(e);
}
}
public virtual void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
if (e.GripStyle == ToolStripGripStyle.Hidden)
{
return;
}
if (e.GripDisplayStyle == ToolStripGripDisplayStyle.Vertical)
{
e.Graphics.DrawLine(Pens.White, 0, 2, 1, 2);
e.Graphics.DrawLine(Pens.White, 0, 2, 0, e.GripBounds.Height - 3);
e.Graphics.DrawLine(SystemPens.ControlDark, 2, 2, 2, e.GripBounds.Height - 3);
e.Graphics.DrawLine(SystemPens.ControlDark, 2, e.GripBounds.Height - 3, 0, e.GripBounds.Height - 3);
}
else
{
e.Graphics.DrawLine(Pens.White, 2, 0, e.GripBounds.Width - 3, 0);
e.Graphics.DrawLine(Pens.White, 2, 0, 2, 1);
e.Graphics.DrawLine(SystemPens.ControlDark, e.GripBounds.Width - 3, 0, e.GripBounds.Width - 3, 2);
e.Graphics.DrawLine(SystemPens.ControlDark, 2, 2, e.GripBounds.Width - 3, 2);
}
}
public override void OnRenderGrip (ToolStripGripRenderEventArgs e)
{
if (!ThemeVisualStyles.RenderClientAreas) {
base.OnRenderGrip (e);
return;
}
if (e.GripStyle == ToolStripGripStyle.Hidden)
return;
VisualStyleElement element = e.GripDisplayStyle == ToolStripGripDisplayStyle.Vertical ?
VisualStyleElement.Rebar.Gripper.Normal :
VisualStyleElement.Rebar.GripperVertical.Normal;
if (!VisualStyleRenderer.IsElementDefined (element)) {
base.OnRenderGrip (e);
return;
}
new VisualStyleRenderer (element).DrawBackground (e.Graphics, e.GripDisplayStyle == ToolStripGripDisplayStyle.Vertical ?
// GetPartSize seems to return useless values.
new Rectangle (2, 0, 5, 20) :
new Rectangle (0, 2, 20, 5));
}
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
return;
}
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
this.renderer.DrawGrip(e);
}
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
var g = e.Graphics;
var bounds = e.GripBounds;
var toolStrip = e.ToolStrip;
var rightToLeft = e.ToolStrip.RightToLeft == RightToLeft.Yes;
var height = toolStrip.Orientation == Orientation.Horizontal ? bounds.Height : bounds.Width;
var width = toolStrip.Orientation == Orientation.Horizontal ? bounds.Width : bounds.Height;
var numRectangles = (height - GRIP_PADDING * 2) / 4;
if (numRectangles > 0)
{
numRectangles++;
// a MenuStrip starts its grip lower and has fewer grip rectangles.
var yOffset = toolStrip is MenuStrip ? 2 : 0;
var shadowRects = new Rectangle[numRectangles];
var startY = GRIP_PADDING + 1 + yOffset;
var startX = width / 2;
for (var i = 0; i < numRectangles; i++)
{
shadowRects[i] = toolStrip.Orientation == Orientation.Horizontal
? new Rectangle(startX, startY, 1, 1)
: new Rectangle(startY, startX, 1, 1);
startY += 4;
}
// in RTL the GripLight rects should paint to the left of the GripDark rects.
var xOffset = rightToLeft ? 2 : -2;
if (rightToLeft)
{
// scoot over the rects in RTL so they fit within the bounds.
for (var i = 0; i < numRectangles; i++)
{
shadowRects[i].Offset(-xOffset, 0);
}
}
Brush b = _gripBrush;
for (var i = 0; i < numRectangles - 1; i++)
{
g.FillRectangle(b, shadowRects[i]);
}
for (var i = 0; i < numRectangles; i++)
{
shadowRects[i].Offset(xOffset, -2);
}
g.FillRectangles(b, shadowRects);
for (var i = 0; i < numRectangles; i++)
{
shadowRects[i].Offset(-2 * xOffset, 0);
}
g.FillRectangles(b, shadowRects);
}
}
public new void OnRenderGrip(ToolStripGripRenderEventArgs e) => base.OnRenderGrip(e);
public void DrawGrip(ToolStripGripRenderEventArgs e)
{
}
// This method handles the RenderGrip event.
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
DrawTitleBar(
e.Graphics,
new Rectangle(0, 0, e.ToolStrip.Width, 7));
}
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
throw null;
}
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
Graphics g = e.Graphics;
Rectangle bounds = e.GripBounds;
ToolStrip toolStrip = e.ToolStrip;
bool rightToLeft = (e.ToolStrip.RightToLeft == RightToLeft.Yes);
int height = (toolStrip.Orientation == Orientation.Horizontal) ? bounds.Height : bounds.Width;
int width = (toolStrip.Orientation == Orientation.Horizontal) ? bounds.Width : bounds.Height;
int numRectangles = (height - (GRIP_PADDING * 2)) / 4;
if (numRectangles > 0)
{
numRectangles++;
// a MenuStrip starts its grip lower and has fewer grip rectangles.
int yOffset = (toolStrip is MenuStrip) ? 2 : 0;
Rectangle[] shadowRects = new Rectangle[numRectangles];
int startY = GRIP_PADDING + 1 + yOffset;
int startX = (width / 2);
for (int i = 0; i < numRectangles; i++)
{
shadowRects[i] = (toolStrip.Orientation == Orientation.Horizontal) ?
new Rectangle(startX, startY, 1, 1) :
new Rectangle(startY, startX, 1, 1);
startY += 4;
}
// in RTL the GripLight rects should paint to the left of the GripDark rects.
int xOffset = (rightToLeft) ? 2 : -2;
if (rightToLeft)
{
// scoot over the rects in RTL so they fit within the bounds.
for (int i = 0; i < numRectangles; i++)
{
shadowRects[i].Offset(-xOffset, 0);
}
}
Brush b = _gripBrush;
for (int i = 0; i < numRectangles - 1; i++)
{
g.FillRectangle(b, shadowRects[i]);
}
for (int i = 0; i < numRectangles; i++)
{
shadowRects[i].Offset(xOffset, -2);
}
g.FillRectangles(b, shadowRects);
for (int i = 0; i < numRectangles; i++)
{
shadowRects[i].Offset(-2 * xOffset, 0);
}
g.FillRectangles(b, shadowRects);
}
}
public void DrawGrip(ToolStripGripRenderEventArgs e)
{
}
/// <summary>
/// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed.
/// <example>
/// toolstripgriprendereventhandler.BeginInvoke(sender, e, callback);
/// </example>
/// </summary>
public static IAsyncResult BeginInvoke(this ToolStripGripRenderEventHandler toolstripgriprendereventhandler, Object sender, ToolStripGripRenderEventArgs e, AsyncCallback callback)
{
if (toolstripgriprendereventhandler == null)
{
throw new ArgumentNullException("toolstripgriprendereventhandler");
}
return(toolstripgriprendereventhandler.BeginInvoke(sender, e, callback, null));
}
protected override void OnRenderGrip(ToolStripGripRenderEventArgs e)
{
base.OnRenderGrip(e);
e.Graphics.DrawString("GRIP", SystemFonts.MenuFont, Brushes.Black, e.GripBounds);
}
