CodeMirror/ShareX
1
0
Fork 0
mirror of https://github.com/ShareX/ShareX.git synced 2024-06-30 20:20:34 +12:00
Code Issues Packages Projects Releases Wiki Activity

Switch to floating point internally. Panning fixes. (#6108)

Browse source 
* Switch to floating point internally. Panning fixes.

* Fix panning/zoom coordination errors.
This commit is contained in:
Eric Tetz 2022-02-19 23:30:39 -07:00 committed by GitHub
parent 5d5414663a
commit 5f7c9096e0
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
35 changed files with 423 additions and 311 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

121
ShareX.HelpersLib/Extensions/Extensions.cs
View file

@ -129,9 +129,9 @@ public static bool IsValid(this Rectangle rect)
return rect.Width > 0 && rect.Height > 0;
}
public static Point Add(this Point point, int offset)
public static bool IsValid(this RectangleF rect)
{
return point.Add(offset, offset);
return rect.Width > 0 && rect.Height > 0;
}
public static Point Add(this Point point, int offsetX, int offsetY)
@ -144,9 +144,35 @@ public static Point Add(this Point point, Point offset)
return new Point(point.X + offset.X, point.Y + offset.Y);
}
public static Point Scale(this Point point, float scaleFactor)
public static PointF Add(this PointF point, float offsetX, float offsetY)
{
return new Point((int)Math.Round(point.X * scaleFactor), (int)Math.Round(point.Y * scaleFactor));
return new PointF(point.X + offsetX, point.Y + offsetY);
}
public static PointF Add(this PointF point, PointF offset)
{
return new PointF(point.X + offset.X, point.Y + offset.Y);
}
public static PointF Scale(this Point point, float scaleFactor)
{
return new PointF(point.X * scaleFactor, point.Y * scaleFactor);
}
public static PointF Scale(this PointF point, float scaleFactor)
{
return new PointF(point.X * scaleFactor, point.Y * scaleFactor);
}
public static Point Round(this PointF point)
{
return Point.Round(point);
}
public static void Offset(this PointF point, PointF offset)
{
point.X += offset.X;
point.Y += offset.Y;
}
public static Size Offset(this Size size, int offset)
@ -164,10 +190,23 @@ public static Rectangle Offset(this Rectangle rect, int offset)
return new Rectangle(rect.X - offset, rect.Y - offset, rect.Width + (offset * 2), rect.Height + (offset * 2));
}
public static Rectangle Scale(this Rectangle rect, float scaleFactor)
public static RectangleF Offset(this RectangleF rect, float offset)
{
return new Rectangle((int)Math.Round(rect.X * scaleFactor), (int)Math.Round(rect.Y * scaleFactor),
(int)Math.Round(rect.Width * scaleFactor), (int)Math.Round(rect.Height * scaleFactor));
return new RectangleF(rect.X - offset, rect.Y - offset, rect.Width + (offset * 2), rect.Height + (offset * 2));
}
public static RectangleF Scale(this RectangleF rect, float scaleFactor)
{
return new RectangleF(
rect.X * scaleFactor,
rect.Y * scaleFactor,
rect.Width * scaleFactor,
rect.Height * scaleFactor);
}
public static Rectangle Round(this RectangleF rect)
{
return Rectangle.Round(rect);
}
public static Rectangle LocationOffset(this Rectangle rect, int x, int y)
@ -175,6 +214,16 @@ public static Rectangle LocationOffset(this Rectangle rect, int x, int y)
return new Rectangle(rect.X + x, rect.Y + y, rect.Width, rect.Height);
}
public static RectangleF LocationOffset(this RectangleF rect, float x, float y)
{
return new RectangleF(rect.X + x, rect.Y + y, rect.Width, rect.Height);
}
public static RectangleF LocationOffset(this RectangleF rect, PointF offset)
{
return rect.LocationOffset(offset.X, offset.Y);
}
public static Rectangle LocationOffset(this Rectangle rect, Point offset)
{
return rect.LocationOffset(offset.X, offset.Y);
@ -190,10 +239,20 @@ public static Rectangle SizeOffset(this Rectangle rect, int width, int height)
return new Rectangle(rect.X, rect.Y, rect.Width + width, rect.Height + height);
}
public static RectangleF SizeOffset(this RectangleF rect, float width, float height)
{
return new RectangleF(rect.X, rect.Y, rect.Width + width, rect.Height + height);
}
public static Rectangle SizeOffset(this Rectangle rect, int offset)
{
return rect.SizeOffset(offset, offset);
}
public static RectangleF SizeOffset(this RectangleF rect, float offset)
{
return rect.SizeOffset(offset, offset);
}
public static string Join<T>(this T[] array, string separator = " ")
{
@ -575,20 +634,39 @@ public static Rectangle Combine(this IEnumerable<Rectangle> rects)
return result;
}
public static Rectangle AddPoint(this Rectangle rect, Point point)
public static RectangleF Combine(this IEnumerable<RectangleF> rects)
{
return Rectangle.Union(rect, new Rectangle(point, new Size(1, 1)));
}
RectangleF result = RectangleF.Empty;
public static Rectangle CreateRectangle(this IEnumerable<Point> points)
{
Rectangle result = Rectangle.Empty;
foreach (Point point in points)
foreach (RectangleF rect in rects)
{
if (result.IsEmpty)
{
result = new Rectangle(point, new Size(1, 1));
result = rect;
}
else
{
result = RectangleF.Union(result, rect);
}
}
return result;
}
public static RectangleF AddPoint(this RectangleF rect, PointF point)
{
return RectangleF.Union(rect, new RectangleF(point, new SizeF(1, 1)));
}
public static RectangleF CreateRectangle(this IEnumerable<PointF> points)
{
RectangleF result = Rectangle.Empty;
foreach (PointF point in points)
{
if (result.IsEmpty)
{
result = new RectangleF(point, new Size(1, 1));
}
else
{
@ -604,17 +682,22 @@ public static Point Center(this Rectangle rect)
return new Point(rect.X + (rect.Width / 2), rect.Y + (rect.Height / 2));
}
public static int Area(this Rectangle rect)
public static PointF Center(this RectangleF rect)
{
return new PointF(rect.X + (rect.Width / 2), rect.Y + (rect.Height / 2));
}
public static float Area(this RectangleF rect)
{
return rect.Width * rect.Height;
}
public static int Perimeter(this Rectangle rect)
public static float Perimeter(this RectangleF rect)
{
return 2 * (rect.Width + rect.Height);
}
public static Point Restrict(this Point point, Rectangle rect)
public static PointF Restrict(this PointF point, RectangleF rect)
{
point.X = Math.Max(point.X, rect.X);
point.Y = Math.Max(point.Y, rect.Y);

18
ShareX.HelpersLib/Extensions/GraphicsExtensions.cs
View file

@ -31,7 +31,7 @@ namespace ShareX.HelpersLib
{
public static class GraphicsExtensions
{
public static void DrawRectangleProper(this Graphics g, Pen pen, Rectangle rect)
public static void DrawRectangleProper(this Graphics g, Pen pen, RectangleF rect)
{
if (pen.Width == 1)
{
@ -40,7 +40,7 @@ public static void DrawRectangleProper(this Graphics g, Pen pen, Rectangle rect)
if (rect.Width > 0 && rect.Height > 0)
{
g.DrawRectangle(pen, rect);
g.DrawRectangle(pen, rect.X, rect.Y, rect.Width, rect.Height);
}
}
@ -68,17 +68,17 @@ public static void DrawRectangleShadow(this Graphics g, Rectangle rect, Color sh
}
}
public static void DrawRoundedRectangle(this Graphics g, Pen pen, Rectangle rect, float radius)
public static void DrawRoundedRectangle(this Graphics g, Pen pen, RectangleF rect, float radius)
{
g.DrawRoundedRectangle(null, pen, rect, radius);
}
public static void DrawRoundedRectangle(this Graphics g, Brush brush, Rectangle rect, float radius)
public static void DrawRoundedRectangle(this Graphics g, Brush brush, RectangleF rect, float radius)
{
g.DrawRoundedRectangle(brush, null, rect, radius);
}
public static void DrawRoundedRectangle(this Graphics g, Brush brush, Pen pen, Rectangle rect, float radius)
public static void DrawRoundedRectangle(this Graphics g, Brush brush, Pen pen, RectangleF rect, float radius)
{
using (GraphicsPath gp = new GraphicsPath())
{
@ -88,7 +88,7 @@ public static void DrawRoundedRectangle(this Graphics g, Brush brush, Pen pen, R
}
}
public static void DrawCapsule(this Graphics g, Brush brush, Rectangle rect)
public static void DrawCapsule(this Graphics g, Brush brush, RectangleF rect)
{
using (GraphicsPath gp = new GraphicsPath())
{
@ -111,7 +111,7 @@ public static void DrawDiamond(this Graphics g, Pen pen, Rectangle rect)
}
}
public static void DrawCross(this Graphics g, Pen pen, Point center, int crossSize)
public static void DrawCross(this Graphics g, Pen pen, PointF center, int crossSize)
{
if (crossSize > 0)
{
@ -123,7 +123,7 @@ public static void DrawCross(this Graphics g, Pen pen, Point center, int crossSi
}
}
public static void DrawCrossRectangle(this Graphics g, Pen pen, Rectangle rect, int crossSize)
public static void DrawCrossRectangle(this Graphics g, Pen pen, RectangleF rect, int crossSize)
{
rect = rect.SizeOffset(-1);
@ -143,7 +143,7 @@ public static void DrawCrossRectangle(this Graphics g, Pen pen, Rectangle rect,
}
}
public static void DrawCornerLines(this Graphics g, Rectangle rect, Pen pen, int lineSize)
public static void DrawCornerLines(this Graphics g, RectangleF rect, Pen pen, int lineSize)
{
if (rect.Width <= lineSize * 2)
{

26
ShareX.HelpersLib/Helpers/CaptureHelpers.cs
View file

@ -192,9 +192,9 @@ public static bool CheckPixelColor(int x, int y, Color color, byte variation)
targetColor.B.IsBetween((byte)(color.B - variation), (byte)(color.B + variation));
}
public static Rectangle CreateRectangle(int x, int y, int x2, int y2)
public static RectangleF CreateRectangle(float x, float y, float x2, float y2)
{
int width, height;
float width, height;
if (x <= x2)
{
@ -216,10 +216,10 @@ public static Rectangle CreateRectangle(int x, int y, int x2, int y2)
y = y2;
}
return new Rectangle(x, y, width, height);
return new RectangleF(x, y, width, height);
}
public static Rectangle CreateRectangle(Point pos, Point pos2)
public static RectangleF CreateRectangle(PointF pos, PointF pos2)
{
return CreateRectangle(pos.X, pos.Y, pos2.X, pos2.Y);
}
@ -263,45 +263,45 @@ public static Point ProportionalPosition(Point pos, Point pos2)
return newPosition;
}
public static Point SnapPositionToDegree(Point pos, Point pos2, float degree, float startDegree)
public static PointF SnapPositionToDegree(PointF pos, PointF pos2, float degree, float startDegree)
{
float angle = MathHelpers.LookAtRadian(pos, pos2);
float startAngle = MathHelpers.DegreeToRadian(startDegree);
float snapAngle = MathHelpers.DegreeToRadian(degree);
float newAngle = ((float)Math.Round((angle + startAngle) / snapAngle) * snapAngle) - startAngle;
float distance = MathHelpers.Distance(pos, pos2);
return (Point)(pos + MathHelpers.RadianToVector2(newAngle, distance));
return pos.Add((PointF)MathHelpers.RadianToVector2(newAngle, distance));
}
public static Point CalculateNewPosition(Point posOnClick, Point posCurrent, Size size)
public static PointF CalculateNewPosition(PointF posOnClick, PointF posCurrent, Size size)
{
if (posCurrent.X > posOnClick.X)
{
if (posCurrent.Y > posOnClick.Y)
{
return new Point(posOnClick.X + size.Width - 1, posOnClick.Y + size.Height - 1);
return new PointF(posOnClick.X + size.Width - 1, posOnClick.Y + size.Height - 1);
}
else
{
return new Point(posOnClick.X + size.Width - 1, posOnClick.Y - size.Height + 1);
return new PointF(posOnClick.X + size.Width - 1, posOnClick.Y - size.Height + 1);
}
}
else
{
if (posCurrent.Y > posOnClick.Y)
{
return new Point(posOnClick.X - size.Width + 1, posOnClick.Y + size.Height - 1);
return new PointF(posOnClick.X - size.Width + 1, posOnClick.Y + size.Height - 1);
}
else
{
return new Point(posOnClick.X - size.Width + 1, posOnClick.Y - size.Height + 1);
return new PointF(posOnClick.X - size.Width + 1, posOnClick.Y - size.Height + 1);
}
}
}
public static Rectangle CalculateNewRectangle(Point posOnClick, Point posCurrent, Size size)
public static RectangleF CalculateNewRectangle(PointF posOnClick, PointF posCurrent, Size size)
{
Point newPosition = CalculateNewPosition(posOnClick, posCurrent, size);
PointF newPosition = CalculateNewPosition(posOnClick, posCurrent, size);
return CreateRectangle(posOnClick, newPosition);
}

4
ShareX.HelpersLib/Helpers/ImageHelpers.cs
View file

@ -213,9 +213,9 @@ public static Bitmap ResizeImageLimit(Bitmap bmp, int size)
return ResizeImageLimit(bmp, size, size);
}
public static Bitmap CropBitmap(Bitmap bmp, Rectangle rect)
public static Bitmap CropBitmap(Bitmap bmp, RectangleF rect)
{
if (bmp != null && rect.X >= 0 && rect.Y >= 0 && rect.Width > 0 && rect.Height > 0 && new Rectangle(0, 0, bmp.Width, bmp.Height).Contains(rect))
if (bmp != null && rect.X >= 0 && rect.Y >= 0 && rect.Width > 0 && rect.Height > 0 && new RectangleF(0, 0, bmp.Width, bmp.Height).Contains(rect))
{
return bmp.Clone(rect, bmp.PixelFormat);
}

16
ShareX.HelpersLib/Helpers/MathHelpers.cs
View file

@ -24,6 +24,7 @@
#endregion License Information (GPL v3)
using System;
using System.Drawing;
namespace ShareX.HelpersLib
{
@ -135,6 +136,11 @@ public static float LookAtRadian(Vector2 pos1, Vector2 pos2)
return (float)Math.Atan2(pos2.Y - pos1.Y, pos2.X - pos1.X);
}
public static float LookAtRadian(PointF pos1, PointF pos2)
{
return (float)Math.Atan2(pos2.Y - pos1.Y, pos2.X - pos1.X);
}
public static Vector2 LookAtVector2(Vector2 pos1, Vector2 pos2)
{
return RadianToVector2(LookAtRadian(pos1, pos2));
@ -145,9 +151,19 @@ public static float LookAtDegree(Vector2 pos1, Vector2 pos2)
return RadianToDegree(LookAtRadian(pos1, pos2));
}
public static float LookAtDegree(PointF pos1, PointF pos2)
{
return RadianToDegree(LookAtRadian(pos1, pos2));
}
public static float Distance(Vector2 pos1, Vector2 pos2)
{
return (float)Math.Sqrt(Math.Pow(pos2.X - pos1.X, 2) + Math.Pow(pos2.Y - pos1.Y, 2));
}
public static float Distance(PointF pos1, PointF pos2)
{
return (float)Math.Sqrt(Math.Pow(pos2.X - pos1.X, 2) + Math.Pow(pos2.Y - pos1.Y, 2));
}
}
}

5
ShareX.HelpersLib/Vector2.cs
View file

@ -124,6 +124,11 @@ public override string ToString()
return new Point((int)Math.Round(u.x), (int)Math.Round(u.y));
}
public static explicit operator PointF(Vector2 u)
{
return new PointF(u.x, u.y);
}
public static implicit operator Vector2(Point p)
{
return new Vector2(p.X, p.Y);

16
ShareX.ScreenCaptureLib/Animations/RectangleAnimation.cs
View file

@ -31,11 +31,11 @@ namespace ShareX.ScreenCaptureLib
{
internal class RectangleAnimation : BaseAnimation
{
public Rectangle FromRectangle { get; set; }
public Rectangle ToRectangle { get; set; }
public RectangleF FromRectangle { get; set; }
public RectangleF ToRectangle { get; set; }
public TimeSpan Duration { get; set; }
public Rectangle CurrentRectangle { get; private set; }
public RectangleF CurrentRectangle { get; private set; }
public override bool Update()
{
@ -46,12 +46,12 @@ public override bool Update()
float amount = (float)Timer.Elapsed.Ticks / Duration.Ticks;
amount = Math.Min(amount, 1);
int x = (int)MathHelpers.Lerp(FromRectangle.X, ToRectangle.X, amount);
int y = (int)MathHelpers.Lerp(FromRectangle.Y, ToRectangle.Y, amount);
int width = (int)MathHelpers.Lerp(FromRectangle.Width, ToRectangle.Width, amount);
int height = (int)MathHelpers.Lerp(FromRectangle.Height, ToRectangle.Height, amount);
float x = MathHelpers.Lerp(FromRectangle.X, ToRectangle.X, amount);
float y = MathHelpers.Lerp(FromRectangle.Y, ToRectangle.Y, amount);
float width = MathHelpers.Lerp(FromRectangle.Width, ToRectangle.Width, amount);
float height = MathHelpers.Lerp(FromRectangle.Height, ToRectangle.Height, amount);
CurrentRectangle = new Rectangle(x, y, width, height);
CurrentRectangle = new RectangleF(x, y, width, height);
if (amount >= 1)
{

116
ShareX.ScreenCaptureLib/Forms/RegionCaptureForm.cs
View file

@ -50,7 +50,7 @@ public sealed class RegionCaptureForm : Form
public RegionCaptureOptions Options { get; set; }
public Rectangle ClientArea { get; private set; }
public Bitmap Canvas { get; private set; }
public Rectangle CanvasRectangle { get; internal set; }
public RectangleF CanvasRectangle { get; internal set; }
public RegionResult Result { get; private set; }
public int MonitorIndex { get; set; }
public string ImageFilePath { get; set; }
@ -64,7 +64,7 @@ public sealed class RegionCaptureForm : Form
public Point CurrentPosition { get; private set; }
public SimpleWindowInfo SelectedWindow { get; private set; }
internal Point PanningStrech = new Point();
internal PointF PanningStrech = new PointF();
internal Vector2 CanvasCenterOffset { get; set; } = new Vector2(0f, 0f);
internal float ZoomFactor
@ -80,9 +80,8 @@ internal float ZoomFactor
}
internal bool IsZoomed => Math.Round(ZoomFactor * 100) != 100;
internal Point ScaledClientMousePosition => InputManager.ClientMousePosition.Scale(1 / ZoomFactor);
internal Point ScaledClientMouseVelocity => InputManager.MouseVelocity.Scale(1 / ZoomFactor);
internal Point ScaledClientCenter => new Point((int)Math.Round(ClientArea.Width / 2f / ZoomFactor), (int)Math.Round(ClientArea.Height / 2f / ZoomFactor));
internal PointF ScaledClientMousePosition => InputManager.ClientMousePosition.Scale(1 / ZoomFactor);
internal PointF ScaledClientMouseVelocity => InputManager.MouseVelocity.Scale(1 / ZoomFactor);
internal ShapeManager ShapeManager { get; private set; }
internal bool IsClosing { get; private set; }
@ -351,7 +350,7 @@ internal void InitBackground(Bitmap canvas, bool centerCanvas = true)
{
UpdateTitle();
CanvasRectangle = new Rectangle(CanvasRectangle.X, CanvasRectangle.Y, Canvas.Width, Canvas.Height);
CanvasRectangle = new RectangleF(CanvasRectangle.X, CanvasRectangle.Y, Canvas.Width, Canvas.Height);
using (Bitmap background = new Bitmap(Canvas.Width, Canvas.Height))
using (Graphics g = Graphics.FromImage(background))
@ -420,18 +419,23 @@ private void OnMoved()
}
}
private void Pan(int deltaX, int deltaY, bool usePanningStretch = true)
private void Pan(float deltaX, float deltaY, bool usePanningStretch = true)
{
if (deltaX == 0 && deltaY == 0)
{
return;
}
if (usePanningStretch)
{
PanningStrech.X -= deltaX;
PanningStrech.Y -= deltaY;
}
Size panLimitSize = new Size(Math.Min((int)Math.Round(ClientArea.Width * 0.25f), CanvasRectangle.Width),
Math.Min((int)Math.Round(ClientArea.Height * 0.25f), CanvasRectangle.Height));
SizeF panLimitSize = new SizeF(Math.Min(ClientArea.Width * 0.25f, CanvasRectangle.Width),
Math.Min(ClientArea.Height * 0.25f, CanvasRectangle.Height));
Rectangle limitRectangle = new Rectangle(ClientArea.X + panLimitSize.Width, ClientArea.Y + panLimitSize.Height,
RectangleF limitRectangle = new RectangleF(ClientArea.X + panLimitSize.Width, ClientArea.Y + panLimitSize.Height,
ClientArea.Width - (panLimitSize.Width * 2), ClientArea.Height - (panLimitSize.Height * 2));
if (IsZoomed)
@ -477,13 +481,13 @@ private void AutomaticPan(Vector2 centerOffset)
{
if (IsEditorMode)
{
Rectangle canvas = CanvasRectangle.Scale(ZoomFactor);
float x = ClientArea.Width / 2 + centerOffset.X;
float y = ClientArea.Height / 2 + centerOffset.Y;
float newX = x - canvas.Width / 2;
float newY = y - canvas.Height / 2;
int deltaX = (int)Math.Round((newX - canvas.X) / ZoomFactor);
int deltaY = (int)Math.Round((newY - canvas.Y) / ZoomFactor);
RectangleF canvas = CanvasRectangle.Scale(ZoomFactor);
float x = (ClientArea.Width / 2) + centerOffset.X;
float y = (ClientArea.Height / 2) + centerOffset.Y;
float newX = x - (canvas.Width / 2);
float newY = y - (canvas.Height / 2);
float deltaX = (newX - canvas.X) / ZoomFactor;
float deltaY = (newY - canvas.Y) / ZoomFactor;
Pan(deltaX, deltaY, false);
}
}
@ -502,7 +506,7 @@ private void UpdateCenterOffset()
public void CenterCanvas()
{
CanvasCenterOffset = new Vector2(0f, ToolbarHeight / 2f);
AutomaticPan();
AutomaticPan(CanvasCenterOffset / ZoomFactor);
}
public void ZoomTransform(Graphics g, bool invertZoom = false)
@ -713,7 +717,8 @@ private void RegionCaptureForm_MouseWheel(object sender, MouseEventArgs e)
private void Zoom(bool zoomIn, bool atMouse = true)
{
Point centerBefore = atMouse ? ScaledClientMousePosition : ScaledClientCenter;
PointF clientCenter = new PointF(ClientArea.Width / 2f, ClientArea.Height / 2f);
PointF scaledCenterBefore = atMouse ? ScaledClientMousePosition : clientCenter.Scale(1 / zoomFactor);
if (zoomIn)
{
@ -746,17 +751,16 @@ private void Zoom(bool zoomIn, bool atMouse = true)
}
}
Point centerAfter = atMouse ? ScaledClientMousePosition : ScaledClientCenter;
Point delta = new Point(centerAfter.X - centerBefore.X, centerAfter.Y - centerBefore.Y);
Pan(delta);
PointF scaledCenterAfter = atMouse ? ScaledClientMousePosition : clientCenter.Scale(1 / zoomFactor);
Pan(scaledCenterAfter.X - scaledCenterBefore.X, scaledCenterAfter.Y - scaledCenterBefore.Y);
CanvasCenterOffset = new Vector2((CanvasRectangle.X + CanvasRectangle.Width / 2f) * ZoomFactor - clientCenter.X,
(CanvasRectangle.Y + CanvasRectangle.Height / 2f) * ZoomFactor - clientCenter.Y);
UpdateTitle();
}
private void ZoomToFit()
{
ZoomFactor = Math.Min((float)ClientArea.Width / CanvasRectangle.Width, (float)ClientArea.Height / CanvasRectangle.Height);
ZoomFactor = Math.Min(ClientArea.Width/CanvasRectangle.Width, (ClientArea.Height-ToolbarHeight)/CanvasRectangle.Height);
CenterCanvas();
}
@ -846,8 +850,8 @@ private new void Update()
if (ShapeManager.IsPanning)
{
Pan(ScaledClientMouseVelocity);
UpdateCenterOffset();
CanvasCenterOffset = new Vector2(CanvasCenterOffset.X + InputManager.MouseVelocity.X, CanvasCenterOffset.Y + InputManager.MouseVelocity.Y);
AutomaticPan();
}
if (Options.EnableAnimations)
@ -882,7 +886,7 @@ protected override void OnPaint(PaintEventArgs e)
if (IsEditorMode && !CanvasRectangle.Contains(ClientArea))
{
g.Clear(canvasBackgroundColor);
g.DrawRectangleProper(canvasBorderPen, CanvasRectangle.Offset(1));
g.DrawRectangleProper(canvasBorderPen, CanvasRectangle.Offset(1F));
}
DrawBackground(g);
@ -920,7 +924,7 @@ private void DrawShapes(Graphics g)
{
foreach (Size size in Options.SnapSizes)
{
Rectangle snapRect = CaptureHelpers.CalculateNewRectangle(shape.StartPosition, shape.EndPosition, size);
RectangleF snapRect = CaptureHelpers.CalculateNewRectangle(shape.StartPosition, shape.EndPosition, size);
g.DrawRectangleProper(markerPen, snapRect);
}
}
@ -1071,7 +1075,7 @@ private void DrawShapes(Graphics g)
}
}
internal void DrawRegionArea(Graphics g, Rectangle rect, bool isAnimated)
internal void DrawRegionArea(Graphics g, RectangleF rect, bool isAnimated)
{
g.DrawRectangleProper(borderPen, rect);
@ -1098,23 +1102,23 @@ private void DrawFPS(Graphics g, int offset)
g.DrawTextWithShadow(FPSManager.FPS.ToString(), textPosition, infoFontBig, Brushes.White, Brushes.Black, new Point(0, 1));
}
private void DrawInfoText(Graphics g, string text, Rectangle rect, Font font, int padding)
private void DrawInfoText(Graphics g, string text, RectangleF rect, Font font, int padding)
{
DrawInfoText(g, text, rect, font, new Point(padding, padding));
}
private void DrawInfoText(Graphics g, string text, Rectangle rect, Font font, Point padding)
private void DrawInfoText(Graphics g, string text, RectangleF rect, Font font, Point padding)
{
DrawInfoText(g, text, rect, font, padding, textBackgroundBrush, textOuterBorderPen, textInnerBorderPen, textBrush, textShadowBrush);
}
private void DrawInfoText(Graphics g, string text, Rectangle rect, Font font, int padding,
private void DrawInfoText(Graphics g, string text, RectangleF rect, Font font, int padding,
Brush backgroundBrush, Pen outerBorderPen, Pen innerBorderPen, Brush textBrush, Brush textShadowBrush)
{
DrawInfoText(g, text, rect, font, new Point(padding, padding), backgroundBrush, outerBorderPen, innerBorderPen, textBrush, textShadowBrush);
}
private void DrawInfoText(Graphics g, string text, Rectangle rect, Font font, Point padding,
private void DrawInfoText(Graphics g, string text, RectangleF rect, Font font, Point padding,
Brush backgroundBrush, Pen outerBorderPen, Pen innerBorderPen, Brush textBrush, Brush textShadowBrush)
{
g.FillRectangle(backgroundBrush, rect.Offset(-2));
@ -1124,20 +1128,20 @@ private void DrawInfoText(Graphics g, string text, Rectangle rect, Font font, Po
g.DrawTextWithShadow(text, rect.LocationOffset(padding.X, padding.Y).Location, font, textBrush, textShadowBrush);
}
internal void DrawAreaText(Graphics g, string text, Rectangle area)
internal void DrawAreaText(Graphics g, string text, RectangleF area)
{
int offset = 6;
int backgroundPadding = 3;
Size textSize = g.MeasureString(text, infoFont).ToSize();
Point textPos;
PointF textPos;
if (area.Y - offset - textSize.Height - (backgroundPadding * 2) < ClientArea.Y)
{
textPos = new Point(area.X + offset + backgroundPadding, area.Y + offset + backgroundPadding);
textPos = new PointF(area.X + offset + backgroundPadding, area.Y + offset + backgroundPadding);
}
else
{
textPos = new Point(area.X + backgroundPadding, area.Y - offset - backgroundPadding - textSize.Height);
textPos = new PointF(area.X + backgroundPadding, area.Y - offset - backgroundPadding - textSize.Height);
}
if (textPos.X + textSize.Width + backgroundPadding >= ClientArea.Width)
@ -1145,7 +1149,7 @@ internal void DrawAreaText(Graphics g, string text, Rectangle area)
textPos.X = ClientArea.Width - textSize.Width - backgroundPadding;
}
Rectangle backgroundRect = new Rectangle(textPos.X - backgroundPadding, textPos.Y - backgroundPadding, textSize.Width + (backgroundPadding * 2), textSize.Height + (backgroundPadding * 2));
RectangleF backgroundRect = new RectangleF(textPos.X - backgroundPadding, textPos.Y - backgroundPadding, textSize.Width + (backgroundPadding * 2), textSize.Height + (backgroundPadding * 2));
DrawInfoText(g, text, backgroundRect, infoFont, backgroundPadding);
}
@ -1186,15 +1190,15 @@ private void DrawBottomTipAnimation(Graphics g, TextAnimation textAnimation)
DrawTextAnimation(g, textAnimation, textRectangle, padding);
}
internal string GetAreaText(Rectangle rect)
internal string GetAreaText(RectangleF rect)
{
if (IsEditorMode)
{
rect = new Rectangle(rect.X - CanvasRectangle.X, rect.Y - CanvasRectangle.Y, rect.Width, rect.Height);
rect = new RectangleF(rect.X - CanvasRectangle.X, rect.Y - CanvasRectangle.Y, rect.Width, rect.Height);
}
else if (Mode == RegionCaptureMode.Ruler)
{
Point endLocation = new Point(rect.Right - 1, rect.Bottom - 1);
PointF endLocation = new PointF(rect.Right - 1, rect.Bottom - 1);
string text = $"X: {rect.X} | Y: {rect.Y} | Right: {endLocation.X} | Bottom: {endLocation.Y}\r\n" +
$"Width: {rect.Width} px | Height: {rect.Height} px | Area: {rect.Area()} px | Perimeter: {rect.Perimeter()} px\r\n" +
$"Distance: {MathHelpers.Distance(rect.Location, endLocation):0.00} px | Angle: {MathHelpers.LookAtDegree(rect.Location, endLocation):0.00}°";
@ -1208,7 +1212,7 @@ private string GetInfoText()
{
if (IsEditorMode)
{
Point canvasRelativePosition = new Point(ScaledClientMousePosition.X - CanvasRectangle.X, ScaledClientMousePosition.Y - CanvasRectangle.Y);
PointF canvasRelativePosition = new PointF(ScaledClientMousePosition.X - CanvasRectangle.X, ScaledClientMousePosition.Y - CanvasRectangle.Y);
return $"X: {canvasRelativePosition.X} Y: {canvasRelativePosition.Y}";
}
else if (Mode == RegionCaptureMode.ScreenColorPicker || Options.UseCustomInfoText)
@ -1236,11 +1240,11 @@ private string GetInfoText()
private void DrawCrosshair(Graphics g)
{
int offset = 5;
Point mousePos = ScaledClientMousePosition;
Point left = new Point(mousePos.X - offset, mousePos.Y), left2 = new Point(0, mousePos.Y);
Point right = new Point(mousePos.X + offset, mousePos.Y), right2 = new Point(ClientArea.Width - 1, mousePos.Y);
Point top = new Point(mousePos.X, mousePos.Y - offset), top2 = new Point(mousePos.X, 0);
Point bottom = new Point(mousePos.X, mousePos.Y + offset), bottom2 = new Point(mousePos.X, ClientArea.Height - 1);
PointF mousePos = ScaledClientMousePosition;
PointF left = new PointF(mousePos.X - offset, mousePos.Y), left2 = new PointF(0, mousePos.Y);
PointF right = new PointF(mousePos.X + offset, mousePos.Y), right2 = new PointF(ClientArea.Width - 1, mousePos.Y);
PointF top = new PointF(mousePos.X, mousePos.Y - offset), top2 = new PointF(mousePos.X, 0);
PointF bottom = new PointF(mousePos.X, mousePos.Y + offset), bottom2 = new PointF(mousePos.X, ClientArea.Height - 1);
if (left.X - left2.X > 10)
{
@ -1383,7 +1387,7 @@ private void DrawCursorGraphics(Graphics g)
}
}
private Bitmap Magnifier(Image img, Point position, int horizontalPixelCount, int verticalPixelCount, int pixelSize)
private Bitmap Magnifier(Image img, PointF position, int horizontalPixelCount, int verticalPixelCount, int pixelSize)
{
horizontalPixelCount = (horizontalPixelCount | 1).Clamp(1, 101);
verticalPixelCount = (verticalPixelCount | 1).Clamp(1, 101);
@ -1395,7 +1399,7 @@ private Bitmap Magnifier(Image img, Point position, int horizontalPixelCount, in
pixelSize = 10;
}
Rectangle srcRect = new Rectangle(position.X - (horizontalPixelCount / 2) - CanvasRectangle.X,
RectangleF srcRect = new RectangleF(position.X - (horizontalPixelCount / 2) - CanvasRectangle.X,
position.Y - (verticalPixelCount / 2) - CanvasRectangle.Y, horizontalPixelCount, verticalPixelCount);
int width = horizontalPixelCount * pixelSize;
@ -1406,7 +1410,7 @@ private Bitmap Magnifier(Image img, Point position, int horizontalPixelCount, in
{
g.InterpolationMode = InterpolationMode.NearestNeighbor;
if (!new Rectangle(0, 0, img.Width, img.Height).Contains(srcRect))
if (!new RectangleF(0, 0, img.Width, img.Height).Contains(srcRect))
{
g.Clear(canvasBackgroundColor);
}
@ -1447,20 +1451,20 @@ private Bitmap Magnifier(Image img, Point position, int horizontalPixelCount, in
return bmp;
}
private void DrawRuler(Graphics g, Rectangle rect, Pen pen, int rulerSize, int rulerWidth)
private void DrawRuler(Graphics g, RectangleF rect, Pen pen, int rulerSize, int rulerWidth)
{
if (rect.Width >= rulerSize && rect.Height >= rulerSize)
{
for (int x = 1; x <= rect.Width / rulerWidth; x++)
{
g.DrawLine(pen, new Point(rect.X + (x * rulerWidth), rect.Y), new Point(rect.X + (x * rulerWidth), rect.Y + rulerSize));
g.DrawLine(pen, new Point(rect.X + (x * rulerWidth), rect.Bottom), new Point(rect.X + (x * rulerWidth), rect.Bottom - rulerSize));
g.DrawLine(pen, new PointF(rect.X + (x * rulerWidth), rect.Y), new PointF(rect.X + (x * rulerWidth), rect.Y + rulerSize));
g.DrawLine(pen, new PointF(rect.X + (x * rulerWidth), rect.Bottom), new PointF(rect.X + (x * rulerWidth), rect.Bottom - rulerSize));
}
for (int y = 1; y <= rect.Height / rulerWidth; y++)
{
g.DrawLine(pen, new Point(rect.X, rect.Y + (y * rulerWidth)), new Point(rect.X + rulerSize, rect.Y + (y * rulerWidth)));
g.DrawLine(pen, new Point(rect.Right, rect.Y + (y * rulerWidth)), new Point(rect.Right - rulerSize, rect.Y + (y * rulerWidth)));
g.DrawLine(pen, new PointF(rect.X, rect.Y + (y * rulerWidth)), new PointF(rect.X + rulerSize, rect.Y + (y * rulerWidth)));
g.DrawLine(pen, new PointF(rect.Right, rect.Y + (y * rulerWidth)), new PointF(rect.Right - rulerSize, rect.Y + (y * rulerWidth)));
}
}
}

14
ShareX.ScreenCaptureLib/Forms/RegionCaptureLightForm.cs
View file

@ -37,15 +37,15 @@ public sealed class RegionCaptureLightForm : Form
{
private const int MinimumRectangleSize = 3;
public static Rectangle LastSelectionRectangle0Based { get; private set; }
public static RectangleF LastSelectionRectangle0Based { get; private set; }
public Rectangle ScreenRectangle { get; private set; }
public RectangleF ScreenRectangle { get; private set; }
public Rectangle ScreenRectangle0Based => new Rectangle(0, 0, ScreenRectangle.Width, ScreenRectangle.Height);
public RectangleF ScreenRectangle0Based => new RectangleF(0, 0, ScreenRectangle.Width, ScreenRectangle.Height);
public Rectangle SelectionRectangle { get; private set; }
public RectangleF SelectionRectangle { get; private set; }
public Rectangle SelectionRectangle0Based => new Rectangle(SelectionRectangle.X - ScreenRectangle.X, SelectionRectangle.Y - ScreenRectangle.Y,
public RectangleF SelectionRectangle0Based => new RectangleF(SelectionRectangle.X - ScreenRectangle.X, SelectionRectangle.Y - ScreenRectangle.Y,
SelectionRectangle.Width, SelectionRectangle.Height);
private Timer timer;
@ -92,7 +92,7 @@ private void InitializeComponent()
AutoScaleMode = AutoScaleMode.None;
StartPosition = FormStartPosition.Manual;
Bounds = ScreenRectangle;
Bounds = Rectangle.Round(ScreenRectangle);
FormBorderStyle = FormBorderStyle.None;
SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint, true);
Text = "ShareX - " + Resources.RectangleLight_InitializeComponent_Rectangle_capture_light;
@ -164,7 +164,7 @@ private void RectangleLight_MouseUp(object sender, MouseEventArgs e)
public Bitmap GetAreaImage()
{
Rectangle rect = SelectionRectangle0Based;
RectangleF rect = SelectionRectangle0Based;
if (rect.Width > 0 && rect.Height > 0)
{

4
ShareX.ScreenCaptureLib/Forms/RegionCaptureTransparentForm.cs
View file

@ -37,7 +37,7 @@ public sealed class RegionCaptureTransparentForm : LayeredForm
{
private const int MinimumRectangleSize = 3;
public static Rectangle LastSelectionRectangle0Based { get; private set; }
public static RectangleF LastSelectionRectangle0Based { get; private set; }
public Rectangle ScreenRectangle { get; private set; }
@ -174,7 +174,7 @@ private void timer_Tick(object sender, EventArgs e)
{
currentPosition = CaptureHelpers.GetCursorPosition();
PreviousSelectionRectangle = SelectionRectangle;
SelectionRectangle = CaptureHelpers.CreateRectangle(positionOnClick.X, positionOnClick.Y, currentPosition.X, currentPosition.Y);
SelectionRectangle = CaptureHelpers.CreateRectangle(positionOnClick.X, positionOnClick.Y, currentPosition.X, currentPosition.Y).Round();
UpdateBackgroundImage();
}

2
ShareX.ScreenCaptureLib/RegionCaptureTasks.cs
View file

@ -63,7 +63,7 @@ public static bool GetRectangleRegion(out Rectangle rect, out WindowInfo windowI
{
if (form.ShapeManager.IsCurrentShapeValid)
{
rect = CaptureHelpers.ClientToScreen(form.ShapeManager.CurrentRectangle);
rect = CaptureHelpers.ClientToScreen(form.ShapeManager.CurrentRectangle.Round());
return true;
}
}

2
ShareX.ScreenCaptureLib/RegionHelpers/ImageEditorButton.cs
View file

@ -38,7 +38,7 @@ internal class ImageEditorButton : ImageEditorControl
public override void OnDraw(Graphics g)
{
Rectangle rect = Rectangle;
RectangleF rect = Rectangle;
if (IsCursorHover)
{

2
ShareX.ScreenCaptureLib/RegionHelpers/ImageEditorControl.cs
View file

@ -36,7 +36,7 @@ internal abstract class ImageEditorControl
public bool Visible { get; set; }
public bool HandleMouseInput { get; set; } = true;
public Rectangle Rectangle { get; set; }
public RectangleF Rectangle { get; set; }
private bool isCursorHover;

51
ShareX.ScreenCaptureLib/RegionHelpers/ImageEditorScrollbar.cs
View file

@ -42,7 +42,7 @@ internal class ImageEditorScrollbar : ImageEditorControl
public Color ThumbColor { get; set; } = Color.FromArgb(90, 94, 104);
public Color ActiveThumbColor { get; set; } = Color.FromArgb(111, 115, 123);
public bool AutoHide { get; set; } = true;
public Rectangle ThumbRectangle { get; private set; }
public RectangleF ThumbRectangle { get; private set; }
private RegionCaptureForm form;
@ -56,17 +56,18 @@ public void Update()
{
if (AutoHide)
{
RectangleF imageRectangle = form.CanvasRectangle.Scale(form.ZoomFactor);
bool isScrollbarNeeded;
if (Orientation == Orientation.Horizontal)
{
isScrollbarNeeded = form.CanvasRectangle.Left < form.ClientArea.Left ||
(form.CanvasRectangle.Right * form.ZoomFactor) > form.ClientArea.Right;
isScrollbarNeeded = imageRectangle.Left < form.ClientArea.Left ||
(imageRectangle.Right * form.ZoomFactor) > form.ClientArea.Right;
}
else
{
isScrollbarNeeded = form.CanvasRectangle.Top < form.ClientArea.Top ||
(form.CanvasRectangle.Bottom * form.ZoomFactor) > form.ClientArea.Bottom;
isScrollbarNeeded = imageRectangle.Top < form.ClientArea.Top ||
(imageRectangle.Bottom * form.ZoomFactor) > form.ClientArea.Bottom;
}
Visible = isScrollbarNeeded || IsDragging;
@ -83,17 +84,18 @@ public void Update()
Scroll(form.ShapeManager.InputManager.ClientMousePosition);
}
Rectangle imageRectangleVisible = form.CanvasRectangle;
RectangleF imageRectangle = form.CanvasRectangle.Scale(form.ZoomFactor);
RectangleF imageRectangleVisible = imageRectangle;
imageRectangleVisible.Intersect(form.ClientArea);
int inClientAreaSize, inImageVisibleSize, inImageSize, sideOffsetBase;
float inClientAreaSize, inImageVisibleSize, inImageSize, sideOffsetBase;
float inCanvasCenterOffset;
if (Orientation == Orientation.Horizontal)
{
inClientAreaSize = form.ClientArea.Width;
inImageVisibleSize = imageRectangleVisible.Width;
inImageSize = form.CanvasRectangle.Width;
inImageSize = imageRectangle.Width;
sideOffsetBase = form.ClientArea.Bottom;
inCanvasCenterOffset = form.CanvasCenterOffset.X;
}
@ -101,13 +103,13 @@ public void Update()
{
inClientAreaSize = form.ClientArea.Height;
inImageVisibleSize = imageRectangleVisible.Height;
inImageSize = form.CanvasRectangle.Height;
inImageSize = imageRectangle.Height;
sideOffsetBase = form.ClientArea.Right;
inCanvasCenterOffset = form.CanvasCenterOffset.Y;
}
int trackLength = inClientAreaSize - (Margin * 2) - (Padding * 2) - Thickness;
int trackLengthInternal = trackLength - (Padding * 2);
float trackLength = inClientAreaSize - (Margin * 2) - (Padding * 2) - Thickness;
float trackLengthInternal = trackLength - (Padding * 2);
int thumbLength = Math.Max(Thickness, (int)Math.Round((float)inImageVisibleSize / inImageSize * trackLengthInternal));
double thumbLimit = (trackLengthInternal - thumbLength) / 2.0f;
@ -115,18 +117,18 @@ public void Update()
Math.Min(thumbLimit, Math.Max(-thumbLimit, inCanvasCenterOffset / inImageSize * trackLengthInternal)));
int trackWidth = (Padding * 2) + Thickness;
int thumbSideOffset = sideOffsetBase - Margin - Padding - Thickness;
int trackSideOffset = thumbSideOffset - Padding;
float thumbSideOffset = sideOffsetBase - Margin - Padding - Thickness;
float trackSideOffset = thumbSideOffset - Padding;
if (Orientation == Orientation.Horizontal)
{
Rectangle = new Rectangle(Margin, trackSideOffset, trackLength, trackWidth);
ThumbRectangle = new Rectangle(thumbPosition, thumbSideOffset, thumbLength, Thickness);
Rectangle = new RectangleF(Margin, trackSideOffset, trackLength, trackWidth);
ThumbRectangle = new RectangleF(thumbPosition, thumbSideOffset, thumbLength, Thickness);
}
else
{
Rectangle = new Rectangle(trackSideOffset, Margin, trackWidth, trackLength);
ThumbRectangle = new Rectangle(thumbSideOffset, thumbPosition, Thickness, thumbLength);
Rectangle = new RectangleF(trackSideOffset, Margin, trackWidth, trackLength);
ThumbRectangle = new RectangleF(thumbSideOffset, thumbPosition, Thickness, thumbLength);
}
}
}
@ -173,27 +175,28 @@ public override void OnDraw(Graphics g)
private void Scroll(Point position)
{
int inMousePosition, inClientAreaSize, inImageSize;
RectangleF imageRectangle = form.CanvasRectangle.Scale(form.ZoomFactor);
float inMousePosition, inClientAreaSize, inImageSize;
if (Orientation == Orientation.Horizontal)
{
inMousePosition = position.X;
inClientAreaSize = form.ClientArea.Width;
inImageSize = form.CanvasRectangle.Width;
inImageSize = imageRectangle.Width;
}
else
{
inMousePosition = position.Y;
inClientAreaSize = form.ClientArea.Height;
inImageSize = form.CanvasRectangle.Height;
inImageSize = imageRectangle.Height;
}
int mousePositionLocal = inMousePosition - Margin - Padding;
float mousePositionLocal = inMousePosition - Margin - Padding;
int trackLength = inClientAreaSize - (Margin * 2) - (Padding * 2) - Thickness;
int trackLengthInternal = trackLength - (Padding * 2);
float trackLength = inClientAreaSize - (Margin * 2) - (Padding * 2) - Thickness;
float trackLengthInternal = trackLength - (Padding * 2);
int centerOffsetNew = (int)(((trackLengthInternal / 2.0f) - mousePositionLocal) / trackLengthInternal * inImageSize);
float centerOffsetNew = ((trackLengthInternal / 2.0f) - mousePositionLocal) / trackLengthInternal * inImageSize;
if (Orientation == Orientation.Horizontal)
{

20
ShareX.ScreenCaptureLib/RegionHelpers/ResizeNode.cs
View file

@ -33,9 +33,9 @@ internal class ResizeNode : ImageEditorControl
{
public const int DefaultSize = 13;
private Point position;
private PointF position;
public Point Position
public PointF Position
{
get
{
@ -45,7 +45,7 @@ public Point Position
{
position = value;
Rectangle = new Rectangle(position.X - ((Size - 1) / 2), position.Y - ((Size - 1) / 2), Size, Size);
Rectangle = new RectangleF(position.X - ((Size - 1) / 2), position.Y - ((Size - 1) / 2), Size, Size);
}
}
@ -81,10 +81,10 @@ public NodeShape Shape
public Image CustomNodeImage { get; private set; }
public ResizeNode(int x = 0, int y = 0)
public ResizeNode(float x = 0, float y = 0)
{
Shape = NodeShape.Square;
Position = new Point(x, y);
Position = new PointF(x, y);
}
public void SetCustomNode(Image customNodeImage)
@ -95,13 +95,13 @@ public void SetCustomNode(Image customNodeImage)
public override void OnDraw(Graphics g)
{
Rectangle rect = Rectangle.SizeOffset(-1);
RectangleF rect = Rectangle.SizeOffset(-1);
switch (Shape)
{
case NodeShape.Square:
g.DrawRectangle(Pens.White, rect.Offset(-1));
g.DrawRectangle(Pens.Black, rect);
g.DrawRectangle(Pens.White, rect.Offset(-1).Round());
g.DrawRectangle(Pens.Black, rect.Round());
break;
default:
case NodeShape.Circle:
@ -109,8 +109,8 @@ public override void OnDraw(Graphics g)
g.DrawEllipse(Pens.Black, rect);
break;
case NodeShape.Diamond:
g.DrawDiamond(Pens.White, rect.Offset(-1));
g.DrawDiamond(Pens.Black, rect);
g.DrawDiamond(Pens.White, rect.Offset(-1).Round());
g.DrawDiamond(Pens.Black, rect.Round());
break;
case NodeShape.CustomNode when CustomNodeImage != null:
g.DrawImage(CustomNodeImage, Rectangle);

88
ShareX.ScreenCaptureLib/Shapes/BaseShape.cs
View file

@ -37,9 +37,9 @@ public abstract class BaseShape : IDisposable
public abstract ShapeType ShapeType { get; }
private Rectangle rectangle;
private RectangleF rectangle;
public Rectangle Rectangle
public RectangleF Rectangle
{
get
{
@ -49,19 +49,19 @@ public Rectangle Rectangle
{
rectangle = value;
startPosition = rectangle.Location;
endPosition = new Point(rectangle.X + rectangle.Width - 1, rectangle.Y + rectangle.Height - 1);
endPosition = new PointF(rectangle.X + rectangle.Width - 1, rectangle.Y + rectangle.Height - 1);
}
}
public Rectangle RectangleInsideCanvas => Rectangle.Intersect(Rectangle, Manager.Form.CanvasRectangle);
public RectangleF RectangleInsideCanvas => RectangleF.Intersect(Rectangle, Manager.Form.CanvasRectangle);
public bool IsInsideCanvas => !RectangleInsideCanvas.IsEmpty;
public virtual bool LimitRectangleToInsideCanvas { get; }
private Point startPosition;
private PointF startPosition;
public Point StartPosition
public PointF StartPosition
{
get
{
@ -74,9 +74,9 @@ private set
}
}
private Point endPosition;
private PointF endPosition;
public Point EndPosition
public PointF EndPosition
{
get
{
@ -89,7 +89,7 @@ private set
}
}
public Size InitialSize { get; set; }
public SizeF InitialSize { get; set; }
public virtual bool IsValidShape => !Rectangle.IsEmpty && Rectangle.Width >= Options.MinimumSize && Rectangle.Height >= Options.MinimumSize;
@ -103,8 +103,8 @@ private set
protected RegionCaptureOptions Options => Manager.Options;
protected AnnotationOptions AnnotationOptions => Manager.Options.AnnotationOptions;
private Point tempNodePos, tempStartPos, tempEndPos;
private Rectangle tempRectangle;
private PointF tempNodePos, tempStartPos, tempEndPos;
private RectangleF tempRectangle;
public bool IsHandledBySelectTool
{
@ -121,7 +121,7 @@ public bool IsHandledBySelectTool
}
}
public virtual bool Intersects(Point position)
public virtual bool Intersects(PointF position)
{
return Rectangle.Contains(position);
}
@ -164,7 +164,7 @@ public virtual void Remove()
public void AddShapePath(GraphicsPath gp, int sizeOffset = 0)
{
Rectangle rect = Rectangle;
RectangleF rect = Rectangle;
if (sizeOffset != 0)
{
@ -174,18 +174,18 @@ public void AddShapePath(GraphicsPath gp, int sizeOffset = 0)
OnShapePathRequested(gp, rect);
}
public virtual void Move(int x, int y)
public virtual void Move(float x, float y)
{
StartPosition = StartPosition.Add(x, y);
EndPosition = EndPosition.Add(x, y);
}
public void Move(Point offset)
public void Move(PointF offset)
{
Move(offset.X, offset.Y);
}
public void MoveAbsolute(int x, int y, bool center = false)
public void MoveAbsolute(float x, float y, bool center = false)
{
if (center)
{
@ -196,7 +196,7 @@ public void MoveAbsolute(int x, int y, bool center = false)
Move(x - Rectangle.X, y - Rectangle.Y);
}
public void MoveAbsolute(Point point, bool center = false)
public void MoveAbsolute(PointF point, bool center = false)
{
MoveAbsolute(point.X, point.Y, center);
}
@ -225,18 +225,18 @@ public virtual BaseShape Duplicate()
public virtual void OnCreating()
{
Point pos = Manager.Form.ScaledClientMousePosition;
PointF pos = Manager.Form.ScaledClientMousePosition;
if (Options.IsFixedSize && ShapeCategory == ShapeCategory.Region)
{
Manager.IsMoving = true;
Rectangle = new Rectangle(new Point(pos.X - (Options.FixedSize.Width / 2), pos.Y - (Options.FixedSize.Height / 2)), Options.FixedSize);
Rectangle = new RectangleF(new PointF(pos.X - (Options.FixedSize.Width / 2), pos.Y - (Options.FixedSize.Height / 2)), Options.FixedSize);
OnCreated();
}
else
{
Manager.IsCreating = true;
Rectangle = new Rectangle(pos.X, pos.Y, 1, 1);
Rectangle = new RectangleF(pos.X, pos.Y, 1, 1);
}
}
@ -270,7 +270,7 @@ public virtual void OnUpdate()
{
if (Manager.IsCreating)
{
Point pos = Manager.Form.ScaledClientMousePosition;
PointF pos = Manager.Form.ScaledClientMousePosition;
if (Manager.IsCornerMoving && !Manager.IsPanning)
{
@ -313,7 +313,7 @@ public virtual void OnUpdate()
}
}
public virtual void OnShapePathRequested(GraphicsPath gp, Rectangle rect)
public virtual void OnShapePathRequested(GraphicsPath gp, RectangleF rect)
{
gp.AddRectangle(rect);
}
@ -353,7 +353,7 @@ public virtual void OnNodeUpdate()
{
tempNodePos = node.Position;
tempStartPos = Rectangle.Location;
tempEndPos = new Point(Rectangle.X + Rectangle.Width - 1, Rectangle.Y + Rectangle.Height - 1);
tempEndPos = new PointF(Rectangle.X + Rectangle.Width - 1, Rectangle.Y + Rectangle.Height - 1);
tempRectangle = Rectangle;
OnResizing();
@ -367,13 +367,13 @@ public virtual void OnNodeUpdate()
tempRectangle.LocationOffset(Manager.Form.ScaledClientMouseVelocity);
}
Point pos = Manager.Form.ScaledClientMousePosition;
Point startPos = tempStartPos;
Point endPos = tempEndPos;
PointF pos = Manager.Form.ScaledClientMousePosition;
PointF startPos = tempStartPos;
PointF endPos = tempEndPos;
NodePosition nodePosition = (NodePosition)i;
int x = pos.X - tempNodePos.X;
float x = pos.X - tempNodePos.X;
switch (nodePosition)
{
@ -389,7 +389,7 @@ public virtual void OnNodeUpdate()
break;
}
int y = pos.Y - tempNodePos.Y;
float y = pos.Y - tempNodePos.Y;
switch (nodePosition)
{
@ -423,7 +423,7 @@ public virtual void OnNodeUpdate()
int newWidth = (int)Math.Round(InitialSize.Width * ratio);
int newHeight = (int)Math.Round(InitialSize.Height * ratio);
Point anchor = new Point();
PointF anchor = new PointF();
switch (nodePosition)
{
@ -453,7 +453,7 @@ public virtual void OnNodeUpdate()
break;
}
Rectangle newRect = Rectangle;
RectangleF newRect = Rectangle;
if (pos.X < anchor.X)
{
@ -482,22 +482,22 @@ public virtual void OnNodeUpdate()
public virtual void OnNodePositionUpdate()
{
int xStart = Rectangle.X;
int xMid = Rectangle.X + (Rectangle.Width / 2);
int xEnd = Rectangle.X + Rectangle.Width - 1;
float xStart = Rectangle.X;
float xMid = Rectangle.X + (Rectangle.Width / 2);
float xEnd = Rectangle.X + Rectangle.Width - 1;
int yStart = Rectangle.Y;
int yMid = Rectangle.Y + (Rectangle.Height / 2);
int yEnd = Rectangle.Y + Rectangle.Height - 1;
float yStart = Rectangle.Y;
float yMid = Rectangle.Y + (Rectangle.Height / 2);
float yEnd = Rectangle.Y + Rectangle.Height - 1;
Manager.ResizeNodes[(int)NodePosition.TopLeft].Position = new Point(xStart, yStart);
Manager.ResizeNodes[(int)NodePosition.Top].Position = new Point(xMid, yStart);
Manager.ResizeNodes[(int)NodePosition.TopRight].Position = new Point(xEnd, yStart);
Manager.ResizeNodes[(int)NodePosition.Right].Position = new Point(xEnd, yMid);
Manager.ResizeNodes[(int)NodePosition.BottomRight].Position = new Point(xEnd, yEnd);
Manager.ResizeNodes[(int)NodePosition.Bottom].Position = new Point(xMid, yEnd);
Manager.ResizeNodes[(int)NodePosition.BottomLeft].Position = new Point(xStart, yEnd);
Manager.ResizeNodes[(int)NodePosition.Left].Position = new Point(xStart, yMid);
Manager.ResizeNodes[(int)NodePosition.TopLeft].Position = new PointF(xStart, yStart);
Manager.ResizeNodes[(int)NodePosition.Top].Position = new PointF(xMid, yStart);
Manager.ResizeNodes[(int)NodePosition.TopRight].Position = new PointF(xEnd, yStart);
Manager.ResizeNodes[(int)NodePosition.Right].Position = new PointF(xEnd, yMid);
Manager.ResizeNodes[(int)NodePosition.BottomRight].Position = new PointF(xEnd, yEnd);
Manager.ResizeNodes[(int)NodePosition.Bottom].Position = new PointF(xMid, yEnd);
Manager.ResizeNodes[(int)NodePosition.BottomLeft].Position = new PointF(xStart, yEnd);
Manager.ResizeNodes[(int)NodePosition.Left].Position = new PointF(xStart, yMid);
for (int i = 0; i < 8; i++)
{

5
ShareX.ScreenCaptureLib/Shapes/Drawing/CursorDrawingShape.cs
View file

@ -23,6 +23,7 @@
#endregion License Information (GPL v3)
using ShareX.HelpersLib;
using System;
using System.Drawing;
@ -49,7 +50,7 @@ public override void ShowNodes()
public override void OnCreating()
{
Manager.IsMoving = true;
UpdateCursor(Manager.GetSelectedCursor().Handle, Manager.Form.ScaledClientMousePosition);
UpdateCursor(Manager.GetSelectedCursor().Handle, Manager.Form.ScaledClientMousePosition.Round());
OnCreated();
}
@ -61,7 +62,7 @@ public override void OnDraw(Graphics g)
if (!Manager.IsRenderingOutput && Manager.CurrentTool == ShapeType.DrawingCursor)
{
Manager.DrawRegionArea(g, Rectangle, false);
Manager.DrawRegionArea(g, Rectangle.Round(), false);
}
}
}

4
ShareX.ScreenCaptureLib/Shapes/Drawing/EllipseDrawingShape.cs
View file

@ -55,7 +55,7 @@ protected void DrawEllipse(Graphics g)
DrawEllipse(g, BorderColor, BorderSize, BorderStyle, FillColor, Rectangle);
}
protected void DrawEllipse(Graphics g, Color borderColor, int borderSize, BorderStyle borderStyle, Color fillColor, Rectangle rect)
protected void DrawEllipse(Graphics g, Color borderColor, int borderSize, BorderStyle borderStyle, Color fillColor, RectangleF rect)
{
g.SmoothingMode = SmoothingMode.HighQuality;
@ -80,7 +80,7 @@ protected void DrawEllipse(Graphics g, Color borderColor, int borderSize, Border
g.SmoothingMode = SmoothingMode.None;
}
public override void OnShapePathRequested(GraphicsPath gp, Rectangle rect)
public override void OnShapePathRequested(GraphicsPath gp, RectangleF rect)
{
gp.AddEllipse(rect);
}

10
ShareX.ScreenCaptureLib/Shapes/Drawing/FreehandDrawingShape.cs
View file

@ -40,7 +40,7 @@ public class FreehandDrawingShape : BaseDrawingShape
public override bool IsSelectable => Manager.CurrentTool == ShapeType.ToolSelect;
public Point LastPosition
public PointF LastPosition
{
get
{
@ -60,7 +60,7 @@ public Point LastPosition
}
}
private List<Point> positions = new List<Point>();
private List<PointF> positions = new List<PointF>();
private bool isPolygonMode;
public override void ShowNodes()
@ -77,7 +77,7 @@ public override void OnUpdate()
}
else
{
Point pos = Manager.Form.ScaledClientMousePosition;
PointF pos = Manager.Form.ScaledClientMousePosition;
if (positions.Count == 0 || (!Manager.IsProportionalResizing && LastPosition != pos))
{
@ -122,7 +122,7 @@ protected void DrawFreehand(Graphics g)
DrawFreehand(g, BorderColor, borderSize, BorderStyle, positions.ToArray());
}
protected void DrawFreehand(Graphics g, Color borderColor, int borderSize, BorderStyle borderStyle, Point[] points)
protected void DrawFreehand(Graphics g, Color borderColor, int borderSize, BorderStyle borderStyle, PointF[] points)
{
if (points.Length > 0 && borderSize > 0 && borderColor.A > 0)
{
@ -160,7 +160,7 @@ protected void DrawFreehand(Graphics g, Color borderColor, int borderSize, Borde
}
}
public override void Move(int x, int y)
public override void Move(float x, float y)
{
for (int i = 0; i < positions.Count; i++)
{

6
ShareX.ScreenCaptureLib/Shapes/Drawing/ImageDrawingShape.cs
View file

@ -64,19 +64,19 @@ public void SetImage(Image img, bool centerImage)
if (Image != null)
{
Point location;
PointF location;
Size size = Image.Size;
if (centerImage)
{
location = new Point(Rectangle.X - (size.Width / 2), Rectangle.Y - (size.Height / 2));
location = new PointF(Rectangle.X - (size.Width / 2), Rectangle.Y - (size.Height / 2));
}
else
{
location = Rectangle.Location;
}
Rectangle = new Rectangle(location, size);
Rectangle = new RectangleF(location, size);
}
}

4
ShareX.ScreenCaptureLib/Shapes/Drawing/ImageFileDrawingShape.cs
View file

@ -32,8 +32,8 @@ public class ImageFileDrawingShape : ImageDrawingShape
{
public override void OnCreating()
{
Point pos = Manager.Form.ScaledClientMousePosition;
Rectangle = new Rectangle(pos.X, pos.Y, 1, 1);
PointF pos = Manager.Form.ScaledClientMousePosition;
Rectangle = new RectangleF(pos.X, pos.Y, 1, 1);
if (Manager.IsCtrlModifier && LoadImageFile(AnnotationOptions.LastImageFilePath, true))
{

18
ShareX.ScreenCaptureLib/Shapes/Drawing/LineDrawingShape.cs
View file

@ -37,7 +37,7 @@ public class LineDrawingShape : BaseDrawingShape
public override ShapeType ShapeType { get; } = ShapeType.DrawingLine;
public Point[] Points { get; private set; } = new Point[2];
public PointF[] Points { get; private set; } = new PointF[2];
public bool CenterNodeActive { get; private set; }
public int CenterPointCount { get; private set; }
@ -50,7 +50,7 @@ protected override void UseLightResizeNodes()
private void AdjustPoints(int centerPointCount)
{
Point[] newPoints = new Point[2 + centerPointCount];
PointF[] newPoints = new PointF[2 + centerPointCount];
if (Points != null)
{
@ -67,8 +67,8 @@ private void AutoPositionCenterPoints()
{
for (int i = 1; i < Points.Length - 1; i++)
{
Points[i] = new Point((int)MathHelpers.Lerp(Points[0].X, Points[Points.Length - 1].X, i / (CenterPointCount + 1f)),
(int)MathHelpers.Lerp(Points[0].Y, Points[Points.Length - 1].Y, i / (CenterPointCount + 1f)));
Points[i] = new PointF(MathHelpers.Lerp(Points[0].X, Points[Points.Length - 1].X, i / (CenterPointCount + 1f)),
MathHelpers.Lerp(Points[0].Y, Points[Points.Length - 1].Y, i / (CenterPointCount + 1f)));
}
}
}
@ -121,12 +121,12 @@ private void CalculateRectangle()
if (Rectangle.Width < MinimumCollisionSize)
{
Rectangle = new Rectangle(Rectangle.X - (MinimumCollisionSize / 2), Rectangle.Y, Rectangle.Width + MinimumCollisionSize, Rectangle.Height);
Rectangle = new RectangleF(Rectangle.X - (MinimumCollisionSize / 2), Rectangle.Y, Rectangle.Width + MinimumCollisionSize, Rectangle.Height);
}
if (Rectangle.Height < MinimumCollisionSize)
{
Rectangle = new Rectangle(Rectangle.X, Rectangle.Y - (MinimumCollisionSize / 2), Rectangle.Width, Rectangle.Height + MinimumCollisionSize);
Rectangle = new RectangleF(Rectangle.X, Rectangle.Y - (MinimumCollisionSize / 2), Rectangle.Width, Rectangle.Height + MinimumCollisionSize);
}
}
@ -141,7 +141,7 @@ protected void DrawLine(Graphics g)
if (Shadow)
{
Point[] shadowPoints = new Point[Points.Length];
PointF[] shadowPoints = new PointF[Points.Length];
for (int i = 0; i < shadowPoints.Length; i++)
{
@ -154,7 +154,7 @@ protected void DrawLine(Graphics g)
DrawLine(g, BorderColor, borderSize, BorderStyle, Points);
}
protected void DrawLine(Graphics g, Color borderColor, int borderSize, BorderStyle borderStyle, Point[] points)
protected void DrawLine(Graphics g, Color borderColor, int borderSize, BorderStyle borderStyle, PointF[] points)
{
if (borderSize > 0 && borderColor.A > 0)
{
@ -193,7 +193,7 @@ protected virtual Pen CreatePen(Color borderColor, int borderSize, BorderStyle b
};
}
public override void Move(int x, int y)
public override void Move(float x, float y)
{
base.Move(x, y);

2
ShareX.ScreenCaptureLib/Shapes/Drawing/MagnifyDrawingShape.cs
View file

@ -71,7 +71,7 @@ public override void OnDraw(Graphics g)
int newHeight = (int)(Rectangle.Height / magnify);
g.DrawImage(Manager.Form.Canvas, Rectangle,
new Rectangle(Rectangle.X + (Rectangle.Width / 2) - (newWidth / 2) - Manager.Form.CanvasRectangle.X + Manager.RenderOffset.X,
new RectangleF(Rectangle.X + (Rectangle.Width / 2) - (newWidth / 2) - Manager.Form.CanvasRectangle.X + Manager.RenderOffset.X,
Rectangle.Y + (Rectangle.Height / 2) - (newHeight / 2) - Manager.Form.CanvasRectangle.Y + Manager.RenderOffset.Y,
newWidth, newHeight), GraphicsUnit.Pixel);

4
ShareX.ScreenCaptureLib/Shapes/Drawing/RectangleDrawingShape.cs
View file

@ -69,7 +69,7 @@ protected void DrawRectangle(Graphics g)
DrawRectangle(g, BorderColor, BorderSize, BorderStyle, FillColor, Rectangle, CornerRadius);
}
protected void DrawRectangle(Graphics g, Color borderColor, int borderSize, BorderStyle borderStyle, Color fillColor, Rectangle rect, int cornerRadius)
protected void DrawRectangle(Graphics g, Color borderColor, int borderSize, BorderStyle borderStyle, Color fillColor, RectangleF rect, int cornerRadius)
{
Brush brush = null;
Pen pen = null;
@ -109,7 +109,7 @@ protected void DrawRectangle(Graphics g, Color borderColor, int borderSize, Bord
}
}
public override void OnShapePathRequested(GraphicsPath gp, Rectangle rect)
public override void OnShapePathRequested(GraphicsPath gp, RectangleF rect)
{
gp.AddRoundedRectangle(rect, CornerRadius);
}

22
ShareX.ScreenCaptureLib/Shapes/Drawing/SpeechBalloonDrawingShape.cs
View file

@ -34,9 +34,9 @@ public class SpeechBalloonDrawingShape : TextDrawingShape
{
public override ShapeType ShapeType { get; } = ShapeType.DrawingSpeechBalloon;
private Point tailPosition;
private PointF tailPosition;
public Point TailPosition
public PointF TailPosition
{
get
{
@ -86,7 +86,7 @@ public override void OnNodeUpdate()
}
}
public override void Move(int x, int y)
public override void Move(float x, float y)
{
base.Move(x, y);
@ -119,7 +119,7 @@ protected void DrawSpeechBalloon(Graphics g)
DrawSpeechBalloon(g, BorderColor, BorderSize, FillColor, Rectangle, TailPosition);
}
protected void DrawSpeechBalloon(Graphics g, Color borderColor, int borderSize, Color fillColor, Rectangle rect, Point tailPosition)
protected void DrawSpeechBalloon(Graphics g, Color borderColor, int borderSize, Color fillColor, RectangleF rect, PointF tailPosition)
{
GraphicsPath gpTail = null;
@ -142,7 +142,7 @@ protected void DrawSpeechBalloon(Graphics g, Color borderColor, int borderSize,
if (fillColor.A > 0)
{
g.ExcludeClip(rect);
g.ExcludeClip(rect.Round());
using (Brush brush = new SolidBrush(fillColor))
{
@ -154,7 +154,7 @@ protected void DrawSpeechBalloon(Graphics g, Color borderColor, int borderSize,
if (borderSize > 0 && borderColor.A > 0)
{
g.ExcludeClip(rect.Offset(-1));
g.ExcludeClip(rect.Offset(-1).Round());
using (Pen pen = new Pen(borderColor, borderSize))
{
@ -191,14 +191,14 @@ protected void DrawSpeechBalloon(Graphics g, Color borderColor, int borderSize,
}
}
protected GraphicsPath CreateTailPath(Rectangle rect, Point tailPosition)
protected GraphicsPath CreateTailPath(RectangleF rect, PointF tailPosition)
{
GraphicsPath gpTail = new GraphicsPath();
Point center = rect.Center();
int rectAverageSize = (rect.Width + rect.Height) / 2;
int tailWidth = (int)(TailWidthMultiplier * rectAverageSize);
PointF center = rect.Center();
float rectAverageSize = (rect.Width + rect.Height) / 2;
float tailWidth = TailWidthMultiplier * rectAverageSize;
tailWidth = Math.Min(Math.Min(tailWidth, rect.Width), rect.Height);
int tailOrigin = tailWidth / 2;
float tailOrigin = tailWidth / 2;
int tailLength = (int)MathHelpers.Distance(center, tailPosition);
gpTail.AddLine(0, -tailOrigin, 0, tailOrigin);
gpTail.AddLine(0, tailOrigin, tailLength, 0);

30
ShareX.ScreenCaptureLib/Shapes/Drawing/StepDrawingShape.cs
View file

@ -42,9 +42,9 @@ public class StepDrawingShape : EllipseDrawingShape
public StepType StepType { get; set; } = StepType.Numbers;
public bool IsTailActive { get; set; }
private Point tailPosition;
private PointF tailPosition;
public Point TailPosition
public PointF TailPosition
{
get
{
@ -71,8 +71,8 @@ public StepDrawingShape()
public override void OnCreating()
{
Manager.IsMoving = true;
Point pos = Manager.Form.ScaledClientMousePosition;
Rectangle = new Rectangle(new Point(pos.X - (Rectangle.Width / 2), pos.Y - (Rectangle.Height / 2)), Rectangle.Size);
PointF pos = Manager.Form.ScaledClientMousePosition;
Rectangle = new RectangleF(new PointF(pos.X - (Rectangle.Width / 2), pos.Y - (Rectangle.Height / 2)), Rectangle.Size);
int tailOffset = 5;
TailPosition = Rectangle.Location.Add(Rectangle.Width + tailOffset, Rectangle.Height + tailOffset);
OnCreated();
@ -158,8 +158,8 @@ protected void DrawNumber(Graphics g)
int maxSize = Math.Max(textSize.Width, textSize.Height);
int padding = 3;
Point center = Rectangle.Center();
Rectangle = new Rectangle(center.X - (maxSize / 2) - padding, center.Y - (maxSize / 2) - padding, maxSize + (padding * 2), maxSize + (padding * 2));
PointF center = Rectangle.Center();
Rectangle = new RectangleF(center.X - (maxSize / 2) - padding, center.Y - (maxSize / 2) - padding, maxSize + (padding * 2), maxSize + (padding * 2));
if (Shadow)
{
@ -205,7 +205,7 @@ protected void DrawNumber(Graphics g)
}
}
protected void DrawNumber(Graphics g, string text, Font font, Color textColor, Rectangle rect)
protected void DrawNumber(Graphics g, string text, Font font, Color textColor, RectangleF rect)
{
using (StringFormat sf = new StringFormat { Alignment = StringAlignment.Center, LineAlignment = StringAlignment.Center })
using (Brush textBrush = new SolidBrush(textColor))
@ -217,7 +217,7 @@ protected void DrawNumber(Graphics g, string text, Font font, Color textColor, R
}
}
private void DrawTail(Graphics g, Color tailColor, Rectangle rectangle, Point tailPosition)
private void DrawTail(Graphics g, Color tailColor, RectangleF rectangle, PointF tailPosition)
{
using (GraphicsPath gpTail = CreateTailPath(rectangle, tailPosition))
{
@ -235,7 +235,7 @@ private void DrawTail(Graphics g, Color tailColor, Rectangle rectangle, Point ta
}
}
public override void Move(int x, int y)
public override void Move(float x, float y)
{
base.Move(x, y);
@ -247,15 +247,15 @@ public override void Resize(int x, int y, bool fromBottomRight)
Move(x, y);
}
protected GraphicsPath CreateTailPath(Rectangle rect, Point tailPosition)
protected GraphicsPath CreateTailPath(RectangleF rect, PointF tailPosition)
{
GraphicsPath gpTail = new GraphicsPath();
Point center = rect.Center();
int rectAverageSize = (rect.Width + rect.Height) / 2;
int tailWidth = (int)(TailWidthMultiplier * rectAverageSize);
PointF center = rect.Center();
float rectAverageSize = (rect.Width + rect.Height) / 2;
float tailWidth = TailWidthMultiplier * rectAverageSize;
tailWidth = Math.Min(Math.Min(tailWidth, rect.Width), rect.Height);
int tailOrigin = tailWidth / 2;
int tailLength = (int)MathHelpers.Distance(center, tailPosition);
float tailOrigin = tailWidth / 2;
float tailLength = MathHelpers.Distance(center, tailPosition);
gpTail.AddLine(0, -tailOrigin, 0, tailOrigin);
gpTail.AddLine(0, tailOrigin, tailLength, 0);
gpTail.CloseFigure();

4
ShareX.ScreenCaptureLib/Shapes/Drawing/StickerDrawingShape.cs
View file

@ -48,8 +48,8 @@ public override void ShowNodes()
public override void OnCreating()
{
Point pos = Manager.Form.ScaledClientMousePosition;
Rectangle = new Rectangle(pos.X, pos.Y, 1, 1);
PointF pos = Manager.Form.ScaledClientMousePosition;
Rectangle = new RectangleF(pos.X, pos.Y, 1, 1);
if (Manager.IsCtrlModifier && LoadSticker(AnnotationOptions.LastStickerPath, AnnotationOptions.StickerSize))
{

14
ShareX.ScreenCaptureLib/Shapes/Drawing/TextDrawingShape.cs
View file

@ -78,12 +78,12 @@ protected void DrawText(Graphics g)
DrawText(g, Text, TextOptions, Rectangle);
}
protected void DrawText(Graphics g, string text, TextDrawingOptions options, Rectangle rect)
protected void DrawText(Graphics g, string text, TextDrawingOptions options, RectangleF rect)
{
DrawText(g, text, options.Color, options, rect);
}
protected void DrawText(Graphics g, string text, Color textColor, TextDrawingOptions options, Rectangle rect)
protected void DrawText(Graphics g, string text, Color textColor, TextDrawingOptions options, RectangleF rect)
{
if (!string.IsNullOrEmpty(text) && rect.Width > 10 && rect.Height > 10)
{
@ -100,8 +100,8 @@ protected void DrawText(Graphics g, string text, Color textColor, TextDrawingOpt
public override void OnCreating()
{
Point pos = Manager.Form.ScaledClientMousePosition;
Rectangle = new Rectangle(pos.X, pos.Y, 1, 1);
PointF pos = Manager.Form.ScaledClientMousePosition;
Rectangle = new RectangleF(pos.X, pos.Y, 1, 1);
if (ShowTextInputBox())
{
@ -168,18 +168,18 @@ public void AutoSize(bool center)
size = new Size(100, 60);
}
Point location;
PointF location;
if (center)
{
location = new Point(Rectangle.X - (size.Width / 2), Rectangle.Y - (size.Height / 2));
location = new PointF(Rectangle.X - (size.Width / 2), Rectangle.Y - (size.Height / 2));
}
else
{
location = Rectangle.Location;
}
Rectangle = new Rectangle(location, size);
Rectangle = new RectangleF(location, size);
}
}
}

4
ShareX.ScreenCaptureLib/Shapes/Drawing/TextOutlineDrawingShape.cs
View file

@ -60,7 +60,7 @@ public override void OnDraw(Graphics g)
DrawTextWithOutline(g, Text, TextOptions, TextOptions.Color, BorderColor, BorderSize, Rectangle);
}
protected void DrawTextWithOutline(Graphics g, string text, TextDrawingOptions options, Color textColor, Color borderColor, int borderSize, Rectangle rect)
protected void DrawTextWithOutline(Graphics g, string text, TextDrawingOptions options, Color textColor, Color borderColor, int borderSize, RectangleF rect)
{
if (!string.IsNullOrEmpty(text) && rect.Width > 10 && rect.Height > 10)
{
@ -123,7 +123,7 @@ protected void DrawTextWithOutline(Graphics g, string text, TextDrawingOptions o
{
if (TextOptions.Gradient)
{
textBrush = new LinearGradientBrush(Rectangle.Round(pathRect).Offset(1), textColor, TextOptions.Color2, TextOptions.GradientMode);
textBrush = new LinearGradientBrush(System.Drawing.Rectangle.Round(pathRect).Offset(1), textColor, TextOptions.Color2, TextOptions.GradientMode);
}
else
{

2
ShareX.ScreenCaptureLib/Shapes/Effect/BaseEffectShape.cs
View file

@ -109,7 +109,7 @@ public void OnDrawOverlay(Graphics g, string overlayText)
public virtual void OnDrawFinal(Graphics g, Bitmap bmp)
{
Rectangle rect = Rectangle.Intersect(new Rectangle(0, 0, bmp.Width, bmp.Height), Rectangle);
RectangleF rect = RectangleF.Intersect(new Rectangle(0, 0, bmp.Width, bmp.Height), Rectangle);
if (!rect.IsEmpty)
{

2
ShareX.ScreenCaptureLib/Shapes/Region/EllipseRegionShape.cs
View file

@ -32,7 +32,7 @@ public class EllipseRegionShape : BaseRegionShape
{
public override ShapeType ShapeType { get; } = ShapeType.RegionEllipse;
public override void OnShapePathRequested(GraphicsPath gp, Rectangle rect)
public override void OnShapePathRequested(GraphicsPath gp, RectangleF rect)
{
gp.AddEllipse(rect);
}

12
ShareX.ScreenCaptureLib/Shapes/Region/FreehandRegionShape.cs
View file

@ -34,7 +34,7 @@ public class FreehandRegionShape : BaseRegionShape
{
public override ShapeType ShapeType { get; } = ShapeType.RegionFreehand;
public Point LastPosition
public PointF LastPosition
{
get
{
@ -43,7 +43,7 @@ public Point LastPosition
return points[points.Count - 1];
}
return Point.Empty;
return PointF.Empty;
}
set
{
@ -54,7 +54,7 @@ public Point LastPosition
}
}
private List<Point> points = new List<Point>();
private List<PointF> points = new List<PointF>();
private bool isPolygonMode;
protected override void UseLightResizeNodes()
@ -72,7 +72,7 @@ public override void OnUpdate()
}
else
{
Point pos = Manager.Form.ScaledClientMousePosition;
PointF pos = Manager.Form.ScaledClientMousePosition;
if (points.Count == 0 || (!Manager.IsProportionalResizing && LastPosition != pos))
{
@ -100,7 +100,7 @@ public override void OnUpdate()
}
}
public override void OnShapePathRequested(GraphicsPath gp, Rectangle rect)
public override void OnShapePathRequested(GraphicsPath gp, RectangleF rect)
{
if (points.Count > 2)
{
@ -112,7 +112,7 @@ public override void OnShapePathRequested(GraphicsPath gp, Rectangle rect)
}
}
public override void Move(int x, int y)
public override void Move(float x, float y)
{
for (int i = 0; i < points.Count; i++)
{

2
ShareX.ScreenCaptureLib/Shapes/Region/RectangleRegionShape.cs
View file

@ -45,7 +45,7 @@ public override void OnConfigSave()
AnnotationOptions.RegionCornerRadius = CornerRadius;
}
public override void OnShapePathRequested(GraphicsPath gp, Rectangle rect)
public override void OnShapePathRequested(GraphicsPath gp, RectangleF rect)
{
gp.AddRoundedRectangle(rect, CornerRadius);
}

76
ShareX.ScreenCaptureLib/Shapes/ShapeManager.cs
View file

@ -133,7 +133,7 @@ public ShapeType CurrentShapeTool
}
}
public Rectangle CurrentRectangle
public RectangleF CurrentRectangle
{
get
{
@ -142,7 +142,7 @@ public Rectangle CurrentRectangle
return CurrentShape.Rectangle;
}
return Rectangle.Empty;
return RectangleF.Empty;
}
}
@ -184,7 +184,7 @@ private set
}
}
public Rectangle PreviousHoverRectangle { get; private set; }
public RectangleF PreviousHoverRectangle { get; private set; }
public bool IsCurrentHoverShapeValid => CurrentHoverShape != null && CurrentHoverShape.IsValidShape;
@ -254,7 +254,7 @@ public bool IsPanning
// Is holding Alt?
public bool IsSnapResizing { get; private set; }
public bool IsRenderingOutput { get; private set; }
public Point RenderOffset { get; private set; }
public PointF RenderOffset { get; private set; }
public bool IsImageModified { get; internal set; }
public InputManager InputManager { get; private set; } = new InputManager();
@ -1038,7 +1038,7 @@ private void EndPanning()
IsPanning = false;
}
internal void UpdateObjects(ImageEditorControl[] objects, Point mousePosition)
internal void UpdateObjects(ImageEditorControl[] objects, PointF mousePosition)
{
if (objects.All(x => !x.IsDragging))
{
@ -1054,7 +1054,7 @@ internal void UpdateObjects(ImageEditorControl[] objects, Point mousePosition)
{
if (InputManager.IsMousePressed(MouseButtons.Left))
{
obj.OnMouseDown(mousePosition);
obj.OnMouseDown(mousePosition.Round());
}
for (int j = i + 1; j < objects.Length; j++)
@ -1079,7 +1079,7 @@ internal void UpdateObjects(ImageEditorControl[] objects, Point mousePosition)
{
if (obj.IsDragging)
{
obj.OnMouseUp(mousePosition);
obj.OnMouseUp(mousePosition.Round());
}
}
}
@ -1233,9 +1233,9 @@ private void SwapShapeType()
}
}
public Point SnapPosition(Point posOnClick, Point posCurrent)
public PointF SnapPosition(PointF posOnClick, PointF posCurrent)
{
Size currentSize = CaptureHelpers.CreateRectangle(posOnClick, posCurrent).Size;
SizeF currentSize = CaptureHelpers.CreateRectangle(posOnClick, posCurrent).Size;
Vector2 vector = new Vector2(currentSize.Width, currentSize.Height);
SnapSize snapSize = (from size in Options.SnapSizes
@ -1246,11 +1246,11 @@ orderby distance
if (snapSize != null)
{
Point posNew = CaptureHelpers.CalculateNewPosition(posOnClick, posCurrent, snapSize);
PointF posNew = CaptureHelpers.CalculateNewPosition(posOnClick, posCurrent, snapSize);
Rectangle newRect = CaptureHelpers.CreateRectangle(posOnClick, posNew);
RectangleF newRect = CaptureHelpers.CreateRectangle(posOnClick, posNew);
if (Form.ClientArea.Contains(newRect))
if (Form.ClientArea.Contains(newRect.Round()))
{
return posNew;
}
@ -1295,10 +1295,10 @@ private BaseShape CheckHover()
if (Options.IsFixedSize && IsCurrentShapeTypeRegion)
{
Point location = Form.ScaledClientMousePosition;
PointF location = Form.ScaledClientMousePosition;
BaseShape rectangleRegionShape = CreateShape(ShapeType.RegionRectangle);
rectangleRegionShape.Rectangle = new Rectangle(new Point(location.X - (Options.FixedSize.Width / 2),
rectangleRegionShape.Rectangle = new RectangleF(new PointF(location.X - (Options.FixedSize.Width / 2),
location.Y - (Options.FixedSize.Height / 2)), Options.FixedSize);
return rectangleRegionShape;
}
@ -1351,7 +1351,7 @@ public Bitmap RenderOutputImage(Bitmap bmp)
return RenderOutputImage(bmp, Point.Empty);
}
public Bitmap RenderOutputImage(Bitmap bmp, Point offset)
public Bitmap RenderOutputImage(Bitmap bmp, PointF offset)
{
Bitmap bmpOutput = (Bitmap)bmp.Clone();
@ -1494,7 +1494,7 @@ public BaseShape GetIntersectShape()
return GetIntersectShape(Form.ScaledClientMousePosition);
}
public BaseShape GetIntersectShape(Point position)
public BaseShape GetIntersectShape(PointF position)
{
if (!IsCtrlModifier)
{
@ -1605,7 +1605,7 @@ public void MoveCurrentShapeUp()
MoveShapeUp(CurrentShape);
}
public void MoveAll(int x, int y)
public void MoveAll(float x, float y)
{
if (x != 0 || y != 0)
{
@ -1616,7 +1616,7 @@ public void MoveAll(int x, int y)
}
}
public void MoveAll(Point offset)
public void MoveAll(PointF offset)
{
MoveAll(offset.X, offset.Y);
}
@ -1729,7 +1729,7 @@ private void PasteFromClipboard(bool insertMousePosition)
if (!string.IsNullOrEmpty(text))
{
Point pos;
PointF pos;
if (insertMousePosition)
{
@ -1742,7 +1742,7 @@ private void PasteFromClipboard(bool insertMousePosition)
CurrentTool = ShapeType.DrawingTextBackground;
TextDrawingShape shape = (TextDrawingShape)CreateShape(ShapeType.DrawingTextBackground);
shape.Rectangle = new Rectangle(pos.X, pos.Y, 1, 1);
shape.Rectangle = new RectangleF(pos.X, pos.Y, 1, 1);
shape.Text = text.Trim();
shape.OnCreated();
AddShape(shape);
@ -1758,7 +1758,7 @@ public void AddCursor(IntPtr cursorHandle, Point position)
Shapes.Add(shape);
}
public void DrawRegionArea(Graphics g, Rectangle rect, bool isAnimated, bool showAreaInfo = false)
public void DrawRegionArea(Graphics g, RectangleF rect, bool isAnimated, bool showAreaInfo = false)
{
Form.DrawRegionArea(g, rect, isAnimated);
@ -1781,7 +1781,7 @@ public void UpdateCanvas(Bitmap canvas, bool centerCanvas = true)
OnImageModified();
}
public void CropArea(Rectangle rect)
public void CropArea(RectangleF rect)
{
Bitmap bmp = CropImage(rect, true);
@ -1792,10 +1792,10 @@ public void CropArea(Rectangle rect)
}
}
public Bitmap CropImage(Rectangle rect, bool onlyIfSizeDifferent = false)
public Bitmap CropImage(RectangleF rect, bool onlyIfSizeDifferent = false)
{
rect = CaptureHelpers.ScreenToClient(rect);
Point offset = CaptureHelpers.ScreenToClient(Form.CanvasRectangle.Location);
rect = CaptureHelpers.ScreenToClient(rect.Round());
PointF offset = CaptureHelpers.ScreenToClient(Form.CanvasRectangle.Location.Round());
rect.X -= offset.X;
rect.Y -= offset.Y;
rect.Intersect(new Rectangle(0, 0, Form.Canvas.Width, Form.Canvas.Height));
@ -1813,7 +1813,7 @@ public Color GetColor(Bitmap bmp, Point pos)
if (bmp != null)
{
Point position = CaptureHelpers.ScreenToClient(pos);
Point offset = CaptureHelpers.ScreenToClient(Form.CanvasRectangle.Location);
Point offset = CaptureHelpers.ScreenToClient(Form.CanvasRectangle.Location.Round());
position.X -= offset.X;
position.Y -= offset.Y;
@ -1828,7 +1828,7 @@ public Color GetColor(Bitmap bmp, Point pos)
public Color GetCurrentColor(Bitmap bmp)
{
return GetColor(bmp, Form.ScaledClientMousePosition);
return GetColor(bmp, Form.ScaledClientMousePosition.Round());
}
public Color GetCurrentColor()
@ -1922,7 +1922,7 @@ private void InsertImage(Image img)
{
if (img != null)
{
Point pos;
PointF pos;
bool centerImage;
using (ImageInsertForm imageInsertForm = new ImageInsertForm())
@ -1939,21 +1939,21 @@ private void InsertImage(Image img)
centerImage = true;
break;
case ImageInsertMethod.CanvasExpandDown:
pos = new Point(Form.CanvasRectangle.X, Form.CanvasRectangle.Bottom);
pos = new PointF(Form.CanvasRectangle.X, Form.CanvasRectangle.Bottom);
centerImage = false;
ChangeCanvasSize(new Padding(0, 0, Math.Max(0, img.Width - Form.CanvasRectangle.Width), img.Height), Options.EditorCanvasColor);
ChangeCanvasSize(new Padding(0, 0, (int)Math.Round(Math.Max(0, img.Width - Form.CanvasRectangle.Width)), img.Height), Options.EditorCanvasColor);
break;
case ImageInsertMethod.CanvasExpandRight:
pos = new Point(Form.CanvasRectangle.Right, Form.CanvasRectangle.Y);
pos = new PointF(Form.CanvasRectangle.Right, Form.CanvasRectangle.Y);
centerImage = false;
ChangeCanvasSize(new Padding(0, 0, img.Width, Math.Max(0, img.Height - Form.CanvasRectangle.Height)), Options.EditorCanvasColor);
ChangeCanvasSize(new Padding(0, 0, img.Width, (int)Math.Round(Math.Max(0, img.Height - Form.CanvasRectangle.Height))), Options.EditorCanvasColor);
break;
}
}
CurrentTool = ShapeType.DrawingImage;
ImageDrawingShape shape = (ImageDrawingShape)CreateShape(ShapeType.DrawingImage);
shape.Rectangle = new Rectangle(pos.X, pos.Y, 1, 1);
shape.Rectangle = new RectangleF(pos.X, pos.Y, 1, 1);
shape.SetImage(img, centerImage);
shape.OnCreated();
AddShape(shape);
@ -2016,13 +2016,13 @@ private void ChangeCanvasSize()
public void AutoResizeCanvas()
{
Rectangle canvas = Form.CanvasRectangle;
Rectangle combinedImageRectangle = Shapes.OfType<ImageDrawingShape>().Select(x => x.Rectangle).Combine();
RectangleF canvas = Form.CanvasRectangle;
RectangleF combinedImageRectangle = Shapes.OfType<ImageDrawingShape>().Select(x => x.Rectangle).Combine();
if (!canvas.Contains(combinedImageRectangle))
{
Padding margin = new Padding(Math.Max(0, canvas.X - combinedImageRectangle.X), Math.Max(0, canvas.Y - combinedImageRectangle.Y),
Math.Max(0, combinedImageRectangle.Right - canvas.Right), Math.Max(0, combinedImageRectangle.Bottom - canvas.Bottom));
Padding margin = new Padding((int)Math.Round(Math.Max(0, canvas.X - combinedImageRectangle.X)), (int)Math.Round(Math.Max(0, canvas.Y - combinedImageRectangle.Y)),
(int)Math.Round(Math.Max(0, combinedImageRectangle.Right - canvas.Right)), (int)Math.Round(Math.Max(0, combinedImageRectangle.Bottom - canvas.Bottom)));
ChangeCanvasSize(margin, Options.EditorCanvasColor);
}
}
@ -2051,7 +2051,7 @@ private void AddCropTool()
private void AutoCropImage()
{
Rectangle source = new Rectangle(0, 0, Form.Canvas.Width, Form.Canvas.Height);
Rectangle crop;
RectangleF crop;
using (Bitmap resultImage = Form.GetResultImage())
{

8
ShareX.ScreenCaptureLib/Shapes/Tool/CropTool.cs
View file

@ -49,16 +49,16 @@ public override void OnUpdate()
Rectangle.Width > (buttonSize.Width * 2) + (buttonOffset * 3) &&
Rectangle.Height > buttonSize.Height + (buttonOffset * 2))
{
confirmButton.Rectangle = new Rectangle(Rectangle.Right - (buttonOffset * 2) - (buttonSize.Width * 2),
confirmButton.Rectangle = new RectangleF(Rectangle.Right - (buttonOffset * 2) - (buttonSize.Width * 2),
Rectangle.Bottom - buttonOffset - buttonSize.Height, buttonSize.Width, buttonSize.Height);
cancelButton.Rectangle = new Rectangle(Rectangle.Right - buttonOffset - buttonSize.Width,
cancelButton.Rectangle = new RectangleF(Rectangle.Right - buttonOffset - buttonSize.Width,
Rectangle.Bottom - buttonOffset - buttonSize.Height, buttonSize.Width, buttonSize.Height);
}
else
{
confirmButton.Rectangle = new Rectangle(Rectangle.Right - (buttonSize.Width * 2) - buttonOffset,
confirmButton.Rectangle = new RectangleF(Rectangle.Right - (buttonSize.Width * 2) - buttonOffset,
Rectangle.Bottom + buttonOffset, buttonSize.Width, buttonSize.Height);
cancelButton.Rectangle = new Rectangle(Rectangle.Right - buttonSize.Width,
cancelButton.Rectangle = new RectangleF(Rectangle.Right - buttonSize.Width,
Rectangle.Bottom + buttonOffset, buttonSize.Width, buttonSize.Height);
}
}