protected override void Draw(Graphics g)
{
if (points.Count > 2)
{
g.SmoothingMode = SmoothingMode.HighQuality;
if (Config.UseDimming)
{
using (Region region = new Region(regionFillPath))
{
g.Clip = region;
g.FillRectangle(lightBackgroundBrush, ScreenRectangle0Based);
g.ResetClip();
}
}
g.DrawPath(borderPen, regionFillPath);
g.DrawPath(borderDotPen, regionFillPath);
g.DrawLine(borderPen, points[points.Count - 1], points[0]);
g.DrawLine(borderDotPen, points[points.Count - 1], points[0]);
g.DrawRectangleProper(borderPen, currentArea);
}
base.Draw(g);
}
protected override void Draw(Graphics g)
{
if (points.Count > 2)
{
g.SmoothingMode = SmoothingMode.HighQuality;
borderDotPen.DashOffset = (float)timer.Elapsed.TotalSeconds * 10;
borderDotPen2.DashOffset = 5 + (float)timer.Elapsed.TotalSeconds * 10;
using (Region region = new Region(regionFillPath))
{
g.Clip = region;
g.FillRectangle(lightBackgroundBrush, ScreenRectangle0Based);
g.ResetClip();
}
g.DrawPath(borderDotPen, regionFillPath);
g.DrawPath(borderDotPen2, regionFillPath);
g.DrawLine(borderDotPen, points[points.Count - 1], points[0]);
g.DrawLine(borderDotPen2, points[points.Count - 1], points[0]);
g.DrawRectangleProper(borderPen, currentArea);
}
base.Draw(g);
}
protected override void Draw(Graphics g)
{
regionFillPath = new GraphicsPath();
for (int i = 0; i < nodes.Count - 1; i++)
{
regionFillPath.AddLine(nodes[i].Position, nodes[i + 1].Position);
}
if (nodes.Count > 2)
{
regionFillPath.CloseFigure();
using (Region region = new Region(regionFillPath))
{
g.ExcludeClip(region);
g.FillRectangle(shadowBrush, 0, 0, Width, Height);
g.ResetClip();
}
g.DrawRectangleProper(borderPen, currentArea);
}
else
{
g.FillRectangle(shadowBrush, 0, 0, Width, Height);
}
if (nodes.Count > 1)
{
g.DrawPath(borderPen, regionFillPath);
}
base.Draw(g);
}
protected override void Draw(Graphics g)
{
g.SmoothingMode = SmoothingMode.HighQuality;
regionFillPath = new GraphicsPath();
for (int i = 0; i < nodes.Count - 1; i++)
{
regionFillPath.AddLine(nodes[i].Position, nodes[i + 1].Position);
}
if (nodes.Count > 2)
{
regionFillPath.CloseFigure();
using (Region region = new Region(regionFillPath))
{
g.Clip = region;
g.FillRectangle(lightBackgroundBrush, ScreenRectangle0Based);
g.ResetClip();
}
g.DrawRectangleProper(borderPen, currentArea);
}
if (nodes.Count > 1)
{
g.DrawPath(borderPen, regionFillPath);
g.DrawPath(borderDotPen, regionFillPath);
}
base.Draw(g);
}
public override void OnDraw(Graphics g)
{
if (FillColor.A > 0)
{
using (Brush brush = new SolidBrush(FillColor))
{
g.FillRectangle(brush, Rectangle);
}
}
if (BorderSize > 0 && BorderColor.A > 0)
{
Rectangle rect = Rectangle.Offset(BorderSize - 1);
using (Pen pen = new Pen(BorderColor, BorderSize) { Alignment = PenAlignment.Inset })
{
g.DrawRectangleProper(pen, rect);
}
}
}
protected override void Draw(Graphics g)
{
if (points.Count > 2)
{
using (Region region = new Region(regionFillPath))
{
g.ExcludeClip(region);
g.FillRectangle(shadowBrush, 0, 0, Width, Height);
g.ResetClip();
}
g.DrawPath(borderPen, regionFillPath);
g.DrawLine(borderPen, points[0], points[points.Count - 1]);
g.DrawRectangleProper(borderPen, currentArea);
}
else
{
g.FillRectangle(shadowBrush, 0, 0, Width, Height);
}
base.Draw(g);
}
private void DrawCursorGraphics(Graphics g)
{
Point mousePos = InputManager.MousePosition0Based;
Rectangle currentScreenRect0Based = CaptureHelpers.GetActiveScreenBounds0Based();
int cursorOffsetX = 10, cursorOffsetY = 10, itemGap = 10, itemCount = 0;
Size totalSize = Size.Empty;
int magnifierPosition = 0;
Bitmap magnifier = null;
if (Config.ShowMagnifier)
{
if (itemCount > 0) totalSize.Height += itemGap;
magnifierPosition = totalSize.Height;
magnifier = Magnifier(backgroundImage, mousePos, Config.MagnifierPixelCount, Config.MagnifierPixelCount, Config.MagnifierPixelSize);
totalSize.Width = Math.Max(totalSize.Width, magnifier.Width);
totalSize.Height += magnifier.Height;
itemCount++;
}
int infoTextPadding = 3;
int infoTextPosition = 0;
Rectangle infoTextRect = Rectangle.Empty;
string infoText = "";
if (Config.ShowInfo)
{
if (itemCount > 0) totalSize.Height += itemGap;
infoTextPosition = totalSize.Height;
CurrentPosition = InputManager.MousePosition;
infoText = GetInfoText();
Size textSize = g.MeasureString(infoText, infoFont).ToSize();
infoTextRect.Size = new Size(textSize.Width + infoTextPadding * 2, textSize.Height + infoTextPadding * 2);
totalSize.Width = Math.Max(totalSize.Width, infoTextRect.Width);
totalSize.Height += infoTextRect.Height;
itemCount++;
}
int x = mousePos.X + cursorOffsetX;
if (x + totalSize.Width > currentScreenRect0Based.Right)
{
x = mousePos.X - cursorOffsetX - totalSize.Width;
}
int y = mousePos.Y + cursorOffsetY;
if (y + totalSize.Height > currentScreenRect0Based.Bottom)
{
y = mousePos.Y - cursorOffsetY - totalSize.Height;
}
if (Config.ShowMagnifier)
{
using (GraphicsQualityManager quality = new GraphicsQualityManager(g))
using (TextureBrush brush = new TextureBrush(magnifier))
{
brush.TranslateTransform(x, y + magnifierPosition);
if (Config.UseSquareMagnifier)
{
g.FillRectangle(brush, x, y + magnifierPosition, magnifier.Width, magnifier.Height);
g.DrawRectangleProper(Pens.White, x - 1, y + magnifierPosition - 1, magnifier.Width + 2, magnifier.Height + 2);
g.DrawRectangleProper(Pens.Black, x, y + magnifierPosition, magnifier.Width, magnifier.Height);
}
else
{
g.FillEllipse(brush, x, y + magnifierPosition, magnifier.Width, magnifier.Height);
g.DrawEllipse(Pens.White, x - 1, y + magnifierPosition - 1, magnifier.Width + 2, magnifier.Height + 2);
g.DrawEllipse(Pens.Black, x, y + magnifierPosition, magnifier.Width, magnifier.Height);
}
}
}
if (Config.ShowInfo)
{
infoTextRect.Location = new Point(x + (totalSize.Width / 2) - (infoTextRect.Width / 2), y + infoTextPosition);
DrawInfoText(g, infoText, infoTextRect, infoFont, infoTextPadding);
}
}
protected override void Draw(Graphics g)
{
// Draw snap rectangles
if (ShapeManager.IsCreating && ShapeManager.IsSnapResizing)
{
BaseShape shape = ShapeManager.CurrentShape;
if (shape != null)
{
foreach (Size size in Config.SnapSizes)
{
Rectangle snapRect = CaptureHelpers.CalculateNewRectangle(shape.StartPosition, shape.EndPosition, size);
g.DrawRectangleProper(markerPen, snapRect);
}
}
}
List<BaseShape> areas = ShapeManager.ValidRegions.ToList();
if (areas.Count > 0)
{
// Create graphics path from all regions
UpdateRegionPath();
// If background is dimmed then draw non dimmed background to region selections
if (Config.UseDimming)
{
using (Region region = new Region(regionDrawPath))
{
g.Clip = region;
g.FillRectangle(lightBackgroundBrush, ScreenRectangle0Based);
g.ResetClip();
}
}
// Blink borders of all regions slightly to make non active regions to be visible in both dark and light backgrounds
using (Pen blinkBorderPen = new Pen(colorBlinkAnimation.GetColor()))
{
g.DrawPath(blinkBorderPen, regionDrawPath);
}
}
// Draw effect shapes
foreach (BaseEffectShape effectShape in ShapeManager.EffectShapes)
{
effectShape.OnDraw(g);
}
ShapeManager.OrderStepShapes();
// Draw drawing shapes
foreach (BaseDrawingShape drawingShape in ShapeManager.DrawingShapes)
{
drawingShape.OnDraw(g);
}
// Draw animated rectangle on hover area
if (ShapeManager.IsCurrentHoverAreaValid)
{
using (GraphicsPath hoverDrawPath = new GraphicsPath { FillMode = FillMode.Winding })
{
ShapeManager.CreateShape(ShapeManager.CurrentHoverRectangle).AddShapePath(hoverDrawPath, -1);
g.DrawPath(borderPen, hoverDrawPath);
g.DrawPath(borderDotPen, hoverDrawPath);
}
}
// Draw animated rectangle on selection area
if (ShapeManager.IsCurrentShapeTypeRegion && ShapeManager.IsCurrentRectangleValid)
{
g.DrawRectangleProper(borderPen, ShapeManager.CurrentRectangle);
g.DrawRectangleProper(borderDotPen, ShapeManager.CurrentRectangle);
if (Mode == RectangleRegionMode.Ruler)
{
DrawRuler(g, ShapeManager.CurrentRectangle, borderPen, 5, 10);
DrawRuler(g, ShapeManager.CurrentRectangle, borderPen, 15, 100);
Point centerPos = new Point(ShapeManager.CurrentRectangle.X + ShapeManager.CurrentRectangle.Width / 2, ShapeManager.CurrentRectangle.Y + ShapeManager.CurrentRectangle.Height / 2);
int markSize = 10;
g.DrawLine(borderPen, centerPos.X, centerPos.Y - markSize, centerPos.X, centerPos.Y + markSize);
g.DrawLine(borderPen, centerPos.X - markSize, centerPos.Y, centerPos.X + markSize, centerPos.Y);
}
}
// Draw all regions rectangle info
if (Config.ShowInfo)
{
// Add hover area to list so rectangle info can be shown
if (ShapeManager.IsCurrentShapeTypeRegion && ShapeManager.IsCurrentHoverAreaValid && areas.All(area => area.Rectangle != ShapeManager.CurrentHoverRectangle))
{
BaseShape shape = ShapeManager.CreateShape(ShapeManager.CurrentHoverRectangle);
areas.Add(shape);
}
foreach (BaseShape regionInfo in areas)
{
if (regionInfo.Rectangle.IsValid())
{
string areaText = GetAreaText(regionInfo.Rectangle);
DrawAreaText(g, areaText, regionInfo.Rectangle);
}
}
}
// Draw resize nodes
DrawObjects(g);
// Draw F1 tips
if (Config.ShowTips)
{
DrawTips(g);
}
if (Mode == RectangleRegionMode.Annotation)
{
if (Config.ShowMenuTip)
{
// Draw right click menu tip
DrawMenuTip(g);
}
else
{
// If current shape changed then draw it temporary
DrawCurrentShapeText(g);
}
}
// Draw magnifier
if (Config.ShowMagnifier || Config.ShowInfo)
{
DrawCursorGraphics(g);
}
// Draw screen wide crosshair
if (Config.ShowCrosshair)
{
DrawCrosshair(g);
}
}
public override void OnDraw(Graphics g)
{
if (Rectangle.Width > 10 && Rectangle.Height > 10)
{
GraphicsPath gpTail = null;
if (TailVisible)
{
gpTail = CreateTailPath();
}
if (FillColor.A > 0)
{
using (Brush brush = new SolidBrush(FillColor))
{
g.FillRectangle(brush, Rectangle);
}
}
if (gpTail != null)
{
g.SmoothingMode = SmoothingMode.HighQuality;
if (FillColor.A > 0)
{
g.ExcludeClip(Rectangle);
using (Brush brush = new SolidBrush(FillColor))
{
g.FillPath(brush, gpTail);
}
g.ResetClip();
}
if (BorderSize > 0 && BorderColor.A > 0)
{
g.ExcludeClip(Rectangle.Offset(-1));
using (Pen pen = new Pen(BorderColor, BorderSize))
{
g.DrawPath(pen, gpTail);
}
g.ResetClip();
}
g.SmoothingMode = SmoothingMode.None;
}
if (BorderSize > 0 && BorderColor.A > 0)
{
if (gpTail != null)
{
using (Region region = new Region(gpTail))
{
g.ExcludeClip(region);
}
}
Rectangle rect = Rectangle.Offset(BorderSize - 1);
using (Pen pen = new Pen(BorderColor, BorderSize) { Alignment = PenAlignment.Inset })
{
g.DrawRectangleProper(pen, rect);
}
g.ResetClip();
}
if (gpTail != null)
{
gpTail.Dispose();
}
DrawText(g);
}
}
private void DrawRectangle(Graphics g)
{
using (Pen pen = new Pen(Options.DrawingPenColor, Options.DrawingRectangleBorderSize) { Alignment = PenAlignment.Inset })
{
g.DrawRectangleProper(pen, SelectionRectangle.Offset(Options.DrawingRectangleBorderSize - 1));
}
}
private void DrawCrosshair(Graphics g, Pen pen, int offset, int height)
{
g.DrawRectangleProper(pen, new Rectangle(offset, lastPos.Y - height / 2, clientWidth - offset * 2, height));
}
protected override void Draw(Graphics g)
{
List<Rectangle> areas = AreaManager.GetValidAreas;
if (areas.Count > 0 || !AreaManager.CurrentHoverArea.IsEmpty)
{
UpdateRegionPath();
using (Region region = new Region(regionFillPath))
{
g.ExcludeClip(region);
g.FillRectangle(shadowBrush, 0, 0, Width, Height);
g.ResetClip();
}
/*foreach (WindowInfo wi in AreaManager.Windows)
{
g.DrawRectangleProper(Pens.Yellow, Rectangle.Intersect(ScreenRectangle0Based, wi.Rectangle0Based));
}*/
borderDotPen.DashOffset = (float)timer.Elapsed.TotalSeconds * 10;
borderDotPen2.DashOffset = 5 + (float)timer.Elapsed.TotalSeconds * 10;
g.DrawPath(borderPen, regionDrawPath);
if (areas.Count > 1)
{
Rectangle totalArea = AreaManager.CombineAreas();
g.DrawCrossRectangle(borderPen, totalArea, 15);
CaptureHelpers.DrawTextWithOutline(g, string.Format("X:{0}, Y:{1}, Width:{2}, Height:{3}", totalArea.X, totalArea.Y,
totalArea.Width, totalArea.Height), new PointF(totalArea.X + 5, totalArea.Y - 20), textFont, Color.White, Color.Black);
}
if (AreaManager.IsCurrentHoverAreaValid)
{
GraphicsPath hoverFillPath = new GraphicsPath() { FillMode = FillMode.Winding };
AddShapePath(hoverFillPath, AreaManager.CurrentHoverArea);
g.FillPath(lightBrush, hoverFillPath);
GraphicsPath hoverDrawPath = new GraphicsPath() { FillMode = FillMode.Winding };
AddShapePath(hoverDrawPath, AreaManager.CurrentHoverArea.SizeOffset(-1));
g.DrawPath(borderDotPen, hoverDrawPath);
g.DrawPath(borderDotPen2, hoverDrawPath);
}
if (AreaManager.IsCurrentAreaValid)
{
g.DrawRectangleProper(borderDotPen, AreaManager.CurrentArea);
g.DrawRectangleProper(borderDotPen2, AreaManager.CurrentArea);
g.ExcludeClip(AreaManager.CurrentArea);
DrawObjects(g);
g.ResetClip();
}
foreach (Rectangle area in areas)
{
if (area.Width > 100 && area.Height > 20)
{
g.Clip = new Region(area);
CaptureHelpers.DrawTextWithOutline(g, string.Format("X:{0}, Y:{1}, Width:{2}, Height:{3}", area.X, area.Y, area.Width, area.Height),
new PointF(area.X + 5, area.Y + 5), textFont, Color.White, Color.Black);
}
}
}
else
{
g.FillRectangle(shadowBrush, 0, 0, Width, Height);
}
}
protected override void Draw(Graphics g)
{
borderDotPen2.DashOffset = (float)timer.Elapsed.TotalSeconds * 10;
List<Rectangle> areas = AreaManager.GetValidAreas;
if (areas.Count > 0 || !AreaManager.CurrentHoverArea.IsEmpty)
{
UpdateRegionPath();
if (areas.Count > 0)
{
using (Region region = new Region(regionDrawPath))
{
g.Clip = region;
g.FillRectangle(lightBackgroundBrush, ScreenRectangle0Based);
g.ResetClip();
}
g.DrawPath(borderPen, regionDrawPath);
if (areas.Count > 1)
{
Rectangle totalArea = AreaManager.CombineAreas();
g.DrawCrossRectangle(borderPen, totalArea, 15);
if (Config.ShowInfo)
{
ImageHelpers.DrawTextWithOutline(g, string.Format("X: {0} / Y: {1} / W: {2} / H: {3}", totalArea.X, totalArea.Y,
totalArea.Width, totalArea.Height), new PointF(totalArea.X + 5, totalArea.Y - 25), textFont, Color.White, Color.Black);
}
}
}
if (AreaManager.IsCurrentHoverAreaValid)
{
using (GraphicsPath hoverDrawPath = new GraphicsPath { FillMode = FillMode.Winding })
{
AddShapePath(hoverDrawPath, AreaManager.CurrentHoverArea.SizeOffset(-1));
g.DrawPath(borderDotPen, hoverDrawPath);
g.DrawPath(borderDotPen2, hoverDrawPath);
}
}
if (AreaManager.IsCurrentAreaValid)
{
g.DrawRectangleProper(borderDotPen, AreaManager.CurrentArea);
g.DrawRectangleProper(borderDotPen2, AreaManager.CurrentArea);
DrawObjects(g);
if (RulerMode)
{
DrawRuler(g, AreaManager.CurrentArea, borderPen, 5, 10);
DrawRuler(g, AreaManager.CurrentArea, borderPen, 15, 100);
Point centerPos = new Point(AreaManager.CurrentArea.X + AreaManager.CurrentArea.Width / 2, AreaManager.CurrentArea.Y + AreaManager.CurrentArea.Height / 2);
int markSize = 10;
g.DrawLine(borderPen, centerPos.X, centerPos.Y - markSize, centerPos.X, centerPos.Y + markSize);
g.DrawLine(borderPen, centerPos.X - markSize, centerPos.Y, centerPos.X + markSize, centerPos.Y);
}
}
if (Config.ShowInfo)
{
foreach (Rectangle area in areas)
{
if (area.IsValid())
{
string areaText;
if (RulerMode)
{
Point endPos = new Point(area.X + area.Width - 1, area.Y + area.Height - 1);
areaText = string.Format("X: {0} / Y: {1} / X2: {2} / Y2: {3}\nWidth: {4} px / Height: {5} px\nDistance: {6:0.00} px / Angle: {7:0.00}°", area.X, area.Y, endPos.X, endPos.Y,
area.Width, area.Height, MathHelpers.Distance(area.Location, endPos), MathHelpers.LookAtDegree(area.Location, endPos));
ImageHelpers.DrawTextWithOutline(g, areaText, new PointF(area.X + 15, area.Y + 15), textFont, Color.White, Color.Black);
}
else
{
areaText = string.Format("X: {0} / Y: {1}\nW: {2} / H: {3}", area.X, area.Y, area.Width, area.Height);
ImageHelpers.DrawTextWithOutline(g, areaText, new PointF(area.X + 5, area.Y + 5), textFont, Color.White, Color.Black);
}
}
}
}
}
if (Config.ShowMagnifier)
{
DrawMagnifier(g);
}
if (Config.ShowCrosshair)
{
DrawCrosshair(g);
}
}
private void DrawMagnifier(Graphics g)
{
Point mousePos = InputManager.MousePosition0Based;
Rectangle currentScreenRect0Based = CaptureHelpers.ScreenToClient(Screen.FromPoint(InputManager.MousePosition).Bounds);
int offsetX = 10, offsetY = 10, infoTextOffset = 0, infoTextPadding = 3;
Rectangle infoTextRect = Rectangle.Empty;
string infoText = string.Empty;
if (Config.ShowInfo)
{
infoTextOffset = 10;
CurrentPosition = InputManager.MousePosition;
infoText = GetInfoText();
Size textSize = g.MeasureString(infoText, infoFont).ToSize();
infoTextRect.Size = new Size(textSize.Width + infoTextPadding * 2, textSize.Height + infoTextPadding * 2);
}
using (Bitmap magnifier = Magnifier(SurfaceImage, mousePos, Config.MagnifierPixelCount, Config.MagnifierPixelCount, Config.MagnifierPixelSize))
{
int x = mousePos.X + offsetX;
if (x + magnifier.Width > currentScreenRect0Based.Right)
{
x = mousePos.X - offsetX - magnifier.Width;
}
int y = mousePos.Y + offsetY;
if (y + magnifier.Height + infoTextOffset + infoTextRect.Height > currentScreenRect0Based.Bottom)
{
y = mousePos.Y - offsetY - magnifier.Height - infoTextOffset - infoTextRect.Height;
}
if (Config.ShowInfo)
{
infoTextRect.Location = new Point(x + (magnifier.Width / 2) - (infoTextRect.Width / 2), y + magnifier.Height + infoTextOffset);
DrawInfoText(g, infoText, infoTextRect, 3);
}
g.SetHighQuality();
using (TextureBrush brush = new TextureBrush(magnifier))
{
brush.TranslateTransform(x, y);
if (Config.UseSquareMagnifier)
{
g.FillRectangle(brush, x, y, magnifier.Width, magnifier.Height);
g.DrawRectangleProper(Pens.White, x - 1, y - 1, magnifier.Width + 2, magnifier.Height + 2);
g.DrawRectangleProper(Pens.Black, x, y, magnifier.Width, magnifier.Height);
}
else
{
g.FillEllipse(brush, x, y, magnifier.Width, magnifier.Height);
g.DrawEllipse(Pens.White, x - 1, y - 1, magnifier.Width + 2, magnifier.Height + 2);
g.DrawEllipse(Pens.Black, x, y, magnifier.Width, magnifier.Height);
}
}
}
}
protected override void Draw(Graphics g)
{
if (AreaManager.IsCreating && AreaManager.IsSnapResizing)
{
foreach (Size size in Config.SnapSizes)
{
Rectangle snapRect = CaptureHelpers.CalculateNewRectangle(AreaManager.PositionOnClick, AreaManager.CurrentPosition, size);
g.DrawRectangleProper(markerPen, snapRect);
}
}
List<RegionInfo> areas = AreaManager.ValidAreas.ToList();
bool drawAreaExist = areas.Count > 0;
if (AreaManager.IsCurrentHoverAreaValid && areas.All(area => area.Area != AreaManager.CurrentHoverArea))
{
areas.Add(AreaManager.GetRegionInfo(AreaManager.CurrentHoverArea));
}
if (areas.Count > 0)
{
UpdateRegionPath();
if (drawAreaExist)
{
if (Config.UseDimming)
{
using (Region region = new Region(regionDrawPath))
{
g.Clip = region;
g.FillRectangle(lightBackgroundBrush, ScreenRectangle0Based);
g.ResetClip();
}
}
using (Pen blinkBorderPen = new Pen(colorBlinkAnimation.GetColor()))
{
g.DrawPath(blinkBorderPen, regionDrawPath);
}
/*
if (areas.Count > 1)
{
Rectangle totalArea = AreaManager.CombineAreas();
g.DrawCrossRectangle(borderPen, totalArea, 15);
if (Config.ShowInfo)
{
ImageHelpers.DrawTextWithOutline(g, string.Format("X: {0} / Y: {1} / W: {2} / H: {3}", totalArea.X, totalArea.Y,
totalArea.Width, totalArea.Height), new PointF(totalArea.X + 5, totalArea.Y - 25), textFont, Color.White, Color.Black);
}
}
*/
}
if (AreaManager.IsCurrentHoverAreaValid)
{
using (GraphicsPath hoverDrawPath = new GraphicsPath { FillMode = FillMode.Winding })
{
AddShapePath(hoverDrawPath, AreaManager.GetRegionInfo(AreaManager.CurrentHoverArea), -1);
g.DrawPath(borderPen, hoverDrawPath);
g.DrawPath(borderDotPen, hoverDrawPath);
}
}
if (AreaManager.IsCurrentAreaValid)
{
g.DrawRectangleProper(borderPen, AreaManager.CurrentArea);
g.DrawRectangleProper(borderDotPen, AreaManager.CurrentArea);
DrawObjects(g);
if (RulerMode)
{
DrawRuler(g, AreaManager.CurrentArea, borderPen, 5, 10);
DrawRuler(g, AreaManager.CurrentArea, borderPen, 15, 100);
Point centerPos = new Point(AreaManager.CurrentArea.X + AreaManager.CurrentArea.Width / 2, AreaManager.CurrentArea.Y + AreaManager.CurrentArea.Height / 2);
int markSize = 10;
g.DrawLine(borderPen, centerPos.X, centerPos.Y - markSize, centerPos.X, centerPos.Y + markSize);
g.DrawLine(borderPen, centerPos.X - markSize, centerPos.Y, centerPos.X + markSize, centerPos.Y);
}
}
if (Config.ShowInfo)
{
foreach (RegionInfo regionInfo in areas)
{
if (regionInfo.Area.IsValid())
{
string areaText = GetAreaText(regionInfo.Area);
DrawAreaText(g, areaText, regionInfo.Area);
}
}
}
}
if (Config.ShowTips)
{
DrawTips(g, 10, 10);
}
if (Config.ShowMagnifier)
{
DrawMagnifier(g);
}
if (Config.ShowCrosshair)
{
DrawCrosshair(g);
}
}
private void DrawInfoText(Graphics g, string text, Rectangle rect, Font font, int padding,
Brush backgroundBrush, Pen outerBorderPen, Pen innerBorderPen, Brush textBrush, Brush textShadowBrush)
{
g.FillRectangle(backgroundBrush, rect.Offset(-2));
g.DrawRectangleProper(innerBorderPen, rect.Offset(-1));
g.DrawRectangleProper(outerBorderPen, rect);
ImageHelpers.DrawTextWithShadow(g, text, rect.Offset(-padding).Location, font, textBrush, textShadowBrush);
}
public static void DrawColorPickerIcon(Graphics g, Color color, Rectangle rect, int holeSize = 0)
{
if (color.A < 255)
{
using (Image checker = CreateCheckers(rect.Width / 2, rect.Height / 2, Color.LightGray, Color.White))
{
g.DrawImage(checker, rect);
}
}
using (SolidBrush brush = new SolidBrush(color))
{
g.FillRectangle(brush, rect);
}
g.DrawRectangleProper(Pens.Black, rect);
if (holeSize > 0)
{
g.CompositingMode = CompositingMode.SourceCopy;
Rectangle holeRect = new Rectangle(rect.Width / 2 - holeSize / 2, rect.Height / 2 - holeSize / 2, holeSize, holeSize);
g.FillRectangle(Brushes.Transparent, holeRect);
g.DrawRectangleProper(Pens.Black, holeRect);
}
}
private void DrawScreenColorPickerInfo(Graphics g)
{
CurrentPosition = InputManager.MousePosition0Based;
if (Config.ShowInfo)
{
Color color = CurrentColor;
using (Brush brush = new SolidBrush(color))
{
Rectangle colorBox = new Rectangle(CurrentPosition.X + 5, CurrentPosition.Y + 5, 20, 20);
g.FillRectangle(brush, colorBox);
g.DrawRectangleProper(Pens.Black, colorBox);
}
string infoText = string.Format(Resources.RectangleRegion_GetColorPickerText, color.R, color.G, color.B, ColorHelpers.ColorToHex(color),
CurrentPosition.X, CurrentPosition.Y);
ImageHelpers.DrawTextWithOutline(g, infoText, new PointF(CurrentPosition.X + 25, CurrentPosition.Y + 5), textFont, Color.White, Color.Black);
}
}
protected override void Draw(Graphics g)
{
RegionInfo[] areas = AreaManager.ValidAreas;
if (areas.Length > 0 || !AreaManager.CurrentHoverArea.IsEmpty)
{
UpdateRegionPath();
if (areas.Length > 0)
{
if (Config.UseDimming)
{
using (Region region = new Region(regionDrawPath))
{
g.Clip = region;
g.FillRectangle(lightBackgroundBrush, ScreenRectangle0Based);
g.ResetClip();
}
}
g.DrawPath(borderPen, regionDrawPath);
/*
if (areas.Count > 1)
{
Rectangle totalArea = AreaManager.CombineAreas();
g.DrawCrossRectangle(borderPen, totalArea, 15);
if (Config.ShowInfo)
{
ImageHelpers.DrawTextWithOutline(g, string.Format("X: {0} / Y: {1} / W: {2} / H: {3}", totalArea.X, totalArea.Y,
totalArea.Width, totalArea.Height), new PointF(totalArea.X + 5, totalArea.Y - 25), textFont, Color.White, Color.Black);
}
}
*/
}
if (AreaManager.IsCurrentHoverAreaValid)
{
using (GraphicsPath hoverDrawPath = new GraphicsPath { FillMode = FillMode.Winding })
{
AddShapePath(hoverDrawPath, AreaManager.GetRegionInfo(AreaManager.CurrentHoverArea), -1);
g.DrawPath(borderPen, hoverDrawPath);
g.DrawPath(borderDotPen, hoverDrawPath);
}
}
if (AreaManager.IsCurrentAreaValid)
{
g.DrawRectangleProper(borderPen, AreaManager.CurrentArea);
g.DrawRectangleProper(borderDotPen, AreaManager.CurrentArea);
DrawObjects(g);
if (RulerMode)
{
DrawRuler(g, AreaManager.CurrentArea, borderPen, 5, 10);
DrawRuler(g, AreaManager.CurrentArea, borderPen, 15, 100);
Point centerPos = new Point(AreaManager.CurrentArea.X + AreaManager.CurrentArea.Width / 2, AreaManager.CurrentArea.Y + AreaManager.CurrentArea.Height / 2);
int markSize = 10;
g.DrawLine(borderPen, centerPos.X, centerPos.Y - markSize, centerPos.X, centerPos.Y + markSize);
g.DrawLine(borderPen, centerPos.X - markSize, centerPos.Y, centerPos.X + markSize, centerPos.Y);
}
}
if (Config.ShowInfo)
{
foreach (RegionInfo regionInfo in areas)
{
if (regionInfo.Area.IsValid())
{
string areaText = GetAreaText(regionInfo.Area);
DrawAreaText(g, areaText, regionInfo.Area);
}
}
}
}
if (Config.ShowTips)
{
DrawTips(g, 10, 10);
}
if (Config.ShowMagnifier)
{
DrawMagnifier(g);
}
if (Config.ShowCrosshair)
{
DrawCrosshair(g);
}
}
protected void DrawSpeechBalloon(Graphics g, Color borderColor, int borderSize, Color fillColor, Rectangle rect, Point tailPosition)
{
GraphicsPath gpTail = null;
if (TailVisible)
{
gpTail = CreateTailPath(rect, tailPosition);
}
if (fillColor.A > 0)
{
using (Brush brush = new SolidBrush(fillColor))
{
g.FillRectangle(brush, rect);
}
}
if (gpTail != null)
{
g.SmoothingMode = SmoothingMode.HighQuality;
if (fillColor.A > 0)
{
g.ExcludeClip(rect);
using (Brush brush = new SolidBrush(fillColor))
{
g.FillPath(brush, gpTail);
}
g.ResetClip();
}
if (borderSize > 0 && borderColor.A > 0)
{
g.ExcludeClip(rect.Offset(-1));
using (Pen pen = new Pen(borderColor, borderSize))
{
g.DrawPath(pen, gpTail);
}
g.ResetClip();
}
g.SmoothingMode = SmoothingMode.None;
}
if (borderSize > 0 && borderColor.A > 0)
{
if (gpTail != null)
{
using (Region region = new Region(gpTail))
{
g.ExcludeClip(region);
}
}
using (Pen pen = new Pen(borderColor, borderSize) { Alignment = PenAlignment.Inset })
{
g.DrawRectangleProper(pen, rect.Offset(borderSize - 1));
}
g.ResetClip();
}
if (gpTail != null)
{
gpTail.Dispose();
}
}
protected override void Draw(Graphics g)
{
borderDotPen2.DashOffset = (float)timer.Elapsed.TotalSeconds * 10;
List<Rectangle> areas = AreaManager.GetValidAreas;
if (areas.Count > 0 || !AreaManager.CurrentHoverArea.IsEmpty)
{
UpdateRegionPath();
if (areas.Count > 0)
{
using (Region region = new Region(regionDrawPath))
{
g.Clip = region;
g.FillRectangle(lightBackgroundBrush, ScreenRectangle0Based);
g.ResetClip();
}
g.DrawPath(borderPen, regionDrawPath);
if (areas.Count > 1)
{
Rectangle totalArea = AreaManager.CombineAreas();
g.DrawCrossRectangle(borderPen, totalArea, 15);
if (Config.ShowInfo)
{
ImageHelpers.DrawTextWithOutline(g, string.Format("X:{0} Y:{1} W:{2} H:{3}", totalArea.X, totalArea.Y,
totalArea.Width, totalArea.Height), new PointF(totalArea.X + 5, totalArea.Y - 25), textFont, Color.White, Color.Black);
}
}
}
if (AreaManager.IsCurrentHoverAreaValid)
{
using (GraphicsPath hoverDrawPath = new GraphicsPath { FillMode = FillMode.Winding })
{
AddShapePath(hoverDrawPath, AreaManager.CurrentHoverArea.SizeOffset(-1));
g.DrawPath(borderDotPen, hoverDrawPath);
g.DrawPath(borderDotPen2, hoverDrawPath);
}
}
if (AreaManager.IsCurrentAreaValid)
{
g.DrawRectangleProper(borderDotPen, AreaManager.CurrentArea);
g.DrawRectangleProper(borderDotPen2, AreaManager.CurrentArea);
DrawObjects(g);
}
if (Config.ShowInfo)
{
foreach (Rectangle area in areas)
{
if (area.IsValid())
{
ImageHelpers.DrawTextWithOutline(g, string.Format("X:{0} Y:{1}\nW:{2} H:{3}", area.X, area.Y, area.Width, area.Height),
new PointF(area.X + 5, area.Y + 5), textFont, Color.White, Color.Black);
}
}
}
}
if (Config.ShowMagnifier)
{
DrawMagnifier(g);
}
if (Config.ShowCrosshair)
{
DrawCrosshair(g);
}
}
private void DrawInfoText(Graphics g, string text, Rectangle rect, int padding)
{
g.FillRectangle(textBackgroundBrush, rect.Offset(-2));
g.DrawRectangleProper(textBackgroundPenBlack, rect.Offset(-1));
g.DrawRectangleProper(textBackgroundPenWhite, rect);
ImageHelpers.DrawTextWithShadow(g, text, rect.Offset(-padding).Location, infoFont, Brushes.White, Brushes.Black);
}
private void DrawRectangle(Graphics g)
{
Rectangle rect = SelectionRectangle0Based.Offset(Options.DrawingRectangleBorderSize - 1);
if (Options.DrawingRectangleShadow)
{
g.DrawRectangleShadow(rect.Offset(1), Color.DarkGray, 3, 128, 20, new Padding(1));
}
using (Pen pen = new Pen(Options.DrawingPenColor, Options.DrawingRectangleBorderSize) { Alignment = PenAlignment.Inset })
{
g.DrawRectangleProper(pen, rect);
}
}
public static void DrawColorPickerIcon(Graphics g, Color color, Rectangle rect)
{
if (color.A < 255)
{
using (Image checker = CreateCheckers(rect.Width / 2, rect.Height / 2, Color.LightGray, Color.White))
{
g.DrawImage(checker, rect);
}
}
using (SolidBrush brush = new SolidBrush(color))
{
g.FillRectangle(brush, rect);
}
g.DrawRectangleProper(Pens.Black, rect);
}
private void DrawRectangleMarker(Graphics g)
{
using (Pen pen = new Pen(Options.DrawingPenColor, Options.DrawingRectangleBorderSize) { Alignment = PenAlignment.Inset })
{
Point pos = CurrentMousePosition0Based;
int offset = 15;
g.DrawRectangleProper(pen, new Rectangle(pos.X - offset, pos.Y - offset, offset * 2, offset * 2).Offset(Options.DrawingRectangleBorderSize - 1));
}
}
