private void AddVerticalEdges(ICanvasItem canvasItem)
{
var range = new Range(canvasItem.Top, canvasItem.Top + canvasItem.Height);
Edges.Add(new Edge(canvasItem.Left, range, Orientation.Vertical));
Edges.Add(new Edge(canvasItem.Right, range, Orientation.Vertical));
}
public UIResizeOperationHandleConnector(ICanvasItem canvasItem, IUserInputReceiver parent, IEdgeSnappingEngine snappingEngine)
{
CanvasItem = canvasItem;
Parent = parent;
SnappingEngine = snappingEngine;
Handles = new Dictionary<IUserInputReceiver, IPoint>();
}
public DragOperation(ICanvasItem child, Point startingPoint)
{
Child = child;
StartingPoint = startingPoint;
ChildStartingPoint = child.GetLocation();
}
public DragOperation(ICanvasItem child, IPoint startingPoint, ISnappingEngine snappingEngine)
{
SnappingEngine = snappingEngine;
Child = child;
StartingPoint = startingPoint;
ChildStartingPoint = child.GetPosition();
}
/// <summary>
/// Функция изменения текущего объекта для манипуляций
/// </summary>
/// <param name="currentItem">Новый объект</param>
public static void SetCurrentItem(ICanvasItem currentItem = null)
{
_currentItem?.Deselect();
_currentItem = currentItem;
_currentItem?.Select();
_refresh?.Invoke();
}
private void RemoveSelectionAdorner(ICanvasItem container)
{
var adorner = SelectionAdorners[container];
SelectionAdorners.Remove(container);
DesignSurface.RemoveAdorner(adorner);
}
private void AddVerticalEdges(ICanvasItem canvasItem)
{
var range = new Range(canvasItem.Top, canvasItem.Top + canvasItem.Height);
Edges.Add(new Edge(canvasItem.Left, range, Orientation.Vertical));
Edges.Add(new Edge(canvasItem.Right, range, Orientation.Vertical));
}
public UIResizeOperationHandleConnector(ICanvasItem canvasItem, IUserInputReceiver parent, IEdgeSnappingEngine snappingEngine)
{
CanvasItem = canvasItem;
Parent = parent;
SnappingEngine = snappingEngine;
Handles = new Dictionary <IUserInputReceiver, IPoint>();
}
/// <summary>
/// Функция вычисление/инициации добавления нового объекта
/// </summary>
/// <param name="pos">Координаты добавления нового объекта</param>
private void AddNewItem(Point pos)
{
_items.ForEach(c => c.Deselect());
ICanvasItem _newObject = null;
switch (CurrentSettings.Mode)
{
case ECanvasMode.BrokenLine:
_newObject = new CustBrokenLine(pos);
break;
case ECanvasMode.Rectangle:
_newObject = new CustRectangle(pos);
break;
}
if (_newObject == null)
{
CurrentSettings.SetCurrentItem();
CurrentSettings.SetIsDraw(false);
return;
}
AppendNewItem(_newObject);
CurrentSettings.SetIsDraw(true);
CurrentSettings.SetCurrentItem(_newObject);
CurrentSettings.AppendNewAction(ECancelTypes.Add, _newObject);
}
private void AddSelectionAdorner(ICanvasItem canvasItem)
{
var selectionAdorner = ServiceLocator.UIElementFactory.CreateSelectionAdorner(DesignSurface, canvasItem);
DesignSurface.AddAdorner(selectionAdorner);
SelectionAdorners.Add(canvasItem, selectionAdorner);
}
public DragOperation(ICanvasItem child, Point startingPoint)
{
Child = child;
StartingPoint = startingPoint;
ChildStartingPoint = child.GetLocation();
}
void ICanvas.addChild(ICanvasItem item)
{
lock (lockObj)
{
canvasItems.Add(item);
}
}
public IAdorner CreateSelectionAdorner(IDesignSurface designSurface, ICanvasItem canvasItem)
{
return(new SelectionAdorner(designSurface, canvasItem)
{
IsHitTestVisible = false
});
}
public WpfUIResizeOperationHandleConnector(ICanvasItem canvasItem, IInputElement parent, IEdgeSnappingEngine snappingEngine)
{
CanvasItem = canvasItem;
Parent = parent;
SnappingEngine = snappingEngine;
Handles = new Dictionary<IInputElement, IPoint>();
}
public DragOperation(ICanvasItem child, IPoint startingPoint, ISnappingEngine snappingEngine)
{
SnappingEngine = snappingEngine;
Child = child;
StartingPoint = startingPoint;
ChildStartingPoint = child.GetPosition();
}
/// <summary>
/// Gets the container, if generated, for a specific item.
/// </summary>
/// <returns></returns>
public DependencyObject ContainerFromItem(ICanvasItem item)
{
if (item == null) throw new ArgumentNullException(nameof(item));
DependencyObject container;
if (containerDict.TryGetValue(item, out container))
return container;
return null;
}
public void SetDragTarget(IInputElement hitTestReceiver, ICanvasItem itemToDrag)
{
if ( this.dragRecordingScope != null )
throw new InvalidOperationException("There is already an active drag operation.");
this.ItemToDrag = itemToDrag;
hitTestReceiver.PreviewMouseLeftButtonDown += TargetOnPreviewMouseLeftButtonDown;
}
/// <summary>
/// Функция инициации отмены последнего действия
/// </summary>
public static void Cancel()
{
ChangeMode(ECanvasMode.Hand);
_currentItem = null;
_isReDraw = false;
_cancelImplement.Cancel();
_refresh?.Invoke();
}
private static void ApplySeparationBetween(ICanvasItem item1, ICanvasItem item2, double separation)
{
var currentSeparation = GetHorizontalSpaceBetween(item1, item2);
var deltaSeparation = separation - currentSeparation;
var offset = new Point(deltaSeparation, 0);
item2.Offset(offset);
}
/// <summary>
/// Функция изменения режима взаимодействия с холстом и объектами на нем
/// </summary>
/// <param name="currentMode">Новый режим</param>
public static void ChangeMode(ECanvasMode currentMode = ECanvasMode.Hand)
{
_currentMode = currentMode;
_currentItem?.Deselect();
_currentItem = null;
_isReDraw = false;
_refresh?.Invoke();
}
/// <summary>
/// Gets a new or pooled container for a specific Entity.
/// </summary>
public DependencyObject CreateContainer(ICanvasItem item)
{
if (item == null) throw new ArgumentNullException(nameof(item));
var container = entityContainerPool.Take();
PrepareContainer(container, item);
var doContainer = container;
containerDict.Add(item, doContainer);
return doContainer;
}
private void PrepareContainer(DependencyObject container, ICanvasItem item)
{
if (container == null) throw new ArgumentNullException(nameof(container));
container.SetValue(DataItemProperty, item);
// Ensure a connection line won't cover any entity.
container.SetValue(FrameworkElement.DataContextProperty, item);
container.SetValue(Panel.ZIndexProperty, 10);
OnContainerPreparing(new ContainerPreparingEventArgs(container, item));
}
public ResizeOperation(ICanvasItem child, IPoint handlePoint, ISnappingEngine snappingEngine)
{
Child = child;
HandlePoint = handlePoint;
SetCanResize(child, handlePoint);
Opposite = HandlePoint.GetOpposite(child.Rect().MiddlePoint());
SnappingEngine = snappingEngine;
this.recordingScope = RecordingServices.DefaultRecorder.OpenScope(string.Format( "Resize {0}", this.child.GetName() ));
}
public ResizeOperation(ICanvasItem child, IPoint handlePoint, ISnappingEngine snappingEngine)
{
Child = child;
HandlePoint = handlePoint;
SetCanResize(child, handlePoint);
Opposite = HandlePoint.GetOpposite(child.Rect().MiddlePoint());
SnappingEngine = snappingEngine;
this.recordingScope = CanvasModelItem.Recorder.StartAtomicScope("Resize", false);
}
public ResizeOperation(ICanvasItem child, IPoint handlePoint, ISnappingEngine snappingEngine)
{
Child = child;
HandlePoint = handlePoint;
SetCanResize(child, handlePoint);
Opposite = HandlePoint.GetOpposite(child.Rect().MiddlePoint());
SnappingEngine = snappingEngine;
this.recordingScope = RecordingServices.DefaultRecorder.OpenScope(string.Format("Resize {0}", this.child.GetName()));
}
public void SetDragTarget(IUserInputReceiver hitTestReceiver, ICanvasItem itemToDrag)
{
if (this.dragRecordingScope != null)
{
throw new InvalidOperationException("There is already an active drag operation.");
}
this.ItemToDrag = itemToDrag;
hitTestReceiver.FingerDown += TargetOnPreviewMouseLeftButtonDown;
}
private void OnCanvasItemChanged(ICanvasItem oldCanvasItem, ICanvasItem newCanvasItem)
{
if (IsLoaded)
{
RegisterHandles();
}
else
{
Loaded += OnLoaded;
}
}
private void OnCanvasItemChanged(ICanvasItem oldCanvasItem, ICanvasItem newCanvasItem)
{
if (IsLoaded)
{
RegisterHandles();
}
else
{
Loaded += OnLoaded;
}
}
private static void Resize(ICanvasItem canvasItem, SizeChangeEventArgs sizeChange, double currentParentLeft)
{
var currentLeft = canvasItem.Left - currentParentLeft;
var currentWidth = canvasItem.Width;
var leftProportion = currentLeft / sizeChange.OldValue;
var widthProportion = currentWidth / sizeChange.OldValue;
canvasItem.Left = currentParentLeft + sizeChange.NewValue * leftProportion;
canvasItem.Width = sizeChange.NewValue * widthProportion;
}
private static void Resize(ICanvasItem canvasItem, SizeChangeEventArgs sizeChange, double currentParentLeft)
{
var currentLeft = canvasItem.Left - currentParentLeft;
var currentWidth = canvasItem.Width;
var leftProportion = currentLeft / sizeChange.OldValue;
var widthProportion = currentWidth / sizeChange.OldValue;
canvasItem.Left = currentParentLeft + sizeChange.NewValue * leftProportion;
canvasItem.Width = sizeChange.NewValue * widthProportion;
}
private void SetCanResize(ICanvasItem canvasItem, IPoint handlePoint)
{
var rect = canvasItem.Rect();
var middlePoint = rect.MiddlePoint();
var distanceX = Math.Abs(middlePoint.X - handlePoint.X);
var distanceY = Math.Abs(middlePoint.Y - handlePoint.Y);
double delta = 0.3;
CanChangeHorizontalPosition = distanceX > delta*canvasItem.Width;
CanChangeVerticalPosition = distanceY > delta * canvasItem.Height;
}
private void SetCanResize(ICanvasItem canvasItem, IPoint handlePoint)
{
var rect = canvasItem.Rect();
var middlePoint = rect.MiddlePoint();
var distanceX = Math.Abs(middlePoint.X - handlePoint.X);
var distanceY = Math.Abs(middlePoint.Y - handlePoint.Y);
double delta = 0.3;
CanChangeHorizontalPosition = distanceX > delta * canvasItem.Width;
CanChangeVerticalPosition = distanceY > delta * canvasItem.Height;
}
public void drawToCanvas(ICanvasItem uIElement, double x, double y)
{
uIElement.setTopLeft(startX + x, startY + y);
if (clippingEnbaled)
{
canvas.enableClipping((int)(clipingBounds.X), (int)(clipingBounds.Y), (int)clipingBounds.Width, (int)clipingBounds.Height);
}
else
{
canvas.disableClipping();
}
canvas.drawToCanvas(uIElement);
}
public static void RemoveAndPromoteChildren(this ICanvasItem canvasItem)
{
var newParent = canvasItem.Parent;
var children = canvasItem.Children.ToList();
IPoint location = canvasItem.GetPosition();
foreach (var child in children)
{
child.Offset(location);
canvasItem.Children.Remove(child);
newParent.Children.Add(child);
}
}
internal CanvasAdorner GenerateDesigningAdornerFormItem(ICanvasItem obj)
{
if (obj == null) throw new ArgumentNullException(nameof(obj));
var entity = obj as IBoxCanvasItem;
var polyLine = obj as IPolyLineCanvasItem;
var e = new DesigningAdornerGeneratingEventArgs(obj);
// Initialize defaults.
if (entity != null)
e.Adorder = new ResizeRotateAdorner(entity);
else if (polyLine != null)
e.Adorder = new PolyLineVerticesAdorner(polyLine);
OnDesigningAdornerGenerating(e);
return e.Adorder;
}
/// <summary>
/// Функция удаления текущего объекта
/// </summary>
public static void Remove()
{
if (_currentItem == null)
{
return;
}
AppendNewAction(ECancelTypes.Remove, _currentItem);
_currentItem.Remove();
_currentItem = null;
_isReDraw = false;
_refresh?.Invoke();
_move?.Invoke();
}
private void Group(object sender, ExecutedRoutedEventArgs executedRoutedEventArgs)
{
var groupCommandArgs = (GroupCommandArgs)executedRoutedEventArgs.Parameter;
IEnumerable <ICanvasItem> items = DesignSurface.GetSelectedCanvasItems().ToList();
ICanvasItem group = groupCommandArgs.CreateHostingItem();
using (RecordingServices.DefaultRecorder.OpenScope("Group"))
{
// We have to *first* add the group to the document to make it recordable.
this.DesignSurface.CanvasDocument.Children.Add(@group);
items.Reparent(@group);
}
}
protected override string FormatOperationDescriptor(IOperationDescriptor operation)
{
if (operation.OperationKind == OperationKind.Method)
{
MethodExecutionOperationDescriptor descriptor = (MethodExecutionOperationDescriptor)operation;
if (descriptor.Method != null &&
(descriptor.Method.Attributes & MethodAttributes.SpecialName) != 0 &&
descriptor.Method.Name.StartsWith("set_"))
{
ICanvasItem canvasItem = (ICanvasItem)descriptor.Target;
return(string.Format("Changing {0} of {1}", descriptor.Method.Name.Substring(4), canvasItem.GetName()));
}
}
return(null);
}
public static void SwapCoordinates(this ICanvasItem item)
{
var left = item.Left;
var top = item.Top;
Swap(ref left, ref top);
var width = item.Width;
var height = item.Height;
Swap(ref width, ref height);
item.Left = left;
item.Top = top;
item.Width = width;
item.Height = height;
}
private void DragThumb_DragStarted(object sender, DragStartedEventArgs e)
{
destItem = DataContext as ICanvasItem;
if (destItem == null)
{
return;
}
designer = DesignerCanvas.FindDesignerCanvas(this);
if (designer == null)
{
return;
}
instantPreview = designer.SelectedItems.Count < InstantPreviewItemsThreshold;
foreach (var item in designer.SelectedItems)
{
item.NotifyUserDraggingStarted();
}
}
public static void Reparent(this IEnumerable<ICanvasItem> items, ICanvasItem destination)
{
var rect = Extensions.GetBoundsFromChildren(items);
var toRemove = items.ToList();
destination.SetBounds(rect);
foreach (var canvasItem in toRemove)
{
var parent = canvasItem.Parent;
parent.Children.Remove(canvasItem);
}
foreach (var canvasItem in items)
{
destination.Children.Add(canvasItem);
canvasItem.Offset(rect.Location.Negative());
}
}
public void drawToCanvas(ICanvasItem canvasItem)
{
if (clippingEnabled)
{
GL.Enable(EnableCap.ScissorTest);
//GL.Scissor(clipX, (Height - clipY - clipHeight), clipWidth, clipHeight);
GL.Scissor(clipX, Height - clipY - clipHeight, clipWidth, clipHeight);
}
else
{
GL.Disable(EnableCap.ScissorTest);
}
Matrix4 _view = Matrix4.CreateTranslation(-(Width) / 2f, (Height) / 2f, -3.0f);
Matrix4 _projection = Matrix4.CreateOrthographic(Width, Height, 0.1f, 100.0f);
((IGLCanvasItem)canvasItem).render(_view, _projection);
GL.Disable(EnableCap.ScissorTest);
}
public EdgeAdorner(IUIElement adornedElement, ICanvasItem canvasItem, Edge edge) : base(adornedElement, canvasItem)
{
Edge = edge;
}
public IAdorner CreateEdgeAdorner(IUIElement adornedElement, ICanvasItem item, Edge edge)
{
return new EdgeAdorner(adornedElement, item, edge);
}
public EdgeAdorner([NotNull] IUIElement adornedElement, ICanvasItem item, Edge edge)
: base((UIElement) adornedElement.GetCoreInstance(), item)
{
Edge = edge;
}
public IAdorner CreateSelectionAdorner(IDesignSurface designSurface, ICanvasItem canvasItem)
{
return new DesignSurface.VisualAids.Selection.SelectionAdorner(designSurface, canvasItem);
}
private void OnCanvasItemChanged(ICanvasItem oldCanvasItem, ICanvasItem newCanvasItem)
{
}
private static double GetHorizontalSpaceBetween(ICanvasItem item1, ICanvasItem item2)
{
return item2.Left - item1.Right;
}
private static void ApplySeparationBetween(ICanvasItem item1, ICanvasItem item2, double separation)
{
var currentSeparation = GetHorizontalSpaceBetween(item1, item2);
var deltaSeparation = separation - currentSeparation;
var offset = ServiceLocator.CoreTypesFactory.CreatePoint(deltaSeparation, 0);
item2.Offset(offset);
}
public ResizeControl(ICanvasItem itemToResize, IUserInputReceiver parent, IEdgeSnappingEngine snappingEngine)
{
SnappingEngine = snappingEngine;
FrameOfReference = parent;
CanvasItem = itemToResize;
}
public void AddItemToSelection(ICanvasItem item)
{
AddSelectionAdorner(item);
WrapSelectedItems();
}
public CanvasItemAdorner(IUIElement adornedElement, ICanvasItem canvasItem)
: base(adornedElement)
{
CanvasItem = canvasItem;
}
public WrappingAdorner(IUIElement adornedElement, IControl chrome, ICanvasItem canvasItem)
: base(adornedElement, canvasItem)
{
Chrome = chrome;
}
public SelectionAdorner(IUIElement adornedElement, ICanvasItem canvasItem)
: base((UIElement) adornedElement.GetCoreInstance(), canvasItem)
{
}
public ProportionalResizer(ICanvasItem canvasItem)
{
this.canvasItem = canvasItem;
}
private void RemoveSelectionAdorner(ICanvasItem container)
{
var adorner = SelectionAdorners[container];
SelectionAdorners.Remove(container);
AdornerLayer.Remove(adorner);
}
protected CanvasItemAdorner(IUIElement adornedElement, ICanvasItem canvasItem)
{
AdornedElement = adornedElement;
CanvasItem = canvasItem;
}
private void AddSelectionAdorner(ICanvasItem canvasItem)
{
var selectionAdorner = new SelectionAdorner(DesignSurface, canvasItem) { IsHitTestVisible = false };
AdornerLayer.Add(selectionAdorner);
SelectionAdorners.Add(canvasItem, selectionAdorner);
}
public IAdorner CreateWrappingAdorner(IUIElement adornerElement, IControl chrome, ICanvasItem canvasItem)
{
return new WrappingAdorner(adornerElement, chrome, canvasItem);
}
public void RemoveItemFromSelection(ICanvasItem item)
{
RemoveSelectionAdorner(item);
WrapSelectedItems();
}
