Pilz.NET/Pilz
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Pilz.UI: convert to C#

Browse Source
This commit is contained in:
Pascal
2024-06-10 12:29:56 +02:00
parent b9be604f0d
commit 5c6f0c8bfc
32 changed files with 3950 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
Pilz.UI/PaintingControl/ArrowLineCapProps.cs Normal file
View File

@@ -0,0 +1,18 @@
using System.Drawing;
using System.Drawing.Drawing2D;
namespace Pilz.UI;
public class ArrowLineCapProps : LineCapProps
{
public Size Size { get; set; } = new Size(10, 10);
public bool IsFilles { get; set; } = true;
internal override LineCapConfigurationArgs Configure()
{
var cap = new AdjustableArrowCap(Size.Width, Size.Height, IsFilles);
return new LineCapConfigurationArgs(cap);
}
}

284
Pilz.UI/PaintingControl/DefaultDrawMethodes.cs Normal file
View File

@@ -0,0 +1,284 @@
using Pilz.Drawing;
using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
namespace Pilz.UI;
/// <summary>
/// Contains static methods that are used for the standart PaintingObject Types.
/// </summary>
public class DefaultDrawMethodes
{
public static void DrawText(PaintingObjectPaintEventArgs e)
{
var obj = e.PaintingObject;
var b = new SolidBrush(obj.TextColor);
var p = new PointF();
var rect = new Rectangle((int)Math.Round(e.X), (int)Math.Round(e.Y), (int)Math.Round(obj.Width), (int)Math.Round(obj.Height));
var f = StringFormat.GenericDefault;
f.Alignment = obj.HorizontalTextAlignment;
f.LineAlignment = obj.VerticalTextAlignment;
float zoomFactor;
if (obj.Parent is null)
zoomFactor = 1.0f;
else
{
zoomFactor = obj.Parent.ZoomFactor.Width;
}
e.Graphics.DrawString(obj.Text, new Font(obj.TextFont.FontFamily, obj.TextFont.Size * zoomFactor, obj.TextFont.Style), b, rect, f);
}
private static object _DrawPicture_newSyncObj = new object();
public static void DrawPicture(PaintingObjectPaintEventArgs e)
{
var obj = e.PaintingObject;
Image objImg;
Size objImgSize;
RectangleF result;
Bitmap image;
SizeF zoomf;
bool hasNoParent = e.PaintingObject.Parent is null;
object syncObj;
if (hasNoParent)
{
zoomf = new SizeF(1f, 1f);
syncObj = _DrawPicture_newSyncObj;
}
else
{
zoomf = e.PaintingObject.Parent.ZoomFactor;
syncObj = e.PaintingObject.Parent;
}
lock (syncObj)
{
if (obj?.Image is null)
return;
objImg = obj.Image;
objImgSize = objImg.Size;
}
image = (Bitmap)obj.BufferedImage;
result = CalculateImageResolution(obj, objImgSize, zoomf);
if (obj.ImageProperties.Rotate == 90 || obj.ImageProperties.Rotate == 270)
result = CalculateImageResolution(obj, new SizeF(objImgSize.Height, objImgSize.Width), zoomf);
if (image is null)
{
bool needRescaleImageBecauseRot = false;
image = DrawToNewImage((Bitmap)objImg, result.Size);
switch (obj.ImageProperties.Rotate)
{
case 90:
{
image.RotateFlip(RotateFlipType.Rotate90FlipNone);
needRescaleImageBecauseRot = true;
break;
}
case 180:
{
image.RotateFlip(RotateFlipType.Rotate180FlipNone);
break;
}
case 270:
{
image.RotateFlip(RotateFlipType.Rotate270FlipNone);
needRescaleImageBecauseRot = true;
break;
}
}
if (obj.ImageProperties.FlipX)
image.RotateFlip(RotateFlipType.RotateNoneFlipX);
if (obj.ImageProperties.FlipY)
image.RotateFlip(RotateFlipType.RotateNoneFlipY);
if (needRescaleImageBecauseRot)
{
result = CalculateImageResolution(obj, new SizeF(objImgSize.Height, objImgSize.Width), zoomf);
image = DrawToNewImage(image, result.Size);
}
obj.BufferedImage = image;
}
if (image is not null)
{
lock (syncObj)
e.Graphics.DrawImageUnscaled(image, new Rectangle(new Point((int)Math.Round(obj.Location.X + result.Location.X - e.Offset.X), (int)Math.Round(obj.Location.Y + result.Location.Y - e.Offset.Y)), result.Size.ToSize()));
}
}
private static Bitmap DrawToNewImage(Bitmap image, SizeF newSize)
{
var bmp = new Bitmap((int)Math.Round(newSize.Width < 0f ? newSize.Width * -1 : newSize.Width), (int)Math.Round(newSize.Height < 0f ? newSize.Height * -1 : newSize.Height));
var gimage = Graphics.FromImage(bmp);
gimage.SmoothingMode = SmoothingMode.HighQuality;
gimage.PixelOffsetMode = PixelOffsetMode.HighQuality;
gimage.PageUnit = GraphicsUnit.Pixel;
gimage.InterpolationMode = InterpolationMode.HighQualityBicubic;
gimage.DrawImage(image, new RectangleF(PointF.Empty, newSize));
gimage.Dispose();
return bmp;
}
public static void DrawLine(PaintingObjectPaintEventArgs e)
{
var obj = e.PaintingObject;
var p2 = new Pen(obj.OutlineColor, obj.OutlineThicknes) { DashStyle = obj.OutlineDashStyle };
if (obj.LineEndCap is not null)
{
var args = obj.LineEndCap.Configure();
p2.StartCap = args.LineCap;
p2.CustomStartCap = args.CustomLineCap;
}
if (obj.LineStartCap is not null)
{
var args = obj.LineStartCap.Configure();
p2.EndCap = args.LineCap;
p2.CustomEndCap = args.CustomLineCap;
}
p2.Alignment = PenAlignment.Center;
var no = new PointF(e.X, e.Y);
e.Graphics.DrawLine(p2, no, no + obj.Size);
}
private static RectangleF CalculateImageResolution(PaintingObject obj, SizeF imageSize, SizeF zoom)
{
var result = new RectangleF();
var objrect = new RectangleF(obj.Location, obj.Size);
var size = new SizeF(imageSize.Width * zoom.Width, imageSize.Height * zoom.Height);
var clientRectangle = objrect;
float val = clientRectangle.Width / size.Width;
clientRectangle = objrect;
float num = Math.Min(val, clientRectangle.Height / size.Height);
result.Width = (int)Math.Round(Math.Truncate((double)(size.Width * num)));
result.Height = (int)Math.Round(Math.Truncate((double)(size.Height * num)));
clientRectangle = objrect;
result.X = (long)Math.Round(clientRectangle.Width - result.Width) / 2L;
clientRectangle = objrect;
result.Y = (long)Math.Round(clientRectangle.Height - result.Height) / 2L;
return result;
}
public static void DrawTriangle(PaintingObjectPaintEventArgs e)
{
var obj = e.PaintingObject;
var p1 = new Point((int)Math.Round(obj.Size.Width / 2f + e.X), (int)Math.Round(e.Y));
var p2 = new Point((int)Math.Round(e.X), (int)Math.Round(e.Y + obj.Size.Height));
var p3 = new Point((int)Math.Round(e.X + obj.Size.Width), (int)Math.Round(e.Y + obj.Size.Height));
if (obj.EnableFill)
{
var b = new SolidBrush(obj.FillColor);
e.Graphics.FillPolygon(b, new[] { p1, p2, p3 });
}
if (obj.EnableOutline)
{
float lw = obj.OutlineThicknes;
var p = new Pen(obj.OutlineColor, obj.OutlineThicknes) { DashStyle = obj.OutlineDashStyle, Alignment = PenAlignment.Inset };
e.Graphics.DrawPolygon(p, new[] { p1, p2, p3 });
}
}
public static void DrawRectangle(PaintingObjectPaintEventArgs e)
{
var obj = e.PaintingObject;
float hol = obj.OutlineThicknes / 2f;
if (obj.EnableFill)
{
var b = new SolidBrush(obj.FillColor);
var rect = obj.EnableOutline ? new Rectangle((int)Math.Round(e.X + hol), (int)Math.Round(e.Y + hol), (int)Math.Round(obj.Size.Width - hol * 2f), (int)Math.Round(obj.Size.Height - hol * 2f)) : new Rectangle((int)Math.Round(e.X), (int)Math.Round(e.Y), (int)Math.Round(obj.Size.Width), (int)Math.Round(obj.Size.Height));
e.Graphics.FillRectangle(b, rect);
}
if (obj.EnableOutline)
{
var p = new Pen(obj.OutlineColor, obj.OutlineThicknes) { DashStyle = obj.OutlineDashStyle, Alignment = PenAlignment.Inset };
var rect = new Rectangle((int)Math.Round(e.X), (int)Math.Round(e.Y), (int)Math.Round(obj.Size.Width), (int)Math.Round(obj.Size.Height));
e.Graphics.DrawRectangle(p, rect);
}
}
public static void DrawEllipse(PaintingObjectPaintEventArgs e)
{
var obj = e.PaintingObject;
if (obj.EnableFill)
{
var b = new SolidBrush(obj.FillColor);
var rect = new Rectangle((int)Math.Round(e.X), (int)Math.Round(e.Y), (int)Math.Round(obj.Size.Width), (int)Math.Round(obj.Size.Height));
e.Graphics.FillEllipse(b, rect);
}
if (obj.EnableOutline)
{
var p = new Pen(obj.OutlineColor, obj.OutlineThicknes) { DashStyle = obj.OutlineDashStyle, Alignment = PenAlignment.Inset };
var rect = new Rectangle((int)Math.Round(e.X), (int)Math.Round(e.Y), (int)Math.Round(obj.Size.Width), (int)Math.Round(obj.Size.Height));
e.Graphics.DrawEllipse(p, rect);
}
}
public static void DrawSelection(PaintingObjectPaintEventArgs e)
{
var obj = e.PaintingObject;
float lw = 2.5f;
float hlw = lw / 2f;
float hlwphol = hlw; // + hol
float hlwpholm2 = hlwphol * 2f;
var p = new Pen(Color.CornflowerBlue, lw) { DashStyle = obj.SelectionDashStyle, Alignment = PenAlignment.Outset };
var rect = new Rectangle((int)Math.Round(e.X - hlwphol), (int)Math.Round(e.Y - hlwphol), (int)Math.Round(obj.Size.Width + hlwpholm2), (int)Math.Round(obj.Size.Height + hlwpholm2));
e.Graphics.DrawRectangle(p, rect);
}
public static void DrawGrid(PaintEventArgs e, PaintingControl pc, PointF offset)
{
var p = new Pen(pc.GridColor, 0.5f);
int curX = (int)Math.Round(pc.GridChunkSize.Width * pc.ZoomFactor.Width - offset.X);
while (curX < pc.Width)
{
e.Graphics.DrawLine(p, curX, -offset.Y, curX, pc.Height);
curX = (int)Math.Round(curX + pc.GridChunkSize.Width * pc.ZoomFactor.Width);
}
int curY = (int)Math.Round(pc.GridChunkSize.Height * pc.ZoomFactor.Height - offset.Y);
while (curY < pc.Height)
{
e.Graphics.DrawLine(p, -offset.X, curY, pc.Width, curY);
curY = (int)Math.Round(curY + pc.GridChunkSize.Height * pc.ZoomFactor.Height);
}
}
public static void DrawAreaSelection(PaintEventArgs e, PaintingControl pc, PointF startMousePos, PointF lastMousePos)
{
var rectToDraw = HelpfulDrawingFunctions.GetRectangle(startMousePos, lastMousePos);
var p = new Pen(pc.AreaSelectionColor);
p.DashStyle = startMousePos.X >= lastMousePos.X ? DashStyle.DashDot : DashStyle.Solid;
p.Width = 3f;
e.Graphics.DrawRectangle(p, rectToDraw.X, rectToDraw.Y, rectToDraw.Width, rectToDraw.Height);
}
}

