mirror of
https://gitee.com/akwkevin/aistudio.-wpf.-diagram
synced 2026-03-03 00:00:57 +08:00
1776 lines
62 KiB
C#
1776 lines
62 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Collections.ObjectModel;
|
||
using System.ComponentModel;
|
||
using System.Linq;
|
||
using System.Reactive.Linq;
|
||
using System.Runtime.InteropServices;
|
||
using System.Windows;
|
||
using System.Windows.Input;
|
||
using System.Windows.Media;
|
||
using AIStudio.Wpf.DiagramDesigner.Geometrys;
|
||
using AIStudio.Wpf.DiagramDesigner.Helpers;
|
||
using AIStudio.Wpf.DiagramDesigner.Models;
|
||
using Newtonsoft.Json;
|
||
|
||
namespace AIStudio.Wpf.DiagramDesigner
|
||
{
|
||
public class DiagramViewModel : BindableBase, IDiagramViewModel
|
||
{
|
||
#region 属性
|
||
private bool _isReadOnly;
|
||
public bool IsReadOnly
|
||
{
|
||
get
|
||
{
|
||
return _isReadOnly;
|
||
}
|
||
set
|
||
{
|
||
SetProperty(ref _isReadOnly, value);
|
||
}
|
||
}
|
||
|
||
public bool IsLoading
|
||
{
|
||
get; set;
|
||
}
|
||
|
||
public IDrawModeViewModel DrawModeViewModel
|
||
{
|
||
get; set;
|
||
}
|
||
|
||
public IColorViewModel ColorViewModel
|
||
{
|
||
get; set;
|
||
}
|
||
|
||
private PageSizeType _pageSizeType = PageSizeType.A4;
|
||
public PageSizeType PageSizeType
|
||
{
|
||
get
|
||
{
|
||
return _pageSizeType;
|
||
}
|
||
set
|
||
{
|
||
SetProperty(ref _pageSizeType, value);
|
||
RaisePropertyChanged(nameof(PageSize));
|
||
}
|
||
}
|
||
|
||
private Size _pageSize = new Size(1000, 600);
|
||
|
||
public Size PageSize
|
||
{
|
||
get
|
||
{
|
||
if (PageSizeOrientation == PageSizeOrientation.Vertical)
|
||
{
|
||
return GetPageSize();
|
||
}
|
||
else
|
||
{
|
||
return new Size(GetPageSize().Height, GetPageSize().Width);
|
||
}
|
||
}
|
||
set
|
||
{
|
||
SetProperty(ref _pageSize, value);
|
||
}
|
||
}
|
||
|
||
public Size GetPageSize()
|
||
{
|
||
switch (PageSizeType)
|
||
{
|
||
case PageSizeType.Letter: return new Size(612, 792);
|
||
case PageSizeType.Folio: return new Size(612, 936);
|
||
case PageSizeType.Legal: return new Size(612, 1008);
|
||
case PageSizeType.Executive: return new Size(522, 756);
|
||
case PageSizeType.Statement: return new Size(396, 612);
|
||
case PageSizeType.Envelope: return new Size(297, 684);
|
||
case PageSizeType.MonarchEnvelope: return new Size(279, 540);
|
||
case PageSizeType.Tabloid: return new Size(792, 1224);
|
||
case PageSizeType.LetterSmall: return new Size(612, 792);
|
||
case PageSizeType.CSheet: return new Size(1224, 1584);
|
||
case PageSizeType.DSheet: return new Size(1584, 2448);
|
||
case PageSizeType.ESheet: return new Size(2448, 3168);
|
||
case PageSizeType.A3: return new Size(842, 1191);
|
||
case PageSizeType.A4: return new Size(595, 842);
|
||
case PageSizeType.A5: return new Size(420, 595);
|
||
case PageSizeType.B4: return new Size(709, 1003);
|
||
case PageSizeType.B5: return new Size(516, 729);
|
||
case PageSizeType.DLEnvelope: return new Size(312, 624);
|
||
case PageSizeType.C5Envelope: return new Size(459, 649);
|
||
case PageSizeType.Quarto: return new Size(609, 780);
|
||
case PageSizeType.C6Quarto: return new Size(323, 459);
|
||
case PageSizeType.B5Quarto: return new Size(499, 709);
|
||
case PageSizeType.ItalyQuarto: return new Size(312, 652);
|
||
case PageSizeType.A4small: return new Size(595, 842);
|
||
case PageSizeType.GermanStdFanfold: return new Size(612, 864);
|
||
case PageSizeType.GermanLegalFanfold: return new Size(576, 936);
|
||
case PageSizeType.PRC16K: return new Size(414, 609);
|
||
case PageSizeType.PRC32K: return new Size(275, 428);
|
||
default: return _pageSize;
|
||
}
|
||
}
|
||
|
||
private PageSizeOrientation _pageSizeOrientation;
|
||
public PageSizeOrientation PageSizeOrientation
|
||
{
|
||
get
|
||
{
|
||
return _pageSizeOrientation;
|
||
}
|
||
set
|
||
{
|
||
SetProperty(ref _pageSizeOrientation, value);
|
||
RaisePropertyChanged(nameof(PageSize));
|
||
}
|
||
}
|
||
|
||
private PageUnit _pageUnit = PageUnit.cm;
|
||
[Browsable(false)]
|
||
public PageUnit PageUnit
|
||
{
|
||
get
|
||
{
|
||
return _pageUnit;
|
||
}
|
||
set
|
||
{
|
||
if (value != PageUnit.cm && value != PageUnit.inch)
|
||
{
|
||
return;
|
||
}
|
||
SetProperty(ref _pageUnit, value);
|
||
}
|
||
}
|
||
|
||
private Size _gridCellSize = new Size(100, 100);
|
||
public Size GridCellSize
|
||
{
|
||
get
|
||
{
|
||
return _gridCellSize;
|
||
}
|
||
set
|
||
{
|
||
SetProperty(ref _gridCellSize, value);
|
||
}
|
||
}
|
||
|
||
public double GridCellWidth
|
||
{
|
||
get
|
||
{
|
||
return _gridCellSize.Width;
|
||
}
|
||
set
|
||
{
|
||
_gridCellSize.Width = value;
|
||
RaisePropertyChanged(nameof(GridCellSize));
|
||
}
|
||
}
|
||
|
||
public double GridCellHeight
|
||
{
|
||
get
|
||
{
|
||
return _gridCellSize.Height;
|
||
}
|
||
set
|
||
{
|
||
_gridCellSize.Height = value;
|
||
RaisePropertyChanged(nameof(GridCellSize));
|
||
}
|
||
}
|
||
|
||
private Color _pageBackground = Colors.White;
|
||
public Color PageBackground
|
||
{
|
||
get
|
||
{
|
||
return _pageBackground;
|
||
}
|
||
set
|
||
{
|
||
SetProperty(ref _pageBackground, value);
|
||
}
|
||
}
|
||
|
||
private bool _showGrid;
|
||
public bool ShowGrid
|
||
{
|
||
get
|
||
{
|
||
return _showGrid;
|
||
}
|
||
set
|
||
{
|
||
SetProperty(ref _showGrid, value);
|
||
}
|
||
}
|
||
|
||
private Color _gridColor = Colors.LightGray;
|
||
public Color GridColor
|
||
{
|
||
get
|
||
{
|
||
return _gridColor;
|
||
}
|
||
set
|
||
{
|
||
SetProperty(ref _gridColor, value);
|
||
}
|
||
}
|
||
|
||
private Size _gridMargin = new Size(28, 28);
|
||
public Size GridMarginSize
|
||
{
|
||
get
|
||
{
|
||
return _gridMargin;
|
||
}
|
||
set
|
||
{
|
||
SetProperty(ref _gridMargin, value);
|
||
}
|
||
}
|
||
|
||
public double GridMarginWidth
|
||
{
|
||
get
|
||
{
|
||
return _gridMargin.Width;
|
||
}
|
||
set
|
||
{
|
||
_gridMargin.Width = value;
|
||
RaisePropertyChanged(nameof(GridMarginSize));
|
||
}
|
||
}
|
||
|
||
public double GridMarginHeight
|
||
{
|
||
get
|
||
{
|
||
return _gridMargin.Height;
|
||
}
|
||
set
|
||
{
|
||
_gridMargin.Height = value;
|
||
RaisePropertyChanged(nameof(GridMarginSize));
|
||
}
|
||
}
|
||
|
||
private double _zoomValue = 1;
|
||
[Browsable(false)]
|
||
public double ZoomValue
|
||
{
|
||
get
|
||
{
|
||
return _zoomValue;
|
||
}
|
||
set
|
||
{
|
||
SetProperty(ref _zoomValue, value);
|
||
}
|
||
}
|
||
|
||
private string _name;
|
||
[Browsable(false)]
|
||
public string Name
|
||
{
|
||
get
|
||
{
|
||
return _name;
|
||
}
|
||
set
|
||
{
|
||
SetProperty(ref _name, value);
|
||
}
|
||
}
|
||
|
||
private DiagramType _diagramType;
|
||
[Browsable(false)]
|
||
public DiagramType DiagramType
|
||
{
|
||
get
|
||
{
|
||
return _diagramType;
|
||
}
|
||
set
|
||
{
|
||
SetProperty(ref _diagramType, value);
|
||
}
|
||
}
|
||
|
||
private CellHorizontalAlignment _cellHorizontalAlignment;
|
||
[Browsable(false)]
|
||
public CellHorizontalAlignment CellHorizontalAlignment
|
||
{
|
||
get
|
||
{
|
||
return _cellHorizontalAlignment;
|
||
}
|
||
set
|
||
{
|
||
SetProperty(ref _cellHorizontalAlignment, value);
|
||
}
|
||
}
|
||
|
||
private CellVerticalAlignment _cellVerticalAlignment;
|
||
[Browsable(false)]
|
||
public CellVerticalAlignment CellVerticalAlignment
|
||
{
|
||
get
|
||
{
|
||
return _cellVerticalAlignment;
|
||
}
|
||
set
|
||
{
|
||
SetProperty(ref _cellVerticalAlignment, value);
|
||
}
|
||
}
|
||
|
||
|
||
private bool _isEditName;
|
||
[Browsable(false)]
|
||
public bool IsEditName
|
||
{
|
||
get
|
||
{
|
||
return _isEditName;
|
||
}
|
||
set
|
||
{
|
||
SetProperty(ref _isEditName, value);
|
||
}
|
||
}
|
||
|
||
private System.Windows.Point _currentPoint;
|
||
[Browsable(false)]
|
||
public System.Windows.Point CurrentPoint
|
||
{
|
||
get
|
||
{
|
||
return _currentPoint;
|
||
}
|
||
set
|
||
{
|
||
SetProperty(ref _currentPoint, value);
|
||
}
|
||
}
|
||
|
||
private Color _currentColor;
|
||
[Browsable(false)]
|
||
public Color CurrentColor
|
||
{
|
||
get
|
||
{
|
||
return _currentColor;
|
||
}
|
||
set
|
||
{
|
||
SetProperty(ref _currentColor, value);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 用于wpf大小与物理像素之间转换
|
||
/// </summary>
|
||
public double ScreenScale { get; set; } = 1;
|
||
|
||
private double OffsetX = 10;
|
||
private double OffsetY = 10;
|
||
#endregion
|
||
|
||
private DoCommandManager DoCommandManager = new DoCommandManager();
|
||
public DiagramViewModel()
|
||
{
|
||
CreateNewDiagramCommand = new SimpleCommand(ExecuteEnable, ExecuteCreateNewDiagramCommand);
|
||
AddItemCommand = new SimpleCommand(ExecuteEnable, ExecuteAddItemCommand);
|
||
DirectAddItemCommand = new SimpleCommand(ExecuteEnable, ExecuteDirectAddItemCommand);
|
||
RemoveItemCommand = new SimpleCommand(ExecuteEnable, ExecuteRemoveItemCommand);
|
||
DirectRemoveItemCommand = new SimpleCommand(ExecuteEnable, ExecuteDirectRemoveItemCommand);
|
||
ClearSelectedItemsCommand = new SimpleCommand(ExecuteEnable, ExecuteClearSelectedItemsCommand);
|
||
|
||
AlignTopCommand = new SimpleCommand(ExecuteEnable, ExecuteAlignTopCommand);
|
||
AlignVerticalCentersCommand = new SimpleCommand(ExecuteEnable, ExecuteAlignVerticalCentersCommand);
|
||
AlignBottomCommand = new SimpleCommand(ExecuteEnable, ExecuteAlignBottomCommand);
|
||
AlignLeftCommand = new SimpleCommand(ExecuteEnable, ExecuteAlignLeftCommand);
|
||
AlignHorizontalCentersCommand = new SimpleCommand(ExecuteEnable, ExecuteAlignHorizontalCentersCommand);
|
||
AlignRightCommand = new SimpleCommand(ExecuteEnable, ExecuteAlignRightCommand);
|
||
BringForwardCommand = new SimpleCommand(ExecuteEnable, ExecuteBringForwardCommand);
|
||
BringToFrontCommand = new SimpleCommand(ExecuteEnable, ExecuteBringToFrontCommand);
|
||
SendBackwardCommand = new SimpleCommand(ExecuteEnable, ExecuteSendBackwardCommand);
|
||
SendToBackCommand = new SimpleCommand(ExecuteEnable, ExecuteSendToBackCommand);
|
||
DistributeHorizontalCommand = new SimpleCommand(ExecuteEnable, ExecuteDistributeHorizontalCommand);
|
||
DistributeVerticalCommand = new SimpleCommand(ExecuteEnable, ExecuteDistributeVerticalCommand);
|
||
SelectAllCommand = new SimpleCommand(ExecuteEnable, ExecuteSelectAllCommand);
|
||
CopyCommand = new SimpleCommand(ExecuteEnable, ExecuteCopyCommand);
|
||
PasteCommand = new SimpleCommand(ExecuteEnable, ExecutePasteCommand);
|
||
CutCommand = new SimpleCommand(ExecuteEnable, ExecuteCutCommand);
|
||
DeleteCommand = new SimpleCommand(ExecuteEnable, ExecuteDeleteCommand);
|
||
LeftMoveCommand = new SimpleCommand(ExecuteEnable, ExecuteLeftMoveCommand);
|
||
RightMoveCommand = new SimpleCommand(ExecuteEnable, ExecuteRightMoveCommand);
|
||
UpMoveCommand = new SimpleCommand(ExecuteEnable, ExecuteUpMoveCommand);
|
||
DownMoveCommand = new SimpleCommand(ExecuteEnable, ExecuteDownMoveCommand);
|
||
CenterMoveCommand = new SimpleCommand(ExecuteEnable, ExecuteCenterMoveCommand);
|
||
SameSizeCommand = new SimpleCommand(ExecuteEnable, ExecuteSameSizeCommand);
|
||
SameWidthCommand = new SimpleCommand(ExecuteEnable, ExecuteSameWidthCommand);
|
||
SameHeightCommand = new SimpleCommand(ExecuteEnable, ExecuteSameHeightCommand);
|
||
SameAngleCommand = new SimpleCommand(ExecuteEnable, ExecuteSameAngleCommand);
|
||
GroupCommand = new SimpleCommand(ExecuteEnable, ExecuteGroupCommand);
|
||
UngroupCommand = new SimpleCommand(ExecuteEnable, ExecuteUngroupCommand);
|
||
LockCommand = new SimpleCommand(ExecuteEnable, ExecuteLockCommand);
|
||
UnlockCommand = new SimpleCommand(ExecuteEnable, ExecuteUnlockCommand);
|
||
Mediator.Instance.Register(this);
|
||
|
||
Items.CollectionChanged += Items_CollectionChanged;
|
||
}
|
||
|
||
public bool ExecuteEnable(object para)
|
||
{
|
||
return IsReadOnly == false;
|
||
}
|
||
|
||
#region UnDo ReDo
|
||
|
||
private void Do(object sender, string propertyName, object newvalue)
|
||
{
|
||
sender.SetPropertyValue(propertyName, newvalue);
|
||
}
|
||
|
||
private void UnDo(object sender, string propertyName, object oldvalue)
|
||
{
|
||
sender.SetPropertyValue(propertyName, oldvalue);
|
||
}
|
||
|
||
private bool _undoing;
|
||
private void UndoExecuted(object para)
|
||
{
|
||
_undoing = true;
|
||
DoCommandManager.UnDo();
|
||
_undoing = false;
|
||
}
|
||
private void RedoExecuted(object para)
|
||
{
|
||
_undoing = true;
|
||
DoCommandManager.ReDo();
|
||
_undoing = false;
|
||
}
|
||
private bool Undo_Enabled(object para)
|
||
{
|
||
return DoCommandManager.CanUnDo;
|
||
}
|
||
private bool Redo_Enabled(object para)
|
||
{
|
||
return DoCommandManager.CanReDo;
|
||
}
|
||
|
||
#endregion
|
||
|
||
private void Items_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
|
||
{
|
||
if (e.OldItems != null)
|
||
{
|
||
foreach (var item in e.OldItems.OfType<SelectableDesignerItemViewModelBase>())
|
||
{
|
||
item.PropertyChanged -= Item_PropertyChanged;
|
||
item.Dispose();
|
||
}
|
||
}
|
||
if (e.NewItems != null)
|
||
{
|
||
foreach (var item in e.NewItems.OfType<SelectableDesignerItemViewModelBase>())
|
||
{
|
||
item.PropertyChanged += Item_PropertyChanged;
|
||
}
|
||
}
|
||
|
||
RaisePropertyChanged("Items");
|
||
}
|
||
|
||
private void Item_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
|
||
{
|
||
RaisePropertyChanged(sender, e.PropertyName);
|
||
|
||
if (_undoing == true) return;
|
||
|
||
//连续改变，需要特殊处理，不单独触发属性改变ReDo
|
||
if (sender is DesignerItemViewModelBase designer)
|
||
{
|
||
if (designer.BeginDo) return;
|
||
}
|
||
|
||
if (e is ValuePropertyChangedEventArgs valuePropertyChangedEventArgs)
|
||
{
|
||
var property = sender.GetType().GetProperty(e.PropertyName);
|
||
var attr = property.GetCustomAttributes(typeof(CanDoAttribute), true);
|
||
if (attr != null && attr.Length != 0)
|
||
{
|
||
DoCommandManager.DoNewCommand(sender.ToString() + e.PropertyName, () => Do(sender, e.PropertyName, valuePropertyChangedEventArgs.NewValue), () => UnDo(sender, e.PropertyName, valuePropertyChangedEventArgs.OldValue), null, false);
|
||
}
|
||
}
|
||
}
|
||
|
||
[MediatorMessageSink("DoneDrawingMessage")]
|
||
public void OnDoneDrawingMessage(bool dummy)
|
||
{
|
||
foreach (var item in Items.OfType<DesignerItemViewModelBase>())
|
||
{
|
||
item.ShowConnectors = false;
|
||
}
|
||
}
|
||
|
||
public SimpleCommand CreateNewDiagramCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand DirectAddItemCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand AddItemCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand DirectRemoveItemCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand RemoveItemCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand ClearSelectedItemsCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand AlignTopCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand AlignVerticalCentersCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand AlignBottomCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand AlignLeftCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand AlignHorizontalCentersCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand AlignRightCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand BringForwardCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand BringToFrontCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand SendBackwardCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand SendToBackCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
|
||
public SimpleCommand DistributeHorizontalCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand DistributeVerticalCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand SelectAllCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
|
||
public SimpleCommand CopyCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
|
||
public SimpleCommand PasteCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
|
||
public SimpleCommand CutCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
|
||
public SimpleCommand DeleteCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
|
||
public SimpleCommand LeftMoveCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
|
||
public SimpleCommand RightMoveCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
|
||
public SimpleCommand UpMoveCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
|
||
public SimpleCommand DownMoveCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
|
||
public SimpleCommand CenterMoveCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand SameSizeCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand SameWidthCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand SameHeightCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand SameAngleCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand GroupCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand UngroupCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand LockCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
public SimpleCommand UnlockCommand
|
||
{
|
||
get; private set;
|
||
}
|
||
|
||
private SimpleCommand _undoCommand;
|
||
public SimpleCommand UndoCommand
|
||
{
|
||
get
|
||
{
|
||
return this._undoCommand ?? (this._undoCommand = new SimpleCommand(Undo_Enabled, this.UndoExecuted));
|
||
}
|
||
}
|
||
|
||
private SimpleCommand _redoCommand;
|
||
public SimpleCommand RedoCommand
|
||
{
|
||
get
|
||
{
|
||
return this._redoCommand ?? (this._redoCommand = new SimpleCommand(Redo_Enabled, this.RedoExecuted));
|
||
}
|
||
}
|
||
|
||
|
||
public ObservableCollection<SelectableDesignerItemViewModelBase> Items { get; set; } = new ObservableCollection<SelectableDesignerItemViewModelBase>();
|
||
|
||
public List<SelectableDesignerItemViewModelBase> SelectedItems
|
||
{
|
||
get
|
||
{
|
||
return Items.Where(x => x.IsSelected).ToList();
|
||
}
|
||
}
|
||
|
||
|
||
private SelectionService selectionService;
|
||
public SelectionService SelectionService
|
||
{
|
||
get
|
||
{
|
||
if (selectionService == null)
|
||
selectionService = new SelectionService(this);
|
||
|
||
return selectionService;
|
||
}
|
||
}
|
||
|
||
public Func<SelectableDesignerItemViewModelBase, bool> OutAddVerify
|
||
{
|
||
get; set;
|
||
}
|
||
|
||
|
||
public bool AddVerify(SelectableDesignerItemViewModelBase item)
|
||
{
|
||
if (item.InitData() == false)
|
||
return false;
|
||
|
||
if (OutAddVerify != null && OutAddVerify(item) != true)
|
||
return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
private void ExecuteCreateNewDiagramCommand(object parameter)
|
||
{
|
||
this.Items.Clear();
|
||
}
|
||
|
||
private void ExecuteDirectAddItemCommand(object parameter)
|
||
{
|
||
if (parameter is SelectableDesignerItemViewModelBase ite)
|
||
{
|
||
if (AddVerify(ite) != true) return;
|
||
|
||
ClearSelectedItems();
|
||
Add(ite);
|
||
}
|
||
else if (parameter is List<SelectableDesignerItemViewModelBase> items)
|
||
{
|
||
if (items.Select(p => AddVerify(p)).Any() != true) return;
|
||
|
||
ClearSelectedItems();
|
||
foreach (var item in items)
|
||
{
|
||
Add(item);
|
||
}
|
||
}
|
||
}
|
||
|
||
private void Add(SelectableDesignerItemViewModelBase item)
|
||
{
|
||
item.Root = this;
|
||
item.ZIndex = Items.Count;
|
||
if (item.Id == Guid.Empty)
|
||
{
|
||
item.Id = Guid.NewGuid();
|
||
}
|
||
//item.LineColor = this.LineColor;
|
||
//item.FillColor = this.FillColor;
|
||
var logical = item as LogicalGateItemViewModelBase;
|
||
if (logical != null && logical.LogicalType > 0)
|
||
{
|
||
logical.OrderNumber = Items.OfType<LogicalGateItemViewModelBase>().Count(p => (int)p.LogicalType > 0) + 1;
|
||
}
|
||
|
||
var designerItemViewModelBase = item as DesignerItemViewModelBase;
|
||
if (designerItemViewModelBase != null)
|
||
{
|
||
designerItemViewModelBase.SetCellAlignment();
|
||
}
|
||
Items.Add(item);
|
||
item.IsSelected = true;
|
||
}
|
||
|
||
private void ExecuteAddItemCommand(object parameter)
|
||
{
|
||
if (parameter is SelectableDesignerItemViewModelBase ite)
|
||
{
|
||
if (AddVerify(ite) != true) return;
|
||
|
||
DoCommandManager.DoNewCommand(this.ToString(),
|
||
() => {
|
||
ClearSelectedItems();
|
||
Add(ite);
|
||
},
|
||
() => {
|
||
Items.Remove(ite);
|
||
});
|
||
}
|
||
else if (parameter is List<SelectableDesignerItemViewModelBase> items)
|
||
{
|
||
if (items.Select(p => AddVerify(p)).Any() != true) return;
|
||
|
||
DoCommandManager.DoNewCommand(this.ToString(),
|
||
() => {
|
||
ClearSelectedItems();
|
||
foreach (var item in items)
|
||
{
|
||
Add(item);
|
||
}
|
||
},
|
||
() => {
|
||
items.ForEach(item => Items.Remove(item));
|
||
});
|
||
}
|
||
}
|
||
|
||
private void ExecuteDirectRemoveItemCommand(object parameter)
|
||
{
|
||
if (parameter is SelectableDesignerItemViewModelBase ite)
|
||
{
|
||
ite.IsSelected = false;
|
||
Items.Remove(ite);
|
||
}
|
||
else if (parameter is List<SelectableDesignerItemViewModelBase> items)
|
||
{
|
||
foreach (var item in items)
|
||
{
|
||
item.IsSelected = false;
|
||
Items.Remove(item);
|
||
}
|
||
}
|
||
}
|
||
private void ExecuteRemoveItemCommand(object parameter)
|
||
{
|
||
if (parameter is SelectableDesignerItemViewModelBase ite)
|
||
{
|
||
DoCommandManager.DoNewCommand(this.ToString(),
|
||
() => {
|
||
ite.IsSelected = false;
|
||
Items.Remove(ite);
|
||
},
|
||
() => {
|
||
Items.Add(ite);
|
||
});
|
||
}
|
||
else if (parameter is List<SelectableDesignerItemViewModelBase> items)
|
||
{
|
||
DoCommandManager.DoNewCommand(this.ToString(),
|
||
() => {
|
||
foreach (var item in items)
|
||
{
|
||
item.IsSelected = false;
|
||
Items.Remove(item);
|
||
}
|
||
|
||
},
|
||
() => {
|
||
foreach (var item in items)
|
||
{
|
||
Items.Add(item);
|
||
}
|
||
|
||
});
|
||
}
|
||
}
|
||
private void ExecuteClearSelectedItemsCommand(object parameter)
|
||
{
|
||
ClearSelectedItems();
|
||
}
|
||
|
||
public void ClearSelectedItems()
|
||
{
|
||
foreach (var item in this.Items.ToList())
|
||
{
|
||
item.IsSelected = false;
|
||
}
|
||
}
|
||
|
||
#region 布局
|
||
private void ExecuteAlignTopCommand(object parameter)
|
||
{
|
||
var selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>();
|
||
var guid = Guid.NewGuid();
|
||
|
||
if (selectedItems.Count() > 1)
|
||
{
|
||
DoCommandManager.DoNewCommand(this.ToString(),
|
||
() => {
|
||
double top = selectedItems.OrderBy(p => p.Top).Select(p => p.Top).FirstOrDefault();
|
||
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
item.SetOldValue(item.Top, nameof(item.Top), guid.ToString());
|
||
item.Top = top;
|
||
}
|
||
},
|
||
() => {
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
item.Top = item.GetOldValue<double>(nameof(item.Top), guid.ToString());
|
||
}
|
||
},
|
||
() => {
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
item.ClearOldValue<double>(nameof(item.Top), guid.ToString());
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
private void ExecuteAlignVerticalCentersCommand(object parameter)
|
||
{
|
||
var selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>();
|
||
var guid = Guid.NewGuid();
|
||
|
||
if (selectedItems.Count() > 1)
|
||
{
|
||
DoCommandManager.DoNewCommand(this.ToString(),
|
||
() => {
|
||
double mid = selectedItems.Select(p => p.Top + p.ItemHeight / 2).Average();
|
||
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
item.SetOldValue(item.Top, nameof(item.Top), guid.ToString());
|
||
item.Top = mid - item.ItemHeight / 2;
|
||
}
|
||
},
|
||
() => {
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
item.Top = item.GetOldValue<double>(nameof(item.Top), guid.ToString());
|
||
}
|
||
},
|
||
() => {
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
item.ClearOldValue<double>(nameof(item.Top), guid.ToString());
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
private void ExecuteAlignBottomCommand(object parameter)
|
||
{
|
||
var selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>();
|
||
var guid = Guid.NewGuid();
|
||
|
||
if (selectedItems.Count() > 1)
|
||
{
|
||
DoCommandManager.DoNewCommand(this.ToString(),
|
||
() => {
|
||
double top = selectedItems.OrderBy(p => p.Top + p.ItemHeight).Select(p => p.Top + p.ItemHeight).LastOrDefault();
|
||
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
item.SetOldValue(item.Top, nameof(item.Top), guid.ToString());
|
||
item.Top = top - item.ItemHeight;
|
||
}
|
||
},
|
||
() => {
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
item.Top = item.GetOldValue<double>(nameof(item.Top), guid.ToString());
|
||
}
|
||
},
|
||
() => {
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
item.ClearOldValue<double>(nameof(item.Top), guid.ToString());
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
private void ExecuteAlignLeftCommand(object parameter)
|
||
{
|
||
var selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>();
|
||
var guid = Guid.NewGuid();
|
||
|
||
if (selectedItems.Count() > 1)
|
||
{
|
||
DoCommandManager.DoNewCommand(this.ToString(),
|
||
() => {
|
||
double left = selectedItems.OrderBy(p => p.Left).Select(p => p.Left).FirstOrDefault();
|
||
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
item.SetOldValue(item.Left, nameof(item.Left), guid.ToString());
|
||
item.Left = left;
|
||
}
|
||
},
|
||
() => {
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
item.Left = item.GetOldValue<double>(nameof(item.Left), guid.ToString());
|
||
}
|
||
},
|
||
() => {
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
item.ClearOldValue<double>(nameof(item.Left), guid.ToString());
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
private void ExecuteAlignHorizontalCentersCommand(object parameter)
|
||
{
|
||
var selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>();
|
||
var guid = Guid.NewGuid();
|
||
|
||
if (selectedItems.Count() > 1)
|
||
{
|
||
DoCommandManager.DoNewCommand(this.ToString(),
|
||
() => {
|
||
double mid = selectedItems.Select(p => p.Left + p.ItemWidth / 2).Average();
|
||
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
item.SetOldValue(item.Left, nameof(item.Left), guid.ToString());
|
||
item.Left = mid - item.ItemWidth / 2;
|
||
}
|
||
},
|
||
() => {
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
item.Left = item.GetOldValue<double>(nameof(item.Left), guid.ToString());
|
||
}
|
||
},
|
||
() => {
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
item.ClearOldValue<double>(nameof(item.Left), guid.ToString());
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
private void ExecuteAlignRightCommand(object parameter)
|
||
{
|
||
var selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>();
|
||
var guid = Guid.NewGuid();
|
||
|
||
if (selectedItems.Count() > 1)
|
||
{
|
||
DoCommandManager.DoNewCommand(this.ToString(),
|
||
() => {
|
||
double right = selectedItems.OrderBy(p => p.Left + p.ItemWidth).Select(p => p.Left + p.ItemWidth).LastOrDefault();
|
||
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
item.SetOldValue(item.Left, nameof(item.Left), guid.ToString());
|
||
item.Left = right - item.ItemWidth;
|
||
}
|
||
},
|
||
() => {
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
item.Left = item.GetOldValue<double>(nameof(item.Left), guid.ToString());
|
||
}
|
||
},
|
||
() => {
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
item.ClearOldValue<double>(nameof(item.Left), guid.ToString());
|
||
}
|
||
});
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
private void ExecuteBringForwardCommand(object parameter)
|
||
{
|
||
List<SelectableDesignerItemViewModelBase> ordered = SelectedItems.OrderByDescending(p => p.ZIndex).ToList();
|
||
|
||
List<SelectableDesignerItemViewModelBase> changeditems = new List<SelectableDesignerItemViewModelBase>();
|
||
var guid = Guid.NewGuid();
|
||
|
||
DoCommandManager.DoNewCommand(this.ToString(),
|
||
() => {
|
||
int count = this.Items.Count;
|
||
for (int i = 0; i < ordered.Count; i++)
|
||
{
|
||
var item = ordered[i];
|
||
int currentIndex = item.ZIndex;
|
||
int newIndex = Math.Min(count - 1 - i, currentIndex + 1);
|
||
if (currentIndex != newIndex)
|
||
{
|
||
item.SetOldValue<int>(item.ZIndex, nameof(item.ZIndex), guid.ToString());
|
||
item.ZIndex = newIndex;
|
||
changeditems.Add(item);
|
||
|
||
IEnumerable<SelectableDesignerItemViewModelBase> it = this.Items.Where(p => p.ZIndex == newIndex);
|
||
|
||
foreach (var elm in it)
|
||
{
|
||
if (elm != item)
|
||
{
|
||
elm.SetOldValue<int>(elm.ZIndex, nameof(elm.ZIndex), guid.ToString());
|
||
elm.ZIndex = currentIndex;
|
||
changeditems.Add(elm);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
},
|
||
() => {
|
||
foreach (var item in changeditems)
|
||
{
|
||
item.ZIndex = item.GetOldValue<int>(nameof(item.ZIndex), guid.ToString());
|
||
}
|
||
},
|
||
() => {
|
||
foreach (var item in changeditems)
|
||
{
|
||
item.ClearOldValue<double>(nameof(item.ZIndex), guid.ToString());
|
||
}
|
||
});
|
||
}
|
||
private void ExecuteBringToFrontCommand(object parameter)
|
||
{
|
||
List<SelectableDesignerItemViewModelBase> selectionSorted = SelectedItems.OrderByDescending(p => p.ZIndex).ToList();
|
||
List<SelectableDesignerItemViewModelBase> childrenSorted = Items.OrderByDescending(p => p.ZIndex).ToList();
|
||
|
||
List<SelectableDesignerItemViewModelBase> changeditems = new List<SelectableDesignerItemViewModelBase>();
|
||
var guid = Guid.NewGuid();
|
||
|
||
DoCommandManager.DoNewCommand(this.ToString(),
|
||
() => {
|
||
int i = childrenSorted.Count - 1;
|
||
int j = childrenSorted.Count - selectionSorted.Count - 1;
|
||
|
||
foreach (SelectableDesignerItemViewModelBase item in childrenSorted)
|
||
{
|
||
item.SetOldValue<int>(item.ZIndex, nameof(item.ZIndex), guid.ToString());
|
||
if (selectionSorted.Contains(item))
|
||
{
|
||
item.ZIndex = i--;
|
||
}
|
||
else
|
||
{
|
||
item.ZIndex = j--;
|
||
}
|
||
changeditems.Add(item);
|
||
}
|
||
},
|
||
() => {
|
||
foreach (var item in changeditems)
|
||
{
|
||
item.ZIndex = item.GetOldValue<int>(nameof(item.ZIndex), guid.ToString());
|
||
}
|
||
},
|
||
() => {
|
||
foreach (var item in changeditems)
|
||
{
|
||
item.ClearOldValue<double>(nameof(item.ZIndex), guid.ToString());
|
||
}
|
||
});
|
||
}
|
||
private void ExecuteSendBackwardCommand(object parameter)
|
||
{
|
||
List<SelectableDesignerItemViewModelBase> ordered = this.SelectedItems.OrderBy(p => p.ZIndex).ToList();
|
||
int count = this.Items.Count;
|
||
|
||
List<SelectableDesignerItemViewModelBase> changeditems = new List<SelectableDesignerItemViewModelBase>();
|
||
var guid = Guid.NewGuid();
|
||
|
||
DoCommandManager.DoNewCommand(this.ToString(),
|
||
() => {
|
||
for (int i = 0; i < ordered.Count; i++)
|
||
{
|
||
var item = ordered[i];
|
||
int currentIndex = item.ZIndex;
|
||
int newIndex = Math.Max(i, currentIndex - 1);
|
||
if (currentIndex != newIndex)
|
||
{
|
||
item.SetOldValue<int>(item.ZIndex, nameof(item.ZIndex), guid.ToString());
|
||
item.ZIndex = newIndex;
|
||
changeditems.Add(item);
|
||
IEnumerable<SelectableDesignerItemViewModelBase> it = this.Items.Where(p => p.ZIndex == newIndex);
|
||
|
||
foreach (var elm in it)
|
||
{
|
||
if (elm != ordered[i])
|
||
{
|
||
elm.SetOldValue<int>(elm.ZIndex, nameof(elm.ZIndex), guid.ToString());
|
||
elm.ZIndex = currentIndex;
|
||
changeditems.Add(elm);
|
||
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
},
|
||
() => {
|
||
foreach (var item in changeditems)
|
||
{
|
||
item.ZIndex = item.GetOldValue<int>(nameof(item.ZIndex), guid.ToString());
|
||
}
|
||
},
|
||
() => {
|
||
foreach (var item in changeditems)
|
||
{
|
||
item.ClearOldValue<double>(nameof(item.ZIndex), guid.ToString());
|
||
}
|
||
});
|
||
}
|
||
private void ExecuteSendToBackCommand(object parameter)
|
||
{
|
||
List<SelectableDesignerItemViewModelBase> selectionSorted = SelectedItems.OrderByDescending(p => p.ZIndex).ToList();
|
||
List<SelectableDesignerItemViewModelBase> childrenSorted = Items.OrderByDescending(p => p.ZIndex).ToList();
|
||
|
||
List<SelectableDesignerItemViewModelBase> changeditems = new List<SelectableDesignerItemViewModelBase>();
|
||
var guid = Guid.NewGuid();
|
||
|
||
DoCommandManager.DoNewCommand(this.ToString(),
|
||
() => {
|
||
int i = childrenSorted.Count - 1;
|
||
int j = selectionSorted.Count - 1;
|
||
|
||
foreach (SelectableDesignerItemViewModelBase item in childrenSorted)
|
||
{
|
||
item.SetOldValue<int>(item.ZIndex, nameof(item.ZIndex), guid.ToString());
|
||
if (selectionSorted.Contains(item))
|
||
{
|
||
item.ZIndex = j--;
|
||
}
|
||
else
|
||
{
|
||
item.ZIndex = i--;
|
||
}
|
||
changeditems.Add(item);
|
||
}
|
||
},
|
||
() => {
|
||
foreach (var item in changeditems)
|
||
{
|
||
item.ZIndex = item.GetOldValue<int>(nameof(item.ZIndex), guid.ToString());
|
||
}
|
||
},
|
||
() => {
|
||
foreach (var item in changeditems)
|
||
{
|
||
item.ClearOldValue<double>(nameof(item.ZIndex), guid.ToString());
|
||
}
|
||
});
|
||
}
|
||
private void ExecuteDistributeHorizontalCommand(object parameter)
|
||
{
|
||
var selectedItems = from item in this.SelectedItems.OfType<DesignerItemViewModelBase>()
|
||
where item.ParentId == Guid.Empty
|
||
orderby item.Left
|
||
select item;
|
||
var guid = Guid.NewGuid();
|
||
|
||
if (selectedItems.Count() > 1)
|
||
{
|
||
DoCommandManager.DoNewCommand(this.ToString(),
|
||
() => {
|
||
double left = Double.MaxValue;
|
||
double right = Double.MinValue;
|
||
double sumWidth = 0;
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
left = Math.Min(left, item.Left);
|
||
right = Math.Max(right, item.Left + item.ItemWidth);
|
||
sumWidth += item.ItemWidth;
|
||
}
|
||
|
||
double distance = Math.Max(0, (right - left - sumWidth) / (selectedItems.Count() - 1));
|
||
double offset = selectedItems.First().Left;
|
||
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
double delta = offset - item.Left;
|
||
foreach (DesignerItemViewModelBase di in SelectionService.GetGroupMembers(item))
|
||
{
|
||
di.SetOldValue(di.Left, nameof(di.Left), guid.ToString());
|
||
di.Left += delta;
|
||
}
|
||
offset = offset + item.ItemWidth + distance;
|
||
}
|
||
|
||
},
|
||
() => {
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
foreach (DesignerItemViewModelBase di in SelectionService.GetGroupMembers(item))
|
||
{
|
||
di.Left = di.GetOldValue<double>(nameof(di.Left), guid.ToString());
|
||
}
|
||
}
|
||
},
|
||
() => {
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
foreach (DesignerItemViewModelBase di in SelectionService.GetGroupMembers(item))
|
||
{
|
||
di.ClearOldValue<double>(nameof(di.Left), guid.ToString());
|
||
}
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
private void ExecuteDistributeVerticalCommand(object parameter)
|
||
{
|
||
var selectedItems = from item in this.SelectedItems.OfType<DesignerItemViewModelBase>()
|
||
where item.ParentId == Guid.Empty
|
||
orderby item.Top
|
||
select item;
|
||
var guid = Guid.NewGuid();
|
||
|
||
if (selectedItems.Count() > 1)
|
||
{
|
||
DoCommandManager.DoNewCommand(this.ToString(),
|
||
() => {
|
||
double top = Double.MaxValue;
|
||
double bottom = Double.MinValue;
|
||
double sumHeight = 0;
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
top = Math.Min(top, item.Top);
|
||
bottom = Math.Max(bottom, item.Top + item.ItemHeight);
|
||
sumHeight += item.ItemHeight;
|
||
}
|
||
|
||
double distance = Math.Max(0, (bottom - top - sumHeight) / (selectedItems.Count() - 1));
|
||
double offset = selectedItems.First().Top;
|
||
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
double delta = offset - item.Top;
|
||
foreach (DesignerItemViewModelBase di in SelectionService.GetGroupMembers(item))
|
||
{
|
||
di.SetOldValue(di.Top, nameof(di.Top), guid.ToString());
|
||
di.Top += +delta;
|
||
}
|
||
offset = offset + item.ItemHeight + distance;
|
||
}
|
||
},
|
||
() => {
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
foreach (DesignerItemViewModelBase di in SelectionService.GetGroupMembers(item))
|
||
{
|
||
di.Top = di.GetOldValue<double>(nameof(di.Top), guid.ToString());
|
||
}
|
||
}
|
||
},
|
||
() => {
|
||
foreach (DesignerItemViewModelBase item in selectedItems)
|
||
{
|
||
foreach (DesignerItemViewModelBase di in SelectionService.GetGroupMembers(item))
|
||
{
|
||
di.ClearOldValue<double>(nameof(di.Top), guid.ToString());
|
||
}
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
private void ExecuteSelectAllCommand(object parameter)
|
||
{
|
||
foreach (var item in Items)
|
||
{
|
||
item.IsSelected = true;
|
||
}
|
||
}
|
||
|
||
private void ExecuteCopyCommand(object parameter)
|
||
{
|
||
List<DesignerItemViewModelBase> selectedDesignerItems =
|
||
SelectedItems.OfType<DesignerItemViewModelBase>().ToList();
|
||
|
||
List<ConnectionViewModel> selectedConnections =
|
||
SelectedItems.OfType<ConnectionViewModel>().ToList();
|
||
|
||
foreach (ConnectionViewModel connection in Items.OfType<ConnectionViewModel>())
|
||
{
|
||
if (!selectedConnections.Contains(connection))
|
||
{
|
||
DesignerItemViewModelBase sourceItem = (from item in selectedDesignerItems
|
||
where item.Id == connection.SourceConnectorInfo.DataItem.Id
|
||
select item).FirstOrDefault();
|
||
|
||
DesignerItemViewModelBase sinkItem = (from item in selectedDesignerItems
|
||
where item.Id == connection.SinkConnectorInfoFully?.DataItem?.Id
|
||
select item).FirstOrDefault();
|
||
|
||
if (sourceItem != null &&
|
||
sinkItem != null &&
|
||
BelongToSameGroup(sourceItem, sinkItem))
|
||
{
|
||
selectedConnections.Add(connection);
|
||
}
|
||
}
|
||
}
|
||
|
||
string json = new SerializableObject
|
||
{
|
||
DesignerItems = selectedDesignerItems.Select(p => p.ToSerializabObject()).Where(p => p != null).ToList(),
|
||
Connections = selectedConnections.Select(p => p.ToSerializabObject()).Where(p => p != null).ToList(),
|
||
}.ToJson();
|
||
|
||
OffsetX = 10;
|
||
OffsetY = 10;
|
||
System.Windows.Clipboard.Clear();
|
||
System.Windows.Clipboard.SetData(System.Windows.DataFormats.Serializable, json);
|
||
}
|
||
|
||
private void ExecutePasteCommand(object parameter)
|
||
{
|
||
if (System.Windows.Clipboard.ContainsData(System.Windows.DataFormats.Serializable))
|
||
{
|
||
String clipboardData = System.Windows.Clipboard.GetData(System.Windows.DataFormats.Serializable) as String;
|
||
|
||
if (String.IsNullOrEmpty(clipboardData))
|
||
return;
|
||
try
|
||
{
|
||
List<SelectableDesignerItemViewModelBase> items = new List<SelectableDesignerItemViewModelBase>();
|
||
SerializableObject copyitem = JsonConvert.DeserializeObject<SerializableObject>(clipboardData);
|
||
|
||
|
||
Dictionary<Guid, Guid> mappingOldToNewIDs = new Dictionary<Guid, Guid>();
|
||
|
||
foreach (var diagramItemData in copyitem.DesignerItems)
|
||
{
|
||
DesignerItemViewModelBase newItem = null;
|
||
|
||
Type type = TypeHelper.GetType(diagramItemData.TypeName);
|
||
|
||
DesignerItemViewModelBase itemBase = (DesignerItemViewModelBase)Activator.CreateInstance(type, this, diagramItemData.ObjectJson);
|
||
Guid newID = Guid.NewGuid();
|
||
mappingOldToNewIDs.Add(itemBase.Id, newID);
|
||
itemBase.Id = newID;
|
||
itemBase.Left += OffsetX;
|
||
itemBase.Top += OffsetY;
|
||
|
||
newItem = itemBase;
|
||
|
||
if (newItem != null)
|
||
{
|
||
items.Add(newItem);
|
||
}
|
||
}
|
||
|
||
DirectAddItemCommand.Execute(items);
|
||
OffsetX += 10;
|
||
OffsetY += 10;
|
||
|
||
List<SelectableDesignerItemViewModelBase> connectors = new List<SelectableDesignerItemViewModelBase>();
|
||
foreach (var connection in copyitem.Connections)
|
||
{
|
||
var connectionItem = JsonConvert.DeserializeObject<ConnectionItem>(connection.ObjectJson);
|
||
Guid newID = Guid.NewGuid();
|
||
mappingOldToNewIDs.Add(connectionItem.Id, newID);
|
||
|
||
connectionItem.SourceId = mappingOldToNewIDs[connectionItem.SourceId];
|
||
connectionItem.SinkId = mappingOldToNewIDs[connectionItem.SinkId];
|
||
|
||
connectionItem.SourceType = System.Type.GetType(connectionItem.SourceTypeName);
|
||
connectionItem.SinkType = System.Type.GetType(connectionItem.SinkTypeName);
|
||
DesignerItemViewModelBase sourceItem = GetConnectorDataItem(this, connectionItem.SourceId, connectionItem.SourceType);
|
||
ConnectorOrientation sourceConnectorOrientation = connectionItem.SourceOrientation;
|
||
FullyCreatedConnectorInfo sourceConnectorInfo = GetFullConnectorInfo(connectionItem.Id, sourceItem, sourceConnectorOrientation, connectionItem.SourceXRatio, connectionItem.SourceYRatio, connectionItem.SourceInnerPoint);
|
||
|
||
DesignerItemViewModelBase sinkItem = GetConnectorDataItem(this, connectionItem.SinkId, connectionItem.SinkType);
|
||
ConnectorOrientation sinkConnectorOrientation = connectionItem.SinkOrientation;
|
||
FullyCreatedConnectorInfo sinkConnectorInfo = GetFullConnectorInfo(connectionItem.Id, sinkItem, sinkConnectorOrientation, connectionItem.SinkXRatio, connectionItem.SinkYRatio, connectionItem.SinkInnerPoint);
|
||
|
||
ConnectionViewModel connectionVM = new ConnectionViewModel(this, sourceConnectorInfo, sinkConnectorInfo, connectionItem);
|
||
connectors.Add(connectionVM);
|
||
}
|
||
|
||
DirectAddItemCommand.Execute(connectors);
|
||
|
||
//修复父级的引用
|
||
foreach (var item in items)
|
||
{
|
||
if (item.ParentId != Guid.Empty)
|
||
{
|
||
if (mappingOldToNewIDs.ContainsKey(item.ParentId))
|
||
item.ParentId = mappingOldToNewIDs[item.ParentId];
|
||
}
|
||
}
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
System.Windows.MessageBox.Show(e.StackTrace, e.Message, System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Error);
|
||
}
|
||
}
|
||
}
|
||
|
||
private DesignerItemViewModelBase GetConnectorDataItem(IDiagramViewModel diagramViewModel, Guid conectorDataItemId, Type connectorDataItemType)
|
||
{
|
||
DesignerItemViewModelBase dataItem = diagramViewModel.Items.OfType<DesignerItemViewModelBase>().Single(x => x.Id == conectorDataItemId);
|
||
return dataItem;
|
||
}
|
||
|
||
private FullyCreatedConnectorInfo GetFullConnectorInfo(Guid connectorId, DesignerItemViewModelBase dataItem, ConnectorOrientation connectorOrientation, double xRatio, double yRatio, bool isInnerPoint)
|
||
{
|
||
if (isInnerPoint)
|
||
{
|
||
return dataItem.Connectors.Where(p => p.XRatio == xRatio && p.YRatio == yRatio).FirstOrDefault();
|
||
}
|
||
else
|
||
{
|
||
switch (connectorOrientation)
|
||
{
|
||
case ConnectorOrientation.Top:
|
||
return dataItem.TopConnector;
|
||
case ConnectorOrientation.Left:
|
||
return dataItem.LeftConnector;
|
||
case ConnectorOrientation.Right:
|
||
return dataItem.RightConnector;
|
||
case ConnectorOrientation.Bottom:
|
||
return dataItem.BottomConnector;
|
||
|
||
default:
|
||
throw new InvalidOperationException(
|
||
string.Format("Found invalid persisted Connector Orientation for Connector Id: {0}", connectorId));
|
||
}
|
||
}
|
||
}
|
||
|
||
private bool ItemsToDeleteHasConnector(List<SelectableDesignerItemViewModelBase> itemsToRemove, ConnectorInfoBase connector)
|
||
{
|
||
if (connector is FullyCreatedConnectorInfo fully)
|
||
{
|
||
return itemsToRemove.Contains(fully.DataItem);
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
|
||
private void ExecuteCutCommand(object parameter)
|
||
{
|
||
ExecutePasteCommand(null);
|
||
OffsetX = 0;
|
||
OffsetY = 0;
|
||
ExecuteDeleteCommand(null);
|
||
}
|
||
|
||
private void ExecuteDeleteCommand(object parameter)
|
||
{
|
||
List<SelectableDesignerItemViewModelBase> itemsToRemove = SelectedItems.OfType<SelectableDesignerItemViewModelBase>().ToList();
|
||
List<SelectableDesignerItemViewModelBase> connectionsToAlsoRemove = new List<SelectableDesignerItemViewModelBase>();
|
||
|
||
foreach (var connector in Items.OfType<ConnectionViewModel>())
|
||
{
|
||
if (ItemsToDeleteHasConnector(itemsToRemove, connector.SourceConnectorInfo))
|
||
{
|
||
connectionsToAlsoRemove.Add(connector);
|
||
}
|
||
|
||
if (ItemsToDeleteHasConnector(itemsToRemove, connector.SinkConnectorInfo))
|
||
{
|
||
connectionsToAlsoRemove.Add(connector);
|
||
}
|
||
|
||
}
|
||
itemsToRemove.AddRange(connectionsToAlsoRemove);
|
||
|
||
RemoveItemCommand.Execute(itemsToRemove);
|
||
}
|
||
|
||
private void ExecuteLeftMoveCommand(object parameter)
|
||
{
|
||
foreach (var item in SelectedItems.OfType<DesignerItemViewModelBase>())
|
||
{
|
||
item.Left -= 0.5;
|
||
}
|
||
}
|
||
|
||
private void ExecuteRightMoveCommand(object parameter)
|
||
{
|
||
foreach (var item in SelectedItems.OfType<DesignerItemViewModelBase>())
|
||
{
|
||
item.Left += 0.5;
|
||
}
|
||
}
|
||
|
||
private void ExecuteUpMoveCommand(object parameter)
|
||
{
|
||
foreach (var item in SelectedItems.OfType<DesignerItemViewModelBase>())
|
||
{
|
||
item.Top -= 0.5;
|
||
}
|
||
}
|
||
|
||
private void ExecuteDownMoveCommand(object parameter)
|
||
{
|
||
foreach (var item in SelectedItems.OfType<DesignerItemViewModelBase>())
|
||
{
|
||
item.Top += 0.5;
|
||
}
|
||
}
|
||
|
||
private void ExecuteCenterMoveCommand(object parameter)
|
||
{
|
||
foreach (var item in SelectedItems.OfType<DesignerItemViewModelBase>())
|
||
{
|
||
item.Left = (PageSize.Width - item.ItemWidth) / 2;
|
||
item.Top = (PageSize.Height - item.ItemHeight) / 2;
|
||
}
|
||
}
|
||
|
||
private void ExecuteSameSizeCommand(object parameter)
|
||
{
|
||
if (parameter is DesignerItemViewModelBase designerItem)
|
||
{
|
||
foreach (var item in SelectedItems.OfType<DesignerItemViewModelBase>())
|
||
{
|
||
item.ItemWidth = designerItem.ItemWidth;
|
||
item.ItemHeight = designerItem.ItemHeight;
|
||
}
|
||
}
|
||
}
|
||
|
||
private void ExecuteSameWidthCommand(object parameter)
|
||
{
|
||
if (parameter is DesignerItemViewModelBase designerItem)
|
||
{
|
||
foreach (var item in SelectedItems.OfType<DesignerItemViewModelBase>())
|
||
{
|
||
item.ItemWidth = designerItem.ItemWidth;
|
||
}
|
||
}
|
||
}
|
||
|
||
private void ExecuteSameHeightCommand(object parameter)
|
||
{
|
||
if (parameter is DesignerItemViewModelBase designerItem)
|
||
{
|
||
foreach (var item in SelectedItems.OfType<DesignerItemViewModelBase>())
|
||
{
|
||
item.ItemHeight = designerItem.ItemHeight;
|
||
}
|
||
}
|
||
}
|
||
|
||
private void ExecuteSameAngleCommand(object parameter)
|
||
{
|
||
if (parameter is DesignerItemViewModelBase designerItem)
|
||
{
|
||
foreach (var item in SelectedItems.OfType<DesignerItemViewModelBase>())
|
||
{
|
||
item.Angle = designerItem.Angle;
|
||
}
|
||
}
|
||
}
|
||
|
||
private void ExecuteGroupCommand(object parameter)
|
||
{
|
||
var items = from item in SelectedItems.OfType<DesignerItemViewModelBase>()
|
||
where item.ParentId == Guid.Empty
|
||
select item;
|
||
|
||
RectangleBase rect = GetBoundingRectangle(items);
|
||
|
||
GroupDesignerItemViewModel groupItem = new GroupDesignerItemViewModel();
|
||
groupItem.IsGroup = true;
|
||
groupItem.ItemWidth = rect.Width;
|
||
groupItem.ItemHeight = rect.Height;
|
||
groupItem.Left = rect.Left;
|
||
groupItem.Top = rect.Top;
|
||
groupItem.ZIndex = Items.Count;
|
||
|
||
DirectAddItemCommand.Execute(groupItem);
|
||
|
||
foreach (DesignerItemViewModelBase item in items)
|
||
item.ParentId = groupItem.Id;
|
||
|
||
ClearSelectedItemsCommand.Execute(null);
|
||
//groupItem.IsSelected = true;
|
||
SelectionService.AddToSelection(groupItem);
|
||
}
|
||
|
||
private void ExecuteUngroupCommand(object parameter)
|
||
{
|
||
var groups = (from item in SelectedItems.OfType<DesignerItemViewModelBase>()
|
||
where item.IsGroup && item.ParentId == Guid.Empty
|
||
select item).ToArray();
|
||
|
||
foreach (DesignerItemViewModelBase groupRoot in groups)
|
||
{
|
||
var children = from child in SelectedItems.OfType<DesignerItemViewModelBase>()
|
||
where child.ParentId == groupRoot.Id
|
||
select child;
|
||
|
||
foreach (DesignerItemViewModelBase child in children)
|
||
child.ParentId = Guid.Empty;
|
||
|
||
RemoveItemCommand.Execute(groupRoot);
|
||
UpdateZIndex();
|
||
}
|
||
}
|
||
|
||
private void ExecuteLockCommand(object parameter)
|
||
{
|
||
|
||
}
|
||
|
||
private void ExecuteUnlockCommand(object parameter)
|
||
{
|
||
|
||
}
|
||
|
||
public bool BelongToSameGroup(IGroupable item1, IGroupable item2)
|
||
{
|
||
IGroupable root1 = SelectionService.GetGroupRoot(item1);
|
||
IGroupable root2 = SelectionService.GetGroupRoot(item2);
|
||
|
||
return (root1.Id == root2.Id);
|
||
}
|
||
|
||
public void UpdateZIndex()
|
||
{
|
||
List<SelectableDesignerItemViewModelBase> ordered = Items.OrderBy(p => p.ZIndex).ToList();
|
||
|
||
|
||
for (int i = 0; i < ordered.Count; i++)
|
||
{
|
||
ordered[i].ZIndex = i;
|
||
}
|
||
}
|
||
|
||
public RectangleBase GetBoundingRectangle(IEnumerable<DesignerItemViewModelBase> items)
|
||
{
|
||
double x1 = Double.MaxValue;
|
||
double y1 = Double.MaxValue;
|
||
double x2 = Double.MinValue;
|
||
double y2 = Double.MinValue;
|
||
|
||
foreach (DesignerItemViewModelBase item in items)
|
||
{
|
||
x1 = Math.Min(item.Left, x1);
|
||
y1 = Math.Min(item.Top, y1);
|
||
|
||
x2 = Math.Max(item.Left + item.ItemWidth, x2);
|
||
y2 = Math.Max(item.Top + item.ItemHeight, y2);
|
||
}
|
||
|
||
return new RectangleBase(new PointBase(x1, y1), new PointBase(x2, y2));
|
||
}
|
||
|
||
#region 用于wpf大小与物理像素之间转换
|
||
public void SetScreenScale()
|
||
{
|
||
ScreenScale = ScreenHelper.ResetScreenScale();
|
||
}
|
||
#endregion
|
||
}
|
||
|
||
|
||
|
||
|
||
}
|