17
Pilz.UI/PaintingControl/DefaultLineCapProps.cs Normal file
View File

@@ -0,0 +1,17 @@
using System.Drawing.Drawing2D;
namespace Pilz.UI;
public class DefaultLineCapProps : LineCapProps
{
public LineCap LineCap { get; set; } = LineCap.Flat;
public CustomLineCap CustomLineCap { get; set; } = null;
internal override LineCapConfigurationArgs Configure()
{
return new LineCapConfigurationArgs(LineCap, CustomLineCap);
}
}

8
Pilz.UI/PaintingControl/EventArgs/PaintingObjectEventArgs.cs Normal file
View File

@@ -0,0 +1,8 @@
using System;
namespace Pilz.UI;
public class PaintingObjectEventArgs(PaintingObject[] paintingObjects) : EventArgs
{
public PaintingObject[] PaintingObjects { get; private set; } = paintingObjects;
}

53
Pilz.UI/PaintingControl/EventArgs/PaintingObjectPaintEventArgs.cs Normal file
View File

@@ -0,0 +1,53 @@
using System;
using System.Drawing;
namespace Pilz.UI;
public class PaintingObjectPaintEventArgs(PaintingObject obj, Graphics g, PointF offset) : EventArgs
{
/// <summary>
/// The Painting Object to draw.
/// </summary>
/// <returns></returns>
public PaintingObject PaintingObject { get; } = obj;
/// <summary>
/// The current offset of the page on the screen.
/// </summary>
/// <returns></returns>
public PointF Offset { get; } = offset;
/// <summary>
/// The Grpahics from the parent PaintingControl.
/// </summary>
/// <returns></returns>
public Graphics Graphics { get; } = g;
/// <summary>
/// The position of the PaintingObject on Screen.
/// </summary>
/// <returns></returns>
public PointF Location => new(X, Y);
/// <summary>
/// The X position of the PaintingObject on Screen.
/// </summary>
/// <returns></returns>
public float X => PaintingObject.X - Offset.X;
/// <summary>
/// The Y position of the PaintingObject on Screen.
/// </summary>
/// <returns></returns>
public float Y => PaintingObject.Y - Offset.Y;
/// <summary>
/// The rectangle of the PaintingObject on Screen.
/// </summary>
/// <returns></returns>
public RectangleF Rectangle => new RectangleF(X, Y, PaintingObject.Width, PaintingObject.Height);
public PaintingObjectPaintEventArgs(PaintingObject obj, Graphics g) : this(obj, g, obj.Parent.Offset)
{
}
}

7
Pilz.UI/PaintingControl/IPaintingObjectContainer.cs Normal file
View File

@@ -0,0 +1,7 @@
namespace Pilz.UI;
public interface IPaintingObjectContainer
{
}

9
Pilz.UI/PaintingControl/ImageProperties.cs Normal file
View File

@@ -0,0 +1,9 @@
namespace Pilz.UI;
public class PaintingObjectImageProperties
{
public bool FlipY { get; set; } = false;
public bool FlipX { get; set; } = false;
public ushort Rotate { get; set; } = 0;
}

26
Pilz.UI/PaintingControl/LineCapConfigurationArgs.cs Normal file
View File

@@ -0,0 +1,26 @@
using System.Drawing.Drawing2D;
namespace Pilz.UI;
public class LineCapConfigurationArgs
{
public LineCap LineCap { get; private set; }
public CustomLineCap CustomLineCap { get; private set; }
public LineCapConfigurationArgs(LineCap lineCap) : this(lineCap, null)
{
}
public LineCapConfigurationArgs(CustomLineCap customLineCap) : this(default, customLineCap)
{
}
public LineCapConfigurationArgs(LineCap lineCap, CustomLineCap customLineCap)
{
LineCap = lineCap;
CustomLineCap = customLineCap;
}
}

9
Pilz.UI/PaintingControl/LineCapProps.cs Normal file
View File

@@ -0,0 +1,9 @@
namespace Pilz.UI;
public abstract class LineCapProps
{
internal abstract LineCapConfigurationArgs Configure();
}

785
Pilz.UI/PaintingControl/PaintingControl.cs Normal file
View File

@@ -0,0 +1,785 @@
using Microsoft.VisualBasic.CompilerServices;
using Pilz.Drawing;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Windows.Forms;
namespace Pilz.UI;
public class PaintingControl : UserControl, IPaintingObjectContainer
{
private PaintingObject curObjMouseDown = null;
private Color bgColor = Color.White;
private Point startMousePos = default;
private Point lastMousePos = default;
private int lastHashCode = 0;
private Point calcOffset_MouseOnTab = Point.Empty;
private bool calcOffset_IsActive = false;
private PointF calcOffset_LastOffset = PointF.Empty;
private new Color ForeColor { get; set; }
private new Font Font { get; set; }
private new string Text { get; set; }
public PointF Offset { get; set; } = PointF.Empty;
public PaintingObjectList PaintingObjects { get; private set; } = new PaintingObjectList(this);
public bool VisibleForMouseEvents { get; set; } = true;
public bool AutoAreaSelection { get; set; } = true;
public bool AutoSingleSelection { get; set; } = true;
public bool AutoMultiselection { get; set; } = true;
public bool AutoRemoveSelection { get; set; } = true;
public DashStyle AreaSelectionDashStyle { get; set; } = DashStyle.DashDot;
public Color AreaSelectionColor { get; set; } = Color.CornflowerBlue;
public bool AutoMoveObjects { get; set; } = true;
private bool _IsAreaSelecting = false;
public bool IsMovingObjects { get; private set; } = false;
public bool GridEnabled { get; set; } = true;
public bool GridVisible { get; set; } = false;
public Size GridChunkSize { get; set; } = new Size(20, 20);
public Color GridColor { get; set; } = Color.LightGray;
public DelegateDrawPaintingControlGridMethode DrawGridMethode { get; set; } = DefaultDrawMethodes.DrawGrid;
public DelegateDrawPaintingControlAreaSelectionMethode DrawAreaSelectionMethode { get; set; } = DefaultDrawMethodes.DrawAreaSelection;
private SizeF _ZoomFactor = new SizeF(1f, 1f);
private int _stopDrawing = -1;
private Image bufferedImg = null;
private bool pressedShift = false;
private bool pressedControl = false;
private bool pressedAlt = false;
private Dictionary<PaintingObject, PointF> savedPos = new Dictionary<PaintingObject, PointF>();
public event SelectionChangedEventHandler SelectionChanged;
public delegate void SelectionChangedEventHandler(object sender, PaintingObjectEventArgs e);
public event PaintingObjectAddedEventHandler PaintingObjectAdded;
public delegate void PaintingObjectAddedEventHandler(object sender, PaintingObjectEventArgs e);
public event PaintingObjectRemovedEventHandler PaintingObjectRemoved;
public delegate void PaintingObjectRemovedEventHandler(object sender, PaintingObjectEventArgs e);
public event AfterScrollingDoneEventHandler AfterScrollingDone;
public delegate void AfterScrollingDoneEventHandler(object sender, EventArgs e);
public event ZoomFactorChangedEventHandler ZoomFactorChanged;
public delegate void ZoomFactorChangedEventHandler(object sender, EventArgs e);
public PaintingObject[] SelectedObjects
{
get
{
var objs = new List<PaintingObject>();
foreach (PaintingObject obj in PaintingObjects)
{
if (obj.Selected)
objs.Add(obj);
}
return objs.ToArray();
}
}
public bool IsLayoutSuspended
{
get
{
return Conversions.ToInteger(GetType().GetField("layoutSuspendCount", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(this)) != 0;
}
}
public bool StopDrawing
{
get
{
return _stopDrawing > -1;
}
}
public override Color BackColor
{
get
{
return bgColor;
}
set
{
bgColor = value;
base.BackColor = value;
// If value <> Color.Transparent Then
// MyBase.BackColor = value
// End If
}
}
public bool IsAreaSelecting
{
get
{
return _IsAreaSelecting && startMousePos != lastMousePos;
}
}
public SizeF ZoomFactor
{
get
{
return _ZoomFactor;
}
set
{
if (_ZoomFactor != value)
{
_ZoomFactor = value;
ResetAllBufferedImages();
ZoomFactorChanged?.Invoke(this, new EventArgs());
}
}
}
public PaintingControl()
{
PaintingObjectResizing.CheckEnabled += PaintingObjectResizing_CheckEnabled;
DoubleBuffered = true;
KeyDown += CheckKeyDown;
KeyUp += CheckKeyDown;
MouseClick += CheckMouseClick;
MouseDown += CheckMouseDown;
MouseUp += CheckMouseUp;
MouseMove += CheckMouseMove;
PaintingObjectAdded += PaintingControl_PaintingObjectAdded;
PaintingObjectRemoved += PaintingControl_PaintingObjectAdded;
MouseWheel += CheckMouseWheel;
}
~PaintingControl()
{
PaintingObjectResizing.CheckEnabled -= PaintingObjectResizing_CheckEnabled;
}
private void PaintingObjectResizing_CheckEnabled(PaintingObjectResizing sender, ref bool enabled)
{
if (PaintingObjects.Contains(sender.PaintingObject) && pressedAlt)
enabled = false;
}
private void ResetAllBufferedImages()
{
foreach (PaintingObject ob in PaintingObjects)
ob.ResetImageBuffer();
Refresh();
}
protected void CheckKeyDown(object sender, KeyEventArgs e)
{
pressedShift = e.Shift;
pressedControl = e.Control;
pressedAlt = e.Alt;
}
internal RectangleF AreaSelectionRectangle
{
get
{
return HelpfulDrawingFunctions.GetRectangle(startMousePos, lastMousePos);
}
}
protected void CheckMouseClick(object sender, MouseEventArgs e)
{
foreach (PaintingObject obj in GetObjects(new Point((int)Math.Round(e.X + Offset.X), (int)Math.Round(e.Y + Offset.Y))))
{
if (!obj.MouseTransparency)
obj.RaiseMouseClick(GetMouseEventArgs(e, obj));
}
}
protected void CheckMouseDown(object sender, MouseEventArgs e)
{
lastMousePos = new Point((int)Math.Round(e.X + Offset.X), (int)Math.Round(e.Y + Offset.Y));
curObjMouseDown = GetObjects(lastMousePos).Where(n => !n.MouseTransparency).LastOrDefault();
curObjMouseDown?.RaiseMouseDown(GetMouseEventArgs(e, curObjMouseDown));
if (curObjMouseDown is null || !curObjMouseDown.Selected || pressedControl)
{
bool hasMovedObjects = false;
if (IsMovingObjects)
{
foreach (PaintingObject obj in GetSelectedObjects())
{
if (HelpfulDrawingFunctions.IsPointInRectangle(lastMousePos, obj.Rectangle))
{
hasMovedObjects = true;
break;
}
}
}
if (!hasMovedObjects && !_IsAreaSelecting)
{
var selChanged = new List<PaintingObject>();
if (AutoRemoveSelection && !pressedControl)
{
foreach (PaintingObject obj in PaintingObjects)
{
if (obj.Selected)
{
obj.SelectedDirect = false;
if (!selChanged.Contains(obj))
selChanged.Add(obj);
}
}
}
if (AutoSingleSelection && curObjMouseDown is not null)
{
var objtosel = curObjMouseDown;
if (objtosel.EnableSelection)
{
objtosel.SelectedDirect = !objtosel.Selected;
if (!selChanged.Contains(objtosel))
selChanged.Add(objtosel);
else
{
selChanged.Remove(objtosel);
}
}
}
SelectionChanged?.Invoke(this, new PaintingObjectEventArgs(selChanged.ToArray()));
}
}
if (pressedAlt)
{
calcOffset_MouseOnTab = new Point(e.X, e.Y);
calcOffset_LastOffset = Offset;
calcOffset_IsActive = true;
Cursor = Cursors.Arrow;
}
else
{
switch (e.Button)
{
case MouseButtons.Left:
{
savedPos.Clear();
if (AutoMoveObjects)
SaveObjectPositions(e, GetSelectedObjects());
if (savedPos.Count > 0)
IsMovingObjects = true;
else if (AutoAreaSelection)
{
startMousePos = new Point((int)Math.Round(e.X + Offset.X), (int)Math.Round(e.Y + Offset.Y));
lastMousePos = startMousePos; // New Point(e.X - Offset.X, e.Y - Offset.Y)
_IsAreaSelecting = true;
}
break;
}
}
}
}
public void RaiseSelectionChanged()
{
SelectionChanged?.Invoke(this, new PaintingObjectEventArgs(SelectedObjects));
}
protected void CheckMouseUp(object sender, MouseEventArgs e)
{
if (_IsAreaSelecting)
_IsAreaSelecting = false;
if (IsMovingObjects)
{
IsMovingObjects = false;
foreach (PaintingObject obj in GetSelectedObjects())
obj.RaiseMoved(new EventArgs());
AutoArrangeToGrid();
}
if (curObjMouseDown is not null)
{
if (!curObjMouseDown.MouseTransparency)
curObjMouseDown.RaiseMouseUp(GetMouseEventArgs(e, curObjMouseDown));
curObjMouseDown = null;
}
if (calcOffset_IsActive)
{
calcOffset_IsActive = false;
Cursor = Cursors.Default;
CalcNewOffset(e.Location);
AfterScrollingDone?.Invoke(this, new EventArgs());
}
}
protected void CheckMouseMove(object sender, MouseEventArgs e)
{
if (_IsAreaSelecting || IsMovingObjects)
lastMousePos = new Point((int)Math.Round(e.X + Offset.X), (int)Math.Round(e.Y + Offset.Y));
if (_IsAreaSelecting)
SelectControlsInArea();
if (IsMovingObjects)
UpdateObjectPositions(e);
foreach (PaintingObject obj in GetObjects(new Point((int)Math.Round(e.X + Offset.X), (int)Math.Round(e.Y + Offset.Y))))
{
if (!obj.MouseTransparency)
obj.RaiseMouseMove(GetMouseEventArgs(e, obj));
}
var topObj = GetObject(new Point((int)Math.Round(e.X + Offset.X), (int)Math.Round(e.Y + Offset.Y)), true);
if (topObj is not null)
Cursor = topObj.Cursor;
else if (calcOffset_IsActive)
{
Cursor = Cursors.Arrow;
}
else
{
Cursor = Cursors.Default;
}
if (calcOffset_IsActive)
{
if (pressedAlt)
CalcNewOffset(e.Location);
else
{
calcOffset_IsActive = false;
}
}
Refresh();
}
private void CalcNewOffset(Point newMousePos)
{
Offset = new PointF(calcOffset_LastOffset.X - (newMousePos.X - calcOffset_MouseOnTab.X), calcOffset_LastOffset.Y - (newMousePos.Y - calcOffset_MouseOnTab.Y));
if (Offset.X < 0f)
Offset = new PointF(0f, Offset.Y);
if (Offset.Y < 0f)
Offset = new PointF(Offset.X, 0f);
}
private PaintingObject[] GetSelectedObjects()
{
var objs = new List<PaintingObject>();
foreach (PaintingObject obj in PaintingObjects)
{
if (obj.Selected)
objs.Add(obj);
}
return objs.ToArray();
}
private void SaveObjectPositions(MouseEventArgs e, IList objs)
{
foreach (PaintingObject obj in objs)
{
if (!obj.HardcodedLocation && !savedPos.ContainsKey(obj))
{
savedPos.Add(obj, new PointF(e.X - obj.Location.X + Offset.X, e.Y - obj.Location.Y + Offset.Y));
SaveObjectPositions(e, obj.PinnedObjects);
}
}
}
private void UpdateObjectPositions(MouseEventArgs e)
{
UpdateObjectPositions(e, GetSelectedObjects());
}
private void UpdateObjectPositions(MouseEventArgs e, IList<PaintingObject> objs, List<PaintingObject> movedObjs = null)
{
if (IsResizingObjs(objs))
return;
if (movedObjs is null)
movedObjs = new List<PaintingObject>();
SuspendDrawing();
foreach (PaintingObject obj in objs)
{
var sp = savedPos[obj];
if (!movedObjs.Contains(obj))
{
if (UpdateObjectPosition(e, obj, sp))
movedObjs.Add(obj);
}
if (obj.PinnedObjects.Count > 0)
{
UpdateObjectPositions(e, obj.PinnedObjects, movedObjs);
movedObjs.AddRange(obj.PinnedObjects.ToArray());
}
}
ResumeDrawing(false);
}
private bool UpdateObjectPosition(MouseEventArgs e, PaintingObject obj, PointF sp)
{
bool moved = false;
var cancel = new CancelEventArgs(false);
obj.RaiseMovingBeforePositionUpdated(cancel);
if (!cancel.Cancel)
{
obj.Location = new Point((int)Math.Round(e.X - sp.X + Offset.X), (int)Math.Round(e.Y - sp.Y + Offset.Y));
obj.RaiseMoving(new EventArgs());
moved = true;
}
return moved;
}
private bool IsResizingObjs(IList<PaintingObject> objs)
{
foreach (PaintingObject obj in objs)
{
if (obj.IsResizing)
return true;
}
return false;
}
private MouseEventArgs GetMouseEventArgs(MouseEventArgs e, PaintingObject obj)
{
return new MouseEventArgs(e.Button, e.Clicks, (int)Math.Round(e.X - obj.X + Offset.X), (int)Math.Round(e.Y - obj.Y + Offset.Y), e.Delta);
}
public PaintingObject GetObject(PointF p, bool UseExtRect = false)
{
PaintingObject val = null;
for (int i = PaintingObjects.Count - 1; i >= 0; i -= 1)
{
var obj = PaintingObjects[i];
if (val is null)
{
if (UseExtRect)
{
if (HelpfulDrawingFunctions.IsPointInRectangle(p, obj.RectangleExtended))
val = obj;
}
else if (HelpfulDrawingFunctions.IsPointInRectangle(p, obj.Rectangle))
{
val = obj;
}
}
}
return val;
}
public PaintingObject[] GetObjects(Point p)
{
var objs = new List<PaintingObject>();
foreach (PaintingObject obj in PaintingObjects)
{
if (HelpfulDrawingFunctions.IsPointInRectangle(p, obj.RectangleExtended))
objs.Add(obj);
}
return objs.ToArray();
}
public PaintingObject[] GetObjects(Point startPoint, Point endPoint)
{
return GetObjects(new Rectangle(startPoint, (Size)(endPoint - (Size)startPoint)));
}
public PaintingObject[] GetObjects(Rectangle rect)
{
var objs = new List<PaintingObject>();
foreach (PaintingObject obj in PaintingObjects)
{
var objRect = obj.Rectangle;
if (HelpfulDrawingFunctions.IsPointInRectangle(objRect.Location, rect) || HelpfulDrawingFunctions.IsPointInRectangle(objRect.Location + objRect.Size, rect) || HelpfulDrawingFunctions.IsPointInRectangle(new PointF(objRect.Left, objRect.Bottom), rect) || HelpfulDrawingFunctions.IsPointInRectangle(new PointF(objRect.Right, objRect.Top), rect))
objs.Add(obj);
}
return objs.ToArray();
}
protected override CreateParams CreateParams
{
get
{
var cp = base.CreateParams;
// If EnableRealTransparency Then
// cp.ExStyle = cp.ExStyle Or &H20 'WS_EX_TRANSPARENT
// End If
return cp;
}
}
/// <summary>
/// Sorg dafür, dass Events durch dieses Control durchdringen zum Parnet-Control.
/// </summary>
/// <param name="m"></param>
protected override void WndProc(ref Message m)
{
const int WM_NCHITTEST = 0x84;
const int HTTRANSPARENT = -1;
if (!VisibleForMouseEvents && m.Msg == WM_NCHITTEST)
m.Result = HTTRANSPARENT;
else
{
base.WndProc(ref m);
}
}
protected override void OnPaintBackground(PaintEventArgs e)
{
// Stop Drawing directly to the parent
SuspendLayout();
// Draw Background
// If Not EnableRealTransparency Then
base.OnPaintBackground(e);
// End If
}
protected override void OnPaint(PaintEventArgs e)
{
// Draw PaintingObjects stuff
if (StopDrawing)
e.Graphics.DrawImage(bufferedImg, Point.Empty);
else
{
{
var withBlock = e.Graphics;
withBlock.SmoothingMode = SmoothingMode.HighQuality;
withBlock.PixelOffsetMode = PixelOffsetMode.HighQuality;
withBlock.PageUnit = GraphicsUnit.Pixel;
withBlock.InterpolationMode = InterpolationMode.HighQualityBicubic;
}
if (GridVisible)
DrawGridMethode?.Invoke(e, this, Offset);
var baserect = new RectangleF(Offset, Size);
foreach (PaintingObject obj in PaintingObjects)
{
if (obj.Visible && HelpfulDrawingFunctions.OverlapsTwoRectangles(obj.Rectangle, baserect))
obj.Draw(e, Offset);
}
if (_IsAreaSelecting)
DrawAreaSelectionMethode?.Invoke(e, this, new PointF(startMousePos.X - Offset.X, startMousePos.Y - Offset.Y), new PointF(lastMousePos.X - Offset.X, lastMousePos.Y - Offset.Y));
}
// Do default Drawing Methode
base.OnPaint(e);
// Start Drawing directly to the Form
ResumeLayout(false);
}
public new Graphics CreateGraphics()
{
return base.CreateGraphics();
}
public void PaintFullView(Graphics g)
{
foreach (PaintingObject obj in PaintingObjects)
{
if (obj.Visible)
obj.Draw(g, PointF.Empty);
}
}
private SizeF CalcTextSize(PaintingObject obj)
{
return CalcTextSize(obj, Parent.CreateGraphics());
}
private SizeF CalcTextSize(PaintingObject obj, Graphics g)
{
return g.MeasureString(obj.Text, obj.TextFont, (int)Math.Round(obj.Width));
}
private void SelectControlsInArea()
{
var rect = HelpfulDrawingFunctions.GetRectangle(startMousePos, lastMousePos);
foreach (PaintingObject obj in PaintingObjects)
obj.Selected = startMousePos.X >= lastMousePos.X ? HelpfulDrawingFunctions.OverlapsTwoRectangles(obj.Rectangle, rect) : HelpfulDrawingFunctions.RectangleContainsRectangle(rect, obj.Rectangle);
}
public void ArrangeToGrid(PaintingObject obj, bool snapPinnedObjects)
{
if (snapPinnedObjects || !IsPinnedObject(obj))
{
var zoomedGridChunkSize = new SizeF(GridChunkSize.Width * ZoomFactor.Width, GridChunkSize.Height * ZoomFactor.Height);
int modTop = (int)Math.Round(obj.Y % zoomedGridChunkSize.Height);
int modLeft = (int)Math.Round(obj.X % zoomedGridChunkSize.Width);
int halfHeight = (int)Math.Round(zoomedGridChunkSize.Height / 2f);
int halfWidth = (int)Math.Round(zoomedGridChunkSize.Width / 2f);
void zoomLocation(PaintingObject obj2)
{
if (modTop > halfHeight)
obj2.Y += zoomedGridChunkSize.Height - modTop;
else
{
obj2.Y -= modTop;
}
if (modLeft > halfWidth)
obj2.X += zoomedGridChunkSize.Width - modLeft;
else
{
obj2.X -= modLeft;
}
};
zoomLocation(obj);
foreach (PaintingObject pinned in obj.PinnedObjects)
zoomLocation(pinned);
int modH = (int)Math.Round(obj.Height % zoomedGridChunkSize.Height);
int modW = (int)Math.Round(obj.Width % zoomedGridChunkSize.Width);
void zoomSize(PaintingObject obj2) { if (obj2.EnableResize && !obj2.HardcodedSize) { if (modH > halfHeight) obj2.Height += zoomedGridChunkSize.Height - modH; else { obj2.Height -= modH; } if (modW > halfWidth) obj2.Width += zoomedGridChunkSize.Width - modW; else { obj2.Width -= modW; } } };
zoomSize(obj);
foreach (PaintingObject pinned in obj.PinnedObjects)
zoomSize(pinned);
}
}
public bool IsPinnedObject(PaintingObject o)
{
foreach (PaintingObject obj in PaintingObjects)
{
if (obj.PinnedObjects.Contains(o))
return true;
}
return false;
}
public void AutoArrangeToGrid()
{
if (GridEnabled)
{
foreach (PaintingObject obj in GetSelectedObjects())
{
if (obj.AutoAlignToGrid)
ArrangeToGrid(obj, false);
}
if (!StopDrawing)
Refresh();
}
}
public SizeF GetFullSize()
{
return GetFullSize(PaintingObjects);
}
public static SizeF GetFullSize(IEnumerable<PaintingObject> objects)
{
float curX = 0f;
float curY = 0f;
foreach (PaintingObject po in objects)
{
float myX = po.X + po.Width;
if (curX < myX)
curX = myX;
float myY = po.Y + po.Height;
if (curY < myY)
curY = myY;
}
return new SizeF(curX + 20f, curY + 20f);
}
internal void RaisePaintingObjectAdded(PaintingObjectEventArgs args)
{
PaintingObjectAdded?.Invoke(this, args);
}
internal void RaisePaintingObjectRemoved(PaintingObjectEventArgs args)
{
PaintingObjectRemoved?.Invoke(this, args);
}
private void PaintingControl_PaintingObjectAdded(object sender, PaintingObjectEventArgs e)
{
// CalculateScrollValues()
}
private void CheckMouseWheel(object sender, MouseEventArgs e)
{
if (pressedAlt)
{
float val = (float)(e.Delta / 120d / 10d);
ZoomFactor = new SizeF((float)Math.Max((double)(ZoomFactor.Width + val), 0.25d), (float)Math.Max((double)(ZoomFactor.Height + val), 0.25d));
Refresh();
}
else
{
// ...
}
}
public void SuspendDrawing()
{
if (_stopDrawing < 0)
// bufferedImg = New Bitmap(Width, Height)
// DrawToBitmap(bufferedImg, New Rectangle(0, 0, bufferedImg.Width, bufferedImg.Height))
Utils.DrawingControl.SuspendDrawing(this);
_stopDrawing += 1;
}
public void ResumeDrawing()
{
ResumeDrawing(true);
}
public void ResumeDrawing(bool executeRefresh)
{
if (_stopDrawing >= 0)
_stopDrawing -= 1;
if (_stopDrawing == -1)
// bufferedImg.Dispose()
// bufferedImg = Nothing
// If executeRefresh Then Refresh()
Utils.DrawingControl.ResumeDrawing(this, executeRefresh);
}
}

11
Pilz.UI/PaintingControl/PaintingControlDelegates.cs Normal file
View File

@@ -0,0 +1,11 @@
using System.Drawing;
using System.Windows.Forms;
namespace Pilz.UI;
public delegate void DelegateDrawPaintingObjectMethode(PaintingObjectPaintEventArgs e);
public delegate void DelegateDrawPaintingControlGridMethode(PaintEventArgs e, PaintingControl pc, PointF offset);
public delegate void DelegateDrawPaintingControlAreaSelectionMethode(PaintEventArgs e, PaintingControl pc, PointF startMousePos, PointF lastMousePos);

826
Pilz.UI/PaintingControl/PaintingObject.cs Normal file
View File

@@ -0,0 +1,826 @@
using Microsoft.VisualBasic.CompilerServices;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Reflection;
using System.Windows.Forms;
namespace Pilz.UI;
[Serializable]
public class PaintingObject : ICloneable, IPaintingObjectContainer
{
private PaintingObjectResizing resizeEngine = null;
private bool _Selected = false;
private PaintingControl _Parent = null;
public Color FillColor { get; set; } = Color.Blue;
public Color OutlineColor { get; set; } = Color.DarkBlue;
public float OutlineThicknes { get; set; } = 1f;
public DashStyle OutlineDashStyle { get; set; } = DashStyle.Solid;
public LineCapProps LineStartCap { get; set; } = null;
public LineCapProps LineEndCap { get; set; } = null;
[JsonProperty]
private string _Text = "";
public TextPosition TextPosition { get; set; } = TextPosition.FullCenter;
public StringAlignment VerticalTextAlignment { get; set; } = StringAlignment.Center;
public StringAlignment HorizontalTextAlignment { get; set; } = StringAlignment.Center;
public Font TextFont { get; set; } = new Font(FontFamily.GenericSansSerif, 8.25f);
public Color TextColor { get; set; } = Color.Black;
[JsonProperty]
private PointF _Location = new PointF(50f, 50f);
[JsonProperty]
private SizeF _Size = new SizeF(50f, 80f);
public bool EnableFill { get; set; } = true;
public bool EnableOutline { get; set; } = true;
public Color SelectionColor { get; set; } = Color.CornflowerBlue;
public DashStyle SelectionDashStyle { get; set; } = DashStyle.Dot;
[JsonProperty]
private bool _EnableSelection = true;
public Image Image { get; set; } = null;
[JsonIgnore]
public Image BufferedImage { get; set; } = null;
public ImageSizeMode ImageSizeMode { get; set; }
public PaintingObjectImageProperties ImageProperties { get; set; } = new PaintingObjectImageProperties();
[JsonIgnore]
public object Tag { get; set; } = null;
public string Name { get; set; } = "";
public List<PaintingObject> PinnedObjects { get; private set; } = new List<PaintingObject>();
[JsonIgnore]
public List<DelegateDrawPaintingObjectMethode> DrawMethodes { get; private set; } = new List<DelegateDrawPaintingObjectMethode>();
[JsonIgnore]
public DelegateDrawPaintingObjectMethode DrawSelectionMethode { get; private set; } = DefaultDrawMethodes.DrawSelection;
public Cursor Cursor { get; set; } = Cursors.Default;
public bool HardcodedSize { get; set; } = false;
public bool HardcodedLocation { get; set; } = false;
[JsonProperty]
private bool _Visible = true;
[JsonProperty]
private bool _AutoAlignToGrid = false;
public bool MouseTransparency { get; set; } = false;
public PaintingObjectLayering Layering { get; private set; } = new PaintingObjectLayering(this);
public PaintingObjectList PaintingObjects { get; private set; } = new PaintingObjectList(_Parent) { EnableRaisingEvents = false };
[JsonIgnore]
public ulong ErrorsAtDrawing { get; private set; } = 0UL;
public event MouseClickEventHandler MouseClick;
public delegate void MouseClickEventHandler(PaintingObject sender, MouseEventArgs e);
public event MouseDownEventHandler MouseDown;
public delegate void MouseDownEventHandler(PaintingObject sender, MouseEventArgs e);
public event MouseUpEventHandler MouseUp;
public delegate void MouseUpEventHandler(PaintingObject sender, MouseEventArgs e);
public event MouseMoveEventHandler MouseMove;
public delegate void MouseMoveEventHandler(PaintingObject sender, MouseEventArgs e);
public event SelectedChangedEventHandler SelectedChanged;
public delegate void SelectedChangedEventHandler(PaintingObject sender, EventArgs e);
public event PaintEventHandler Paint;
public delegate void PaintEventHandler(PaintingObject sender, PaintEventArgs e);
public event ParentChangedEventHandler ParentChanged;
public delegate void ParentChangedEventHandler(PaintingObject sender, EventArgs e);
public event VisibleChangedEventHandler VisibleChanged;
public delegate void VisibleChangedEventHandler(PaintingObject sender, EventArgs e);
public event MovedEventHandler Moved;
public delegate void MovedEventHandler(PaintingObject sender, EventArgs e);
public event MovingEventHandler Moving;
public delegate void MovingEventHandler(PaintingObject sender, EventArgs e);
public event MovingBeforePositionUpdatedEventHandler MovingBeforePositionUpdated;
public delegate void MovingBeforePositionUpdatedEventHandler(PaintingObject sender, CancelEventArgs e);
public PaintingObject()
{
}
public PaintingObject(PaintingObjectType @type)
{
Type = type;
}
public PaintingObject(PaintingObjectType @type, DelegateDrawPaintingObjectMethode[] drawMethodes) : this(type)
{
DrawMethodes.AddRange(drawMethodes);
}
internal void RaiseMouseClick(MouseEventArgs e)
{
MouseClick?.Invoke(this, e);
}
internal void RaiseMouseDown(MouseEventArgs e)
{
MouseDown?.Invoke(this, e);
}
internal void RaiseMouseUp(MouseEventArgs e)
{
MouseUp?.Invoke(this, e);
}
internal void RaiseMouseMove(MouseEventArgs e)
{
MouseMove?.Invoke(this, e);
}
private void RaisePaint(PaintEventArgs e)
{
Paint?.Invoke(this, e);
}
internal void RaiseMoved(EventArgs e)
{
Moved?.Invoke(this, e);
}
internal void RaiseMoving(EventArgs e)
{
Moving?.Invoke(this, e);
}
internal void RaiseMovingBeforePositionUpdated(EventArgs e)
{
MovingBeforePositionUpdated?.Invoke(this, (CancelEventArgs)e);
}
public PaintingObjectType Type
{
get
{
var tt = PaintingObjectType.Custom;
foreach (DelegateDrawPaintingObjectMethode d in DrawMethodes)
{
if (ReferenceEquals(d.Method.DeclaringType, typeof(DefaultDrawMethodes)))
{
switch (d.Method.Name ?? "")
{
case "DrawPicture":
{
tt = tt | PaintingObjectType.Picture;
break;
}
case "DrawText":
{
tt = tt | PaintingObjectType.Text;
break;
}
case "DrawRectangle":
{
tt = tt | PaintingObjectType.Rectangle;
break;
}
case "DrawEllipse":
{
tt = tt | PaintingObjectType.Elipse;
break;
}
case "DrawTriangle":
{
tt = tt | PaintingObjectType.Triangle;
break;
}
case "DrawLine":
{
tt = tt | PaintingObjectType.Line;
break;
}
}
}
}
return tt;
}
set
{
DrawMethodes.Clear();
if ((value & PaintingObjectType.Picture) == PaintingObjectType.Picture)
DrawMethodes.Add(DefaultDrawMethodes.DrawPicture);
if ((value & PaintingObjectType.Rectangle) == PaintingObjectType.Rectangle)
DrawMethodes.Add(DefaultDrawMethodes.DrawRectangle);
if ((value & PaintingObjectType.Elipse) == PaintingObjectType.Elipse)
DrawMethodes.Add(DefaultDrawMethodes.DrawEllipse);
if ((value & PaintingObjectType.Triangle) == PaintingObjectType.Triangle)
DrawMethodes.Add(DefaultDrawMethodes.DrawTriangle);
if ((value & PaintingObjectType.Line) == PaintingObjectType.Line)
DrawMethodes.Add(DefaultDrawMethodes.DrawLine);
if ((value & PaintingObjectType.Text) == PaintingObjectType.Text)
DrawMethodes.Add(DefaultDrawMethodes.DrawText);
}
}
[JsonIgnore]
public PointF Location
{
get
{
if (Parent is not null)
return new PointF(_Location.X * Parent.ZoomFactor.Width, _Location.Y * Parent.ZoomFactor.Height);
else
{
return _Location;
}
}
set
{
if (Parent is not null)
_Location = new PointF(value.X / Parent.ZoomFactor.Width, value.Y / Parent.ZoomFactor.Height);
else
{
_Location = value;
}
}
}
[JsonIgnore]
public PointF LocationDirect
{
get
{
return _Location;
}
set
{
_Location = value;
}
}
[JsonIgnore]
public SizeF Size
{
get
{
if (Parent is not null)
return new SizeF(_Size.Width * Parent.ZoomFactor.Width, _Size.Height * Parent.ZoomFactor.Height);
else
{
return _Size;
}
}
set
{
if (Parent is not null)
_Size = new SizeF(value.Width / Parent.ZoomFactor.Width, value.Height / Parent.ZoomFactor.Height);
else
{
_Size = value;
}
ResetImageBuffer();
}
}
[JsonIgnore]
public SizeF SizeDirect
{
get
{
return _Size;
}
set
{
_Size = value;
ResetImageBuffer();
}
}
[JsonIgnore]
public bool AutoAlignToGrid
{
get
{
return _AutoAlignToGrid;
}
set
{
_AutoAlignToGrid = value;
if (value)
ArrangeToGrid();
}
}
[JsonIgnore]
public bool IsResizing
{
get
{
if (resizeEngine is null)
return false;
else
{
return (bool)resizeEngine?.IsResizing;
}
}
}
[JsonIgnore]
public PaintingControl Parent
{
get
{
return _Parent;
}
set
{
bool re = !ReferenceEquals(value, _Parent);
_Parent = value;
if (re)
ParentChanged?.Invoke(this, new EventArgs());
}
}
[JsonIgnore]
public bool Visible
{
get
{
return _Visible;
}
set
{
if (value != _Visible)
{
_Visible = value;
if (!value && !_EnableSelection)
EnableResize = false;
VisibleChanged?.Invoke(this, new EventArgs());
}
}
}
[JsonIgnore]
public bool Selected
{
get
{
return _Selected;
}
set
{
SetSelection(value, true);
}
}
[JsonIgnore]
public bool SelectedDirect
{
get
{
return Selected;
}
set
{
SetSelection(value, false);
}
}
private void SetSelection(bool value, bool raiseEventOnParent)
{
if (EnableSelection)
{
if (_Selected != value)
{
_Selected = value;
SelectedChanged?.Invoke(this, new EventArgs());
if (raiseEventOnParent)
Parent.RaiseSelectionChanged();
}
}
else
{
_Selected = false;
}
}
[JsonIgnore]
public float Width
{
get
{
return Size.Width;
}
set
{
Size = new SizeF(value, Size.Height);
}
}
[JsonIgnore]
public float Height
{
get
{
return Size.Height;
}
set
{
Size = new SizeF(Size.Width, value);
}
}
[JsonIgnore]
public float X
{
get
{
return Location.X;
}
set
{
Location = new PointF(value, Location.Y);
}
}
[JsonIgnore]
public float Y
{
get
{
return Location.Y;
}
set
{
Location = new PointF(Location.X, value);
}
}
[JsonIgnore]
public string Text
{
get
{
return _Text;
}
set
{
_Text = value;
}
}
[JsonIgnore]
public RectangleF Rectangle
{
get
{
return new RectangleF(Location, Size);
}
set
{
Location = value.Location;
Size = value.Size;
}
}
[JsonIgnore]
public bool EnableSelection
{
get
{
return _EnableSelection;
}
set
{
_EnableSelection = value;
if (!value && !_Visible)
EnableResize = false;
if (!value)
Selected = false;
}
}
[JsonIgnore]
public Rectangle RectangleExtended
{
get
{
return new Rectangle((int)Math.Round(X - 12f), (int)Math.Round(Y - 12f), (int)Math.Round(Width + 12f + 12f), (int)Math.Round(Height + 12f + 12f));
}
set
{
X = value.X + 12;
Y = value.Y + 12;
Width = value.Width - 12 - 12;
Height = value.Height - 12 - 12;
}
}
public void FitSizeToText()
{
if (Parent is null)
throw new Exception("You have to put that PaintingObject to a PaintingControl before.");
var g = Parent.CreateGraphics();
var newSize = g.MeasureString(Text, TextFont);
SizeDirect = newSize + new SizeF(1f, 0f);
}
public void SetBounds(int x, int y, int width, int height)
{
Location = new Point(x, y);
Size = new Size(width, height);
}
[JsonIgnore]
public int Left
{
get
{
return (int)Math.Round(X);
}
set
{
X = value;
}
}
[JsonIgnore]
public int Top
{
get
{
return (int)Math.Round(Y);
}
set
{
Y = value;
}
}
[JsonIgnore]
public int Right
{
get
{
return (int)Math.Round(X + Width);
}
set
{
X = value - Width;
}
}
[JsonIgnore]
public int Bottom
{
get
{
return (int)Math.Round(Y + Height);
}
set
{
Y = value - Height;
}
}
[JsonProperty(nameof(Tag))]
public string TagString
{
get
{
if (Tag is string)
return Conversions.ToString(Tag);
else
{
return string.Empty;
}
}
set
{
Tag = value;
}
}
public bool EnableResize
{
get
{
if (resizeEngine is null)
return false;
else
{
return resizeEngine.Enabled;
}
}
set
{
if (resizeEngine is null && value)
resizeEngine = new PaintingObjectResizing(this);
else if (resizeEngine is not null)
{
resizeEngine.Enabled = value;
}
}
}
public void Remove()
{
Parent?.PaintingObjects.Remove(this);
}
public void AutoArrangeToGrid()
{
if (((Parent?.GridEnabled) is var arg1 && !arg1.HasValue || arg1.Value) && AutoAlignToGrid && arg1.HasValue)
ArrangeToGrid();
}
public void ArrangeToGrid()
{
if (Parent is not null)
{
Parent.ArrangeToGrid(this, true);
if (!Parent.StopDrawing)
Parent.Refresh();
}
}
public void Draw(PaintEventArgs e)
{
Draw(e, e.ClipRectangle.Location);
}
public void Draw(PaintEventArgs e, PointF offset)
{
Draw(e.Graphics, offset);
if (Visible)
RaisePaint(e);
}
public void Draw(Graphics g, PointF offset)
{
if (Visible)
{
var poevargs = new PaintingObjectPaintEventArgs(this, g, offset);
foreach (DelegateDrawPaintingObjectMethode dm in DrawMethodes)
{
try
{
dm?.Invoke(poevargs);
}
catch (Exception ex)
{
ErrorsAtDrawing = (ulong)Math.Round(ErrorsAtDrawing + 1m);
}
}
if (Selected && DrawSelectionMethode is not null)
DrawSelectionMethode?.Invoke(poevargs);
}
}
public object Clone()
{
return Clone(true);
}
public object Clone(bool includePinnedObject)
{
var obj = new PaintingObject();
var metype = GetType();
string[] blackField = new[] { nameof(PinnedObjects), nameof(resizeEngine), nameof(_Parent), nameof(BufferedImage), nameof(ImageProperties) };
void copyFields(object source, object dest, string[] blackFields, Type t)
{
var fields = new List<FieldInfo>(t.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.IgnoreCase | BindingFlags.Instance));
foreach (FieldInfo @field in fields)
{
if (!blackFields.Contains(@field.Name))
@field.SetValue(dest, @field.GetValue(source));
}
};
copyFields(this, obj, blackField, metype);
copyFields(ImageProperties, obj.ImageProperties, Array.Empty<string>(), ImageProperties.GetType());
if (includePinnedObject)
obj.PinnedObjects.AddRange(PinnedObjects);
obj.EnableResize = EnableResize;
return obj;
}
[Obsolete("Use Layering.BringToTop() instead!")]
public void BringToFront()
{
Layering.BringToTop();
}
[Obsolete("Use Layering.SendToBack() instead!")]
public void SendToBack()
{
Layering.SendToBack();
}
public void ResetImageBuffer()
{
BufferedImage = null;
}
}
public class PaintingObjectList : List<PaintingObject>
{
[JsonIgnore]
internal PaintingControl MyParent { get; private set; }
internal bool EnableRaisingEvents { get; set; } = true;
[JsonIgnore]
public PaintingObjectListLayering Layering { get; private set; } = new PaintingObjectListLayering(this);
public PaintingObjectList() : this(null)
{
}
public PaintingObjectList(PaintingControl parent)
{
MyParent = parent;
}
public new void Add(PaintingObject item)
{
item.Parent = MyParent;
base.Add(item);
item.AutoArrangeToGrid();
if (EnableRaisingEvents)
MyParent?.RaisePaintingObjectAdded(new PaintingObjectEventArgs(new[] { item }));
}
public void AddRange(PaintingObject[] items)
{
foreach (PaintingObject item in items)
item.Parent = MyParent;
base.AddRange(items);
foreach (PaintingObject item in items)
item.AutoArrangeToGrid();
if (EnableRaisingEvents)
MyParent?.RaisePaintingObjectAdded(new PaintingObjectEventArgs(items));
}
public new void Insert(int index, PaintingObject item)
{
item.Parent = MyParent;
base.Insert(index, item);
MyParent?.AutoArrangeToGrid();
if (EnableRaisingEvents)
MyParent?.RaisePaintingObjectAdded(new PaintingObjectEventArgs(new[] { item }));
}
public new void Remove(PaintingObject item)
{
item.Parent = null;
base.Remove(item);
if (EnableRaisingEvents)
MyParent?.RaisePaintingObjectRemoved(new PaintingObjectEventArgs(new[] { item }));
}
public new void RemoveAt(int index)
{
this[index].Parent = null;
var item = this[index];
base.RemoveAt(index);
if (EnableRaisingEvents)
MyParent?.RaisePaintingObjectRemoved(new PaintingObjectEventArgs(new[] { item }));
}
}
public enum PaintingObjectType
{
Custom = 0,
Text = 1,
Picture = 2,
Line = 4,
Triangle = 8,
Rectangle = 16,
Elipse = 32
}
public enum ImageSizeMode
{
Fit,
Zoom,
Original
}
public enum TextPosition
{
HLeft = 0x1,
HRight = 0x2,
HCenter = 0x4,
VUp = 0x10,
VDown = 0x20,
VCenter = 0x40,
FullCenter = HCenter | VCenter
}

7
Pilz.UI/PaintingControl/PaintingObjectJsonSerializer.cs Normal file
View File

@@ -0,0 +1,7 @@
namespace Pilz.UI;
public class PaintingObjectJsonSerializer
{
}

112
Pilz.UI/PaintingControl/PaintingObjectLayering.cs Normal file
View File

@@ -0,0 +1,112 @@
using Newtonsoft.Json;
namespace Pilz.UI;
public class PaintingObjectLayering
{
// <JsonProperty(NameOf(PaintingObject))>
private readonly PaintingObject _PaintingObject;
[JsonIgnore]
public PaintingObject PaintingObject
{
get
{
return _PaintingObject;
}
}
/// <summary>
/// Get the current object list from the painting object.
/// </summary>
/// <returns>Returns the current object list from the painting object.</returns>
[JsonIgnore]
public PaintingObjectList ObjectList
{
get
{
return PaintingObject.Parent.PaintingObjects;
}
}
/// <summary>
/// Create a new instance of object layer managing.
/// </summary>
/// <param name="obj"></param>
public PaintingObjectLayering(PaintingObject obj)
{
_PaintingObject = obj;
}
/// <summary>
/// Moves the object by the given number of indicies.
/// </summary>
/// <param name="count">The number how many objects it should be moved.</param>
public void MoveObject(int count)
{
int oldIndex = ObjectList.IndexOf(PaintingObject);
int newIndex = oldIndex + count;
MoveObjectTo(newIndex);
}
/// <summary>
/// Moves the object to the new index.
/// </summary>
/// <param name="newIndex"></param>
public void MoveObjectTo(int newIndex)
{
var list = ObjectList;
// Check & make index valid
if (newIndex >= ObjectList.Count)
newIndex = ObjectList.Count - 1;
else if (newIndex < 0)
{
newIndex = 0;
}
// Remove object
list.Remove(PaintingObject);
// Insert object at new index
list.Insert(newIndex, PaintingObject);
// Order all objects again
list.Layering.OrderAll();
}
/// <summary>
/// Moves the object to the front.
/// </summary>
public void BringToTop()
{
MoveObjectTo(ObjectList.Count - 1);
}
/// <summary>
/// Moves the object to the back.
/// </summary>
public void SendToBack()
{
MoveObjectTo(0);
}
/// <summary>
/// Moves the object fordward by one
/// </summary>
public void OneToTop()
{
MoveObject(+1);
}
/// <summary>
/// Moves the object backward by one
/// </summary>
public void OneToBack()
{
MoveObject(-1);
}
}

87
Pilz.UI/PaintingControl/PaintingObjectListLayering.cs Normal file
View File

@@ -0,0 +1,87 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
namespace Pilz.UI;
public class PaintingObjectListLayering
{
public PaintingObjectList ObjectList { get; private set; }
public Dictionary<int, Func<PaintingObject, bool>> Conditions { get; private set; } = new Dictionary<int, Func<PaintingObject, bool>>();
/// <summary>
/// Get the order function will checkout the conditions.
/// </summary>
/// <returns>Returns true, if conditions are aviable, otherwise false.</returns>
public bool EnableConditions
{
get
{
return Conditions.Any();
}
}
/// <summary>
/// Create a new instance of object list layer managing.
/// </summary>
/// <param name="list"></param>
public PaintingObjectListLayering(PaintingObjectList list)
{
ObjectList = list;
}
/// <summary>
/// Order all objects using the conditions. If no conditions are setted, this method will do nothing.
/// </summary>
public void OrderAll()
{
if (EnableConditions)
OrderAllPrivate();
}
private void OrderAllPrivate()
{
var list = ObjectList;
var listOld = list.ToList();
var toRemove = new List<PaintingObject>();
// Disable raising events
ObjectList.EnableRaisingEvents = false;
// Clear list
list.Clear();
// Add ordered
foreach (var kvp in Conditions.OrderBy(n => n.Key))
{
var func = kvp.Value;
foreach (PaintingObject obj in listOld)
{
if (func(obj))
{
// Add to list
list.Add(obj);
// Add to remove
toRemove.Add(obj);
}
}
// Remove remembered objects
foreach (PaintingObject obj in toRemove)
listOld.Remove(obj);
toRemove.Clear();
}
// Enable raising events
ObjectList.EnableRaisingEvents = true;
// Refresh
ObjectList.MyParent?.Refresh();
}
}

346
Pilz.UI/PaintingControl/PaintingObjectResizing.cs Normal file
View File

@@ -0,0 +1,346 @@
using Pilz.Drawing;
using System;
using System.Drawing;
using System.Runtime.CompilerServices;
using System.Windows.Forms;
namespace Pilz.UI;
[Serializable]
internal class PaintingObjectResizing
{
public static event CheckEnabledEventHandler CheckEnabled;
public delegate void CheckEnabledEventHandler(PaintingObjectResizing sender, ref bool enabled);
private PaintingObject _mObj;
private PaintingObject mObj
{
[MethodImpl(MethodImplOptions.Synchronized)]
get
{
return _mObj;
}
[MethodImpl(MethodImplOptions.Synchronized)]
set
{
if (_mObj != null)
{
_mObj.MouseDown -= mControl_MouseDown;
_mObj.MouseUp -= mControl_MouseUp;
_mObj.Paint -= mControl_Paint;
_mObj.SelectedChanged -= mControl_MouseLeave;
_mObj.ParentChanged -= mObj_ParentChanged;
}
_mObj = value;
if (_mObj != null)
{
_mObj.MouseDown += mControl_MouseDown;
_mObj.MouseUp += mControl_MouseUp;
_mObj.Paint += mControl_Paint;
_mObj.SelectedChanged += mControl_MouseLeave;
_mObj.ParentChanged += mObj_ParentChanged;
}
}
}
private Control _mObjParent;
private Control mObjParent
{
[MethodImpl(MethodImplOptions.Synchronized)]
get
{
return _mObjParent;
}
[MethodImpl(MethodImplOptions.Synchronized)]
set
{
_mObjParent = value;
}
}
private Control _mObjControl;
private Control mObjControl
{
[MethodImpl(MethodImplOptions.Synchronized)]
get
{
return _mObjControl;
}
[MethodImpl(MethodImplOptions.Synchronized)]
set
{
if (_mObjControl != null)
{
_mObjControl.MouseMove -= mControl_MouseMove;
_mObjControl.ParentChanged -= mObjParent_ParentChanged;
}
_mObjControl = value;
if (_mObjControl != null)
{
_mObjControl.MouseMove += mControl_MouseMove;
_mObjControl.ParentChanged += mObjParent_ParentChanged;
}
}
}
private bool mMouseDown = false;
private EdgeEnum mEdge = EdgeEnum.None;
private int mWidth = 4;
private int qWidth = 4 * 4;
private Rectangle rect = new Rectangle();
public bool Enabled { get; set; } = true;
public SizeF MinimumSize { get; set; } = new SizeF(15f, 15f);
[Serializable]
private enum EdgeEnum
{
None,
Right,
Left,
Top,
Bottom,
TopLeft,
TopRight,
BottomLeft,
BottomRight
}
public bool IsResizing
{
get
{
return mMouseDown && mEdge != EdgeEnum.None;
}
}
public PaintingObject PaintingObject
{
get
{
return mObj;
}
}
public PaintingObjectResizing(PaintingObject obj)
{
mObjParent = null;
mObjControl = null;
mObj = obj;
mObjControl = mObj.Parent;
}
private bool IsEnabled()
{
bool enabled = Enabled;
CheckEnabled?.Invoke(this, ref enabled);
return enabled;
}
private void mControl_MouseDown(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
mMouseDown = true;
}
private void mControl_MouseUp(object sender, MouseEventArgs e)
{
mMouseDown = false;
if (mObj.Selected)
mObj.AutoArrangeToGrid();
}
private void KeepInRange(ref SizeF size)
{
if (size.Height < MinimumSize.Height || size.Width < MinimumSize.Width)
size = new SizeF(Math.Max(size.Width, MinimumSize.Width), Math.Max(size.Height, MinimumSize.Height));
}
private void mControl_MouseMove(object sender, MouseEventArgs e)
{
if (mMouseDown && mEdge != EdgeEnum.None)
{
int eX = (int)Math.Round(e.X + mObj.Parent.Offset.X);
int eY = (int)Math.Round(e.Y + mObj.Parent.Offset.Y);
switch (mEdge)
{
case EdgeEnum.TopLeft:
{
mObj.SetBounds(eX, eY, (int)Math.Round(mObj.Width + (mObj.Left - eX)), (int)Math.Round(mObj.Height + (mObj.Top - eY)));
break;
}
case EdgeEnum.TopRight:
{
mObj.SetBounds(mObj.Left, eY, eX - mObj.Left, (int)Math.Round(mObj.Height + (mObj.Top - eY)));
break;
}
case EdgeEnum.BottomRight:
{
mObj.SetBounds(mObj.Left, mObj.Top, eX - mObj.Left, eY - mObj.Top);
break;
}
case EdgeEnum.BottomLeft:
{
mObj.SetBounds(eX, mObj.Top, (int)Math.Round(mObj.Width + (mObj.Left - eX)), eY - mObj.Top);
break;
}
case EdgeEnum.Left:
{
mObj.SetBounds(eX, mObj.Top, (int)Math.Round(mObj.Width + (mObj.Left - eX)), (int)Math.Round(mObj.Height));
break;
}
case EdgeEnum.Right:
{
mObj.SetBounds(mObj.Left, mObj.Top, eX - mObj.Left, (int)Math.Round(mObj.Height));
break;
}
case EdgeEnum.Top:
{
mObj.SetBounds(mObj.Left, eY, (int)Math.Round(mObj.Width), (int)Math.Round(mObj.Height + (mObj.Top - eY)));
break;
}
case EdgeEnum.Bottom:
{
mObj.SetBounds(mObj.Left, mObj.Top, (int)Math.Round(mObj.Width), eY - mObj.Top);
break;
}
}
var argsize = mObj.Size;
KeepInRange(ref argsize);
mObj.Size = argsize;
}
else if (!mMouseDown)
{
int eXo = e.X;
int eYo = e.Y;
int realX = (int)Math.Round(eXo + mObj.Parent.Offset.X);
int realY = (int)Math.Round(eYo + mObj.Parent.Offset.Y);
int eXwo = (int)Math.Round(eXo - mObj.X);
int eYwo = (int)Math.Round(eYo - mObj.Y);
int eX = (int)Math.Round(eXwo + mObj.Parent.Offset.X);
int eY = (int)Math.Round(eYwo + mObj.Parent.Offset.Y);
var eLocation = new Point(eX, eY);
RectangleF extRect = mObj.RectangleExtended;
var oldRect = mObj.Rectangle;
var newRect = new RectangleF();
newRect.X = extRect.X - oldRect.X;
newRect.Y = extRect.Y - oldRect.Y;
newRect.Width = (extRect.Width - oldRect.Width) / 2f;
newRect.Height = (extRect.Height - oldRect.Height) / 2f;
bool setToNone = false;
bool isOnTop = ReferenceEquals(mObj.Parent.GetObject(new PointF(realX, realY), true), mObj);
if (IsEnabled() && isOnTop)
{
switch (true)
{
case object _ when HelpfulDrawingFunctions.IsPointInRectangle(eLocation, new Rectangle((int)Math.Round(newRect.X), (int)Math.Round(newRect.Y), (int)Math.Round(newRect.Width), (int)Math.Round(newRect.Height))):
{
mObj.Cursor = Cursors.SizeNWSE;
mEdge = EdgeEnum.TopLeft;
break;
}
case object _ when HelpfulDrawingFunctions.IsPointInRectangle(eLocation, new Rectangle((int)Math.Round(mObj.Width), (int)Math.Round(newRect.Y), (int)Math.Round(newRect.Width), (int)Math.Round(newRect.Height))):
{
mObj.Cursor = Cursors.SizeNESW;
mEdge = EdgeEnum.TopRight;
break;
}
case object _ when HelpfulDrawingFunctions.IsPointInRectangle(eLocation, new Rectangle((int)Math.Round(mObj.Width), (int)Math.Round(mObj.Height), (int)Math.Round(newRect.Width), (int)Math.Round(newRect.Height))):
{
mObj.Cursor = Cursors.SizeNWSE;
mEdge = EdgeEnum.BottomRight;
break;
}
case object _ when HelpfulDrawingFunctions.IsPointInRectangle(eLocation, new Rectangle((int)Math.Round(newRect.X), (int)Math.Round(mObj.Height), (int)Math.Round(newRect.Width), (int)Math.Round(newRect.Height))):
{
mObj.Cursor = Cursors.SizeNESW;
mEdge = EdgeEnum.BottomLeft;
break;
}
case object _ when HelpfulDrawingFunctions.IsPointInRectangle(eLocation, new Rectangle((int)Math.Round(-newRect.Width), 0, (int)Math.Round(newRect.Width), (int)Math.Round(mObj.Height))):
{
mObj.Cursor = Cursors.SizeWE;
mEdge = EdgeEnum.Left;
break;
}
case object _ when HelpfulDrawingFunctions.IsPointInRectangle(eLocation, new Rectangle((int)Math.Round(mObj.Width), 0, (int)Math.Round(newRect.Width), (int)Math.Round(mObj.Height))):
{
mObj.Cursor = Cursors.SizeWE;
mEdge = EdgeEnum.Right;
break;
}
case object _ when HelpfulDrawingFunctions.IsPointInRectangle(eLocation, new Rectangle(0, (int)Math.Round(-newRect.Height), (int)Math.Round(mObj.Width), (int)Math.Round(newRect.Height))):
{
mObj.Cursor = Cursors.SizeNS;
mEdge = EdgeEnum.Top;
break;
}
case object _ when HelpfulDrawingFunctions.IsPointInRectangle(eLocation, new Rectangle(0, (int)Math.Round(mObj.Height), (int)Math.Round(mObj.Width), (int)Math.Round(newRect.Height))):
{
mObj.Cursor = Cursors.SizeNS;
mEdge = EdgeEnum.Bottom;
break;
}
default:
{
setToNone = true;
break;
}
}
}
else
{
setToNone = true;
}
if (setToNone)
{
mObj.Cursor = Cursors.Default;
mEdge = EdgeEnum.None;
}
}
}
private void mControl_Paint(PaintingObject sender, PaintEventArgs e)
{
// e.Graphics.FillRectangle(brush, rect)
}
private void mControl_MouseLeave(PaintingObject sender, EventArgs e)
{
if (!sender.Selected)
mEdge = EdgeEnum.None;
}
private void mObjParent_ParentChanged(object sender, EventArgs e)
{
mObjParent = mObjControl.Parent;
}
private void mObj_ParentChanged(PaintingObject sender, EventArgs e)
{
mObjControl = mObj.Parent;
mObjParent = mObjControl?.Parent;
}
}