zhusenlin/aistudio-wpf-diagram
1
0
Fork 0
mirror of https://gitee.com/akwkevin/aistudio.-wpf.-diagram synced 2026-03-03 00:00:57 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
6d1960a8dfffd95fada8810f9451ea50865f4303
aistudio-wpf-diagram/AIStudio.Wpf.DiagramDesigner/ViewModels/BaseViewModel/DiagramViewModel.cs

1807 lines
63 KiB
C#
Raw Normal View History

添加项目文件。
2021-07-23 09:42:22 +08:00
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;
修改暂存一下
2023-01-12 23:02:53 +08:00
using AIStudio.Wpf.DiagramDesigner.Geometrys;
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
using AIStudio.Wpf.DiagramDesigner.Helpers;
using AIStudio.Wpf.DiagramDesigner.Models;
using Newtonsoft.Json;
添加项目文件。
2021-07-23 09:42:22 +08:00
整理一下项目文件
2022-10-28 22:45:39 +08:00
namespace AIStudio.Wpf.DiagramDesigner
添加项目文件。
2021-07-23 09:42:22 +08:00
{
public class DiagramViewModel : BindableBase, IDiagramViewModel
{
#region 属性
序列化调整中
2023-01-24 23:10:57 +08:00
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;
}
}
Flowchart
2022-12-04 23:07:20 +08:00
private bool _isReadOnly;
public bool IsReadOnly
{
get
{
return _isReadOnly;
}
set
{
SetProperty(ref _isReadOnly, value);
}
}
继续调整
2022-12-05 22:48:00 +08:00
public bool IsLoading
{
get; set;
}
线条文本可以保存了
2022-12-06 21:28:42 +08:00
public IDrawModeViewModel DrawModeViewModel
{
get; set;
}
public IColorViewModel ColorViewModel
Flowchart
2022-12-04 23:07:20 +08:00
{
get; set;
}
箭头分离到独立的model中，方便自定义path
2023-01-26 18:27:17 +08:00
public IFontViewModel FontViewModel
{
get; set;
}
public IShapeViewModel ShapeViewModel
{
get; set;
}
添加项目文件。
2021-07-23 09:42:22 +08:00
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);
}
}
连接线改成path绘制，方便绘制曲线
2021-08-06 18:12:05 +08:00
private Size _gridCellSize = new Size(100, 100);
添加项目文件。
2021-07-23 09:42:22 +08:00
public Size GridCellSize
{
get
{
return _gridCellSize;
}
set
{
SetProperty(ref _gridCellSize, value);
}
}
连接线改成path绘制，方便绘制曲线
2021-08-06 18:12:05 +08:00
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));
}
}
添加项目文件。
2021-07-23 09:42:22 +08:00
private Color _pageBackground = Colors.White;
public Color PageBackground
{
get
{
return _pageBackground;
}
set
{
SetProperty(ref _pageBackground, value);
}
}
序列化继续改进
2023-01-25 11:11:27 +08:00
private bool _showGrid = true;
添加项目文件。
2021-07-23 09:42:22 +08:00
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);
}
}
页边距修改
2023-01-24 20:51:39 +08:00
private Size _gridMargin = new Size(28, 28);
public Size GridMarginSize
添加项目文件。
2021-07-23 09:42:22 +08:00
{
get
{
return _gridMargin;
}
set
{
SetProperty(ref _gridMargin, value);
}
}
页边距修改
2023-01-24 20:51:39 +08:00
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));
}
}
添加项目文件。
2021-07-23 09:42:22 +08:00
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);
}
大部分完成，还有写要解决的问题
2023-01-26 22:25:48 +08:00
}
添加项目文件。
2021-07-23 09:42:22 +08:00
private bool _isEditName;
[Browsable(false)]
public bool IsEditName
{
get
{
return _isEditName;
}
set
{
SetProperty(ref _isEditName, value);
}
}
使用PointBase代替Point
2023-01-08 09:22:37 +08:00
private System.Windows.Point _currentPoint;
添加项目文件。
2021-07-23 09:42:22 +08:00
[Browsable(false)]
使用PointBase代替Point
2023-01-08 09:22:37 +08:00
public System.Windows.Point CurrentPoint
添加项目文件。
2021-07-23 09:42:22 +08:00
{
get
{
return _currentPoint;
}
set
{
SetProperty(ref _currentPoint, value);
}
}
private Color _currentColor;
[Browsable(false)]
public Color CurrentColor
{
get
{
return _currentColor;
}
set
{
SetProperty(ref _currentColor, value);
}
}
Flowchart
2022-12-04 23:07:20 +08:00
/// <summary>
/// 用于wpf大小与物理像素之间转换
/// </summary>
public double ScreenScale { get; set; } = 1;
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
private double OffsetX = 10;
private double OffsetY = 10;
添加项目文件。
2021-07-23 09:42:22 +08:00
#endregion
序列化调整中
2023-01-24 23:10:57 +08:00
#region 命令
Flowchart
2022-12-04 23:07:20 +08:00
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;
}
添加项目文件。
2021-07-23 09:42:22 +08:00
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
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;
}
添加项目文件。
2021-07-23 09:42:22 +08:00
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));
}
}
序列化调整中
2023-01-24 23:10:57 +08:00
#endregion
添加项目文件。
2021-07-23 09:42:22 +08:00
序列化调整中
2023-01-24 23:10:57 +08:00
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);
添加项目文件。
2021-07-23 09:42:22 +08:00
序列化调整中
2023-01-24 23:10:57 +08:00
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);
添加项目文件。
2021-07-23 09:42:22 +08:00
序列化调整中
2023-01-24 23:10:57 +08:00
Items.CollectionChanged += Items_CollectionChanged;
}
public bool ExecuteEnable(object para)
添加项目文件。
2021-07-23 09:42:22 +08:00
{
序列化调整中
2023-01-24 23:10:57 +08:00
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)
Flowchart
2022-12-04 23:07:20 +08:00
{
序列化调整中
2023-01-24 23:10:57 +08:00
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;
}
Flowchart
2022-12-04 23:07:20 +08:00
}
添加项目文件。
2021-07-23 09:42:22 +08:00
序列化调整中
2023-01-24 23:10:57 +08:00
RaisePropertyChanged("Items");
}
添加项目文件。
2021-07-23 09:42:22 +08:00
序列化调整中
2023-01-24 23:10:57 +08:00
private void Item_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
添加项目文件。
2021-07-23 09:42:22 +08:00
{
序列化调整中
2023-01-24 23:10:57 +08:00
RaisePropertyChanged(sender, e.PropertyName);
if (_undoing == true) return;
//连续改变，需要特殊处理，不单独触发属性改变ReDo
if (sender is DesignerItemViewModelBase designer)
添加项目文件。
2021-07-23 09:42:22 +08:00
{
序列化调整中
2023-01-24 23:10:57 +08:00
if (designer.BeginDo) return;
}
添加项目文件。
2021-07-23 09:42:22 +08:00
序列化调整中
2023-01-24 23:10:57 +08:00
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;
添加项目文件。
2021-07-23 09:42:22 +08:00
}
}
把底层再分割一下
2023-01-24 09:02:40 +08:00
public Func<SelectableDesignerItemViewModelBase, bool> OutAddVerify
Flowchart
2022-12-04 23:07:20 +08:00
{
get; set;
}
把底层再分割一下
2023-01-24 09:02:40 +08:00
public bool AddVerify(SelectableDesignerItemViewModelBase item)
添加项目文件。
2021-07-23 09:42:22 +08:00
{
if (item.InitData() == false)
return false;
if (OutAddVerify != null && OutAddVerify(item) != true)
return false;
return true;
}
序列化调整中
2023-01-24 23:10:57 +08:00
#region 新增,删除
添加项目文件。
2021-07-23 09:42:22 +08:00
private void ExecuteCreateNewDiagramCommand(object parameter)
{
this.Items.Clear();
}
private void ExecuteDirectAddItemCommand(object parameter)
{
把底层再分割一下
2023-01-24 09:02:40 +08:00
if (parameter is SelectableDesignerItemViewModelBase ite)
添加项目文件。
2021-07-23 09:42:22 +08:00
{
if (AddVerify(ite) != true) return;
ClearSelectedItems();
Add(ite);
}
大部分完成，还有写要解决的问题
2023-01-26 22:25:48 +08:00
else if (parameter is IEnumerable<SelectableDesignerItemViewModelBase> items)
添加项目文件。
2021-07-23 09:42:22 +08:00
{
if (items.Select(p => AddVerify(p)).Any() != true) return;
ClearSelectedItems();
foreach (var item in items)
{
Add(item);
}
}
}
把底层再分割一下
2023-01-24 09:02:40 +08:00
private void Add(SelectableDesignerItemViewModelBase item)
添加项目文件。
2021-07-23 09:42:22 +08:00
{
整理序列化
2023-01-24 16:20:39 +08:00
item.Root = this;
添加项目文件。
2021-07-23 09:42:22 +08:00
item.ZIndex = Items.Count;
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
if (item.Id == Guid.Empty)
{
item.Id = Guid.NewGuid();
}
添加项目文件。
2021-07-23 09:42:22 +08:00
//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)
{
把底层再分割一下
2023-01-24 09:02:40 +08:00
if (parameter is SelectableDesignerItemViewModelBase ite)
添加项目文件。
2021-07-23 09:42:22 +08:00
{
if (AddVerify(ite) != true) return;
DoCommandManager.DoNewCommand(this.ToString(),
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
ClearSelectedItems();
Add(ite);
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
Items.Remove(ite);
});
}
把底层再分割一下
2023-01-24 09:02:40 +08:00
else if (parameter is List<SelectableDesignerItemViewModelBase> items)
添加项目文件。
2021-07-23 09:42:22 +08:00
{
if (items.Select(p => AddVerify(p)).Any() != true) return;
DoCommandManager.DoNewCommand(this.ToString(),
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
ClearSelectedItems();
foreach (var item in items)
{
Add(item);
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
items.ForEach(item => Items.Remove(item));
});
}
}
private void ExecuteDirectRemoveItemCommand(object parameter)
{
把底层再分割一下
2023-01-24 09:02:40 +08:00
if (parameter is SelectableDesignerItemViewModelBase ite)
添加项目文件。
2021-07-23 09:42:22 +08:00
{
ite.IsSelected = false;
Items.Remove(ite);
}
把底层再分割一下
2023-01-24 09:02:40 +08:00
else if (parameter is List<SelectableDesignerItemViewModelBase> items)
添加项目文件。
2021-07-23 09:42:22 +08:00
{
foreach (var item in items)
{
item.IsSelected = false;
Items.Remove(item);
}
}
}
private void ExecuteRemoveItemCommand(object parameter)
{
把底层再分割一下
2023-01-24 09:02:40 +08:00
if (parameter is SelectableDesignerItemViewModelBase ite)
添加项目文件。
2021-07-23 09:42:22 +08:00
{
DoCommandManager.DoNewCommand(this.ToString(),
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
ite.IsSelected = false;
Items.Remove(ite);
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
Items.Add(ite);
});
}
把底层再分割一下
2023-01-24 09:02:40 +08:00
else if (parameter is List<SelectableDesignerItemViewModelBase> items)
添加项目文件。
2021-07-23 09:42:22 +08:00
{
DoCommandManager.DoNewCommand(this.ToString(),
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (var item in items)
{
item.IsSelected = false;
Items.Remove(item);
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
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;
}
}
序列化调整中
2023-01-24 23:10:57 +08:00
private void ExecuteSelectAllCommand(object parameter)
{
foreach (var item in Items)
{
item.IsSelected = true;
}
}
#endregion
添加项目文件。
2021-07-23 09:42:22 +08:00
#region 布局
private void ExecuteAlignTopCommand(object parameter)
{
var selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>();
var guid = Guid.NewGuid();
if (selectedItems.Count() > 1)
{
DoCommandManager.DoNewCommand(this.ToString(),
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
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;
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (DesignerItemViewModelBase item in selectedItems)
{
item.Top = item.GetOldValue<double>(nameof(item.Top), guid.ToString());
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
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(),
Flowchart
2022-12-04 23:07:20 +08:00
() => {
sfc界面处理完成，还差顺序逻辑控制过程
2021-08-01 22:30:12 +08:00
double mid = selectedItems.Select(p => p.Top + p.ItemHeight / 2).Average();
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (DesignerItemViewModelBase item in selectedItems)
{
item.SetOldValue(item.Top, nameof(item.Top), guid.ToString());
sfc界面处理完成，还差顺序逻辑控制过程
2021-08-01 22:30:12 +08:00
item.Top = mid - item.ItemHeight / 2;
添加项目文件。
2021-07-23 09:42:22 +08:00
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (DesignerItemViewModelBase item in selectedItems)
{
item.Top = item.GetOldValue<double>(nameof(item.Top), guid.ToString());
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
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(),
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
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;
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (DesignerItemViewModelBase item in selectedItems)
{
item.Top = item.GetOldValue<double>(nameof(item.Top), guid.ToString());
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
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(),
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
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;
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (DesignerItemViewModelBase item in selectedItems)
{
item.Left = item.GetOldValue<double>(nameof(item.Left), guid.ToString());
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
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(),
Flowchart
2022-12-04 23:07:20 +08:00
() => {
sfc界面处理完成，还差顺序逻辑控制过程
2021-08-01 22:30:12 +08:00
double mid = selectedItems.Select(p => p.Left + p.ItemWidth / 2).Average();
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (DesignerItemViewModelBase item in selectedItems)
{
item.SetOldValue(item.Left, nameof(item.Left), guid.ToString());
sfc界面处理完成，还差顺序逻辑控制过程
2021-08-01 22:30:12 +08:00
item.Left = mid - item.ItemWidth / 2;
添加项目文件。
2021-07-23 09:42:22 +08:00
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (DesignerItemViewModelBase item in selectedItems)
{
item.Left = item.GetOldValue<double>(nameof(item.Left), guid.ToString());
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
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(),
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
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;
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (DesignerItemViewModelBase item in selectedItems)
{
item.Left = item.GetOldValue<double>(nameof(item.Left), guid.ToString());
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (DesignerItemViewModelBase item in selectedItems)
{
item.ClearOldValue<double>(nameof(item.Left), guid.ToString());
}
});
}
}
EnableSnapping完成
2023-01-26 20:05:21 +08:00
添加项目文件。
2021-07-23 09:42:22 +08:00
private void ExecuteBringForwardCommand(object parameter)
{
把底层再分割一下
2023-01-24 09:02:40 +08:00
List<SelectableDesignerItemViewModelBase> ordered = SelectedItems.OrderByDescending(p => p.ZIndex).ToList();
添加项目文件。
2021-07-23 09:42:22 +08:00
把底层再分割一下
2023-01-24 09:02:40 +08:00
List<SelectableDesignerItemViewModelBase> changeditems = new List<SelectableDesignerItemViewModelBase>();
添加项目文件。
2021-07-23 09:42:22 +08:00
var guid = Guid.NewGuid();
DoCommandManager.DoNewCommand(this.ToString(),
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
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);
把底层再分割一下
2023-01-24 09:02:40 +08:00
IEnumerable<SelectableDesignerItemViewModelBase> it = this.Items.Where(p => p.ZIndex == newIndex);
添加项目文件。
2021-07-23 09:42:22 +08:00
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;
}
}
}
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (var item in changeditems)
{
item.ZIndex = item.GetOldValue<int>(nameof(item.ZIndex), guid.ToString());
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (var item in changeditems)
{
item.ClearOldValue<double>(nameof(item.ZIndex), guid.ToString());
}
});
}
private void ExecuteBringToFrontCommand(object parameter)
{
把底层再分割一下
2023-01-24 09:02:40 +08:00
List<SelectableDesignerItemViewModelBase> selectionSorted = SelectedItems.OrderByDescending(p => p.ZIndex).ToList();
List<SelectableDesignerItemViewModelBase> childrenSorted = Items.OrderByDescending(p => p.ZIndex).ToList();
添加项目文件。
2021-07-23 09:42:22 +08:00
把底层再分割一下
2023-01-24 09:02:40 +08:00
List<SelectableDesignerItemViewModelBase> changeditems = new List<SelectableDesignerItemViewModelBase>();
添加项目文件。
2021-07-23 09:42:22 +08:00
var guid = Guid.NewGuid();
DoCommandManager.DoNewCommand(this.ToString(),
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
int i = childrenSorted.Count - 1;
int j = childrenSorted.Count - selectionSorted.Count - 1;
把底层再分割一下
2023-01-24 09:02:40 +08:00
foreach (SelectableDesignerItemViewModelBase item in childrenSorted)
添加项目文件。
2021-07-23 09:42:22 +08:00
{
item.SetOldValue<int>(item.ZIndex, nameof(item.ZIndex), guid.ToString());
if (selectionSorted.Contains(item))
{
item.ZIndex = i--;
}
else
{
item.ZIndex = j--;
}
changeditems.Add(item);
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (var item in changeditems)
{
item.ZIndex = item.GetOldValue<int>(nameof(item.ZIndex), guid.ToString());
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (var item in changeditems)
{
item.ClearOldValue<double>(nameof(item.ZIndex), guid.ToString());
}
});
}
private void ExecuteSendBackwardCommand(object parameter)
{
把底层再分割一下
2023-01-24 09:02:40 +08:00
List<SelectableDesignerItemViewModelBase> ordered = this.SelectedItems.OrderBy(p => p.ZIndex).ToList();
添加项目文件。
2021-07-23 09:42:22 +08:00
int count = this.Items.Count;
把底层再分割一下
2023-01-24 09:02:40 +08:00
List<SelectableDesignerItemViewModelBase> changeditems = new List<SelectableDesignerItemViewModelBase>();
添加项目文件。
2021-07-23 09:42:22 +08:00
var guid = Guid.NewGuid();
DoCommandManager.DoNewCommand(this.ToString(),
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
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);
把底层再分割一下
2023-01-24 09:02:40 +08:00
IEnumerable<SelectableDesignerItemViewModelBase> it = this.Items.Where(p => p.ZIndex == newIndex);
添加项目文件。
2021-07-23 09:42:22 +08:00
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;
}
}
}
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (var item in changeditems)
{
item.ZIndex = item.GetOldValue<int>(nameof(item.ZIndex), guid.ToString());
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (var item in changeditems)
{
item.ClearOldValue<double>(nameof(item.ZIndex), guid.ToString());
}
});
}
private void ExecuteSendToBackCommand(object parameter)
{
把底层再分割一下
2023-01-24 09:02:40 +08:00
List<SelectableDesignerItemViewModelBase> selectionSorted = SelectedItems.OrderByDescending(p => p.ZIndex).ToList();
List<SelectableDesignerItemViewModelBase> childrenSorted = Items.OrderByDescending(p => p.ZIndex).ToList();
添加项目文件。
2021-07-23 09:42:22 +08:00
把底层再分割一下
2023-01-24 09:02:40 +08:00
List<SelectableDesignerItemViewModelBase> changeditems = new List<SelectableDesignerItemViewModelBase>();
添加项目文件。
2021-07-23 09:42:22 +08:00
var guid = Guid.NewGuid();
DoCommandManager.DoNewCommand(this.ToString(),
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
int i = childrenSorted.Count - 1;
int j = selectionSorted.Count - 1;
把底层再分割一下
2023-01-24 09:02:40 +08:00
foreach (SelectableDesignerItemViewModelBase item in childrenSorted)
添加项目文件。
2021-07-23 09:42:22 +08:00
{
item.SetOldValue<int>(item.ZIndex, nameof(item.ZIndex), guid.ToString());
if (selectionSorted.Contains(item))
{
item.ZIndex = j--;
}
else
{
item.ZIndex = i--;
}
changeditems.Add(item);
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (var item in changeditems)
{
item.ZIndex = item.GetOldValue<int>(nameof(item.ZIndex), guid.ToString());
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
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(),
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
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;
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (DesignerItemViewModelBase item in selectedItems)
{
foreach (DesignerItemViewModelBase di in SelectionService.GetGroupMembers(item))
{
di.Left = di.GetOldValue<double>(nameof(di.Left), guid.ToString());
}
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
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(),
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
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;
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (DesignerItemViewModelBase item in selectedItems)
{
foreach (DesignerItemViewModelBase di in SelectionService.GetGroupMembers(item))
{
di.Top = di.GetOldValue<double>(nameof(di.Top), guid.ToString());
}
}
},
Flowchart
2022-12-04 23:07:20 +08:00
() => {
添加项目文件。
2021-07-23 09:42:22 +08:00
foreach (DesignerItemViewModelBase item in selectedItems)
{
foreach (DesignerItemViewModelBase di in SelectionService.GetGroupMembers(item))
{
di.ClearOldValue<double>(nameof(di.Top), guid.ToString());
}
}
});
}
}
序列化调整中
2023-01-24 23:10:57 +08:00
#endregion
添加项目文件。
2021-07-23 09:42:22 +08:00
序列化调整中
2023-01-24 23:10:57 +08:00
#region 复制，粘贴
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
private void ExecuteCopyCommand(object parameter)
{
List<DesignerItemViewModelBase> selectedDesignerItems =
SelectedItems.OfType<DesignerItemViewModelBase>().ToList();
序列化继续整理
2023-01-24 17:53:04 +08:00
List<ConnectionViewModel> selectedConnections =
EnableSnapping完成
2023-01-26 20:05:21 +08:00
SelectedItems.OfType<ConnectionViewModel>().ToList();
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
序列化继续整理
2023-01-24 17:53:04 +08:00
foreach (ConnectionViewModel connection in Items.OfType<ConnectionViewModel>())
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
{
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
使用PointBase代替Point
2023-01-08 09:22:37 +08:00
where item.Id == connection.SinkConnectorInfoFully?.DataItem?.Id
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
select item).FirstOrDefault();
if (sourceItem != null &&
sinkItem != null &&
BelongToSameGroup(sourceItem, sinkItem))
{
selectedConnections.Add(connection);
}
}
}
string json = new SerializableObject
{
序列化继续改进
2023-01-25 11:11:27 +08:00
DesignerItems = selectedDesignerItems.Select(p => p.ToSerializableItem(".json")).Where(p => p != null).ToList(),
Connections = selectedConnections.Select(p => p.ToSerializableItem(".json")).Where(p => p != null).ToList(),
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
}.ToJson();
OffsetX = 10;
OffsetY = 10;
使用PointBase代替Point
2023-01-08 09:22:37 +08:00
System.Windows.Clipboard.Clear();
System.Windows.Clipboard.SetData(System.Windows.DataFormats.Serializable, json);
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
}
private void ExecutePasteCommand(object parameter)
{
使用PointBase代替Point
2023-01-08 09:22:37 +08:00
if (System.Windows.Clipboard.ContainsData(System.Windows.DataFormats.Serializable))
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
{
序列化继续改进
2023-01-25 11:11:27 +08:00
string clipboardData = System.Windows.Clipboard.GetData(System.Windows.DataFormats.Serializable) as String;
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
序列化继续改进
2023-01-25 11:11:27 +08:00
if (string.IsNullOrEmpty(clipboardData))
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
return;
try
{
把底层再分割一下
2023-01-24 09:02:40 +08:00
List<SelectableDesignerItemViewModelBase> items = new List<SelectableDesignerItemViewModelBase>();
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
SerializableObject copyitem = JsonConvert.DeserializeObject<SerializableObject>(clipboardData);
Dictionary<Guid, Guid> mappingOldToNewIDs = new Dictionary<Guid, Guid>();
foreach (var diagramItemData in copyitem.DesignerItems)
{
DesignerItemViewModelBase newItem = null;
EnableSnapping完成
2023-01-26 20:05:21 +08:00
序列化继续改进
2023-01-25 11:11:27 +08:00
Type type = TypeHelper.GetType(diagramItemData.ModelTypeName);
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
序列化继续改进
2023-01-25 11:11:27 +08:00
DesignerItemViewModelBase itemBase = Activator.CreateInstance(type, this, diagramItemData, ".json") as DesignerItemViewModelBase;
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
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);
}
EnableSnapping完成
2023-01-26 20:05:21 +08:00
}
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
DirectAddItemCommand.Execute(items);
OffsetX += 10;
OffsetY += 10;
把底层再分割一下
2023-01-24 09:02:40 +08:00
List<SelectableDesignerItemViewModelBase> connectors = new List<SelectableDesignerItemViewModelBase>();
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
foreach (var connection in copyitem.Connections)
{
序列化调整中
2023-01-24 23:10:57 +08:00
var connectionItem = JsonConvert.DeserializeObject<ConnectionItem>(connection.SerializableString);
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
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;
Portless序列化
2023-01-27 20:43:41 +08:00
FullyCreatedConnectorInfo sourceConnectorInfo = GetFullConnectorInfo(connectionItem.Id, sourceItem, sourceConnectorOrientation, connectionItem.SourceXRatio, connectionItem.SourceYRatio, connectionItem.SourceInnerPoint, connectionItem.SourceIsPortless);
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
DesignerItemViewModelBase sinkItem = GetConnectorDataItem(this, connectionItem.SinkId, connectionItem.SinkType);
ConnectorOrientation sinkConnectorOrientation = connectionItem.SinkOrientation;
Portless序列化
2023-01-27 20:43:41 +08:00
FullyCreatedConnectorInfo sinkConnectorInfo = GetFullConnectorInfo(connectionItem.Id, sinkItem, sinkConnectorOrientation, connectionItem.SinkXRatio, connectionItem.SinkYRatio, connectionItem.SinkInnerPoint, connectionItem.SinkIsPortless);
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
序列化继续整理
2023-01-24 17:53:04 +08:00
ConnectionViewModel connectionVM = new ConnectionViewModel(this, sourceConnectorInfo, sinkConnectorInfo, connectionItem);
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
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)
{
使用PointBase代替Point
2023-01-08 09:22:37 +08:00
System.Windows.MessageBox.Show(e.StackTrace, e.Message, System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Error);
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
}
}
}
private DesignerItemViewModelBase GetConnectorDataItem(IDiagramViewModel diagramViewModel, Guid conectorDataItemId, Type connectorDataItemType)
{
DesignerItemViewModelBase dataItem = diagramViewModel.Items.OfType<DesignerItemViewModelBase>().Single(x => x.Id == conectorDataItemId);
return dataItem;
}
Portless序列化
2023-01-27 20:43:41 +08:00
private FullyCreatedConnectorInfo GetFullConnectorInfo(Guid connectorId, DesignerItemViewModelBase dataItem, ConnectorOrientation connectorOrientation, double xRatio, double yRatio, bool isInnerPoint, bool isPortless)
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
{
if (isInnerPoint)
{
return dataItem.Connectors.Where(p => p.XRatio == xRatio && p.YRatio == yRatio).FirstOrDefault();
}
Portless序列化
2023-01-27 20:43:41 +08:00
else if (isPortless)
{
return dataItem.PortlessConnector;
}
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
else
{
switch (connectorOrientation)
{
case ConnectorOrientation.Left:
return dataItem.LeftConnector;
Portless序列化
2023-01-27 20:43:41 +08:00
case ConnectorOrientation.TopLeft:
return dataItem.TopLeftConnector;
case ConnectorOrientation.Top:
return dataItem.TopConnector;
case ConnectorOrientation.TopRight:
return dataItem.TopRightConnector;
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
case ConnectorOrientation.Right:
return dataItem.RightConnector;
Portless序列化
2023-01-27 20:43:41 +08:00
case ConnectorOrientation.BottomRight:
return dataItem.BottomRightConnector;
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
case ConnectorOrientation.Bottom:
return dataItem.BottomConnector;
Portless序列化
2023-01-27 20:43:41 +08:00
case ConnectorOrientation.BottomLeft:
return dataItem.BottomLeftConnector;
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
default:
throw new InvalidOperationException(
string.Format("Found invalid persisted Connector Orientation for Connector Id: {0}", connectorId));
}
}
}
把底层再分割一下
2023-01-24 09:02:40 +08:00
private bool ItemsToDeleteHasConnector(List<SelectableDesignerItemViewModelBase> itemsToRemove, ConnectorInfoBase connector)
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
{
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)
{
把底层再分割一下
2023-01-24 09:02:40 +08:00
List<SelectableDesignerItemViewModelBase> itemsToRemove = SelectedItems.OfType<SelectableDesignerItemViewModelBase>().ToList();
List<SelectableDesignerItemViewModelBase> connectionsToAlsoRemove = new List<SelectableDesignerItemViewModelBase>();
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
序列化继续整理
2023-01-24 17:53:04 +08:00
foreach (var connector in Items.OfType<ConnectionViewModel>())
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
{
if (ItemsToDeleteHasConnector(itemsToRemove, connector.SourceConnectorInfo))
{
connectionsToAlsoRemove.Add(connector);
}
if (ItemsToDeleteHasConnector(itemsToRemove, connector.SinkConnectorInfo))
{
connectionsToAlsoRemove.Add(connector);
}
}
itemsToRemove.AddRange(connectionsToAlsoRemove);
RemoveItemCommand.Execute(itemsToRemove);
}
序列化调整中
2023-01-24 23:10:57 +08:00
#endregion
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
序列化调整中
2023-01-24 23:10:57 +08:00
#region 移动
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
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;
}
}
序列化调整中
2023-01-24 23:10:57 +08:00
public void UpdateZIndex()
{
List<SelectableDesignerItemViewModelBase> ordered = Items.OrderBy(p => p.ZIndex).ToList();
for (int i = 0; i < ordered.Count; i++)
{
ordered[i].ZIndex = i;
}
}
#endregion
#region 大小
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
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;
}
}
}
序列化调整中
2023-01-24 23:10:57 +08:00
#endregion
#region 分组
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
private void ExecuteGroupCommand(object parameter)
{
大部分完成，还有写要解决的问题
2023-01-26 22:25:48 +08:00
List<DesignerItemViewModelBase> items;
if (parameter is IEnumerable<DesignerItemViewModelBase> para)
{
items = para.ToList();
}
else
{
items = SelectedItems.OfType<DesignerItemViewModelBase>().Where(p => p.ParentId == Guid.Empty).ToList();
}
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
使用PointBase代替Point
2023-01-08 09:22:37 +08:00
RectangleBase rect = GetBoundingRectangle(items);
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
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();
}
}
序列化调整中
2023-01-24 23:10:57 +08:00
public bool BelongToSameGroup(IGroupable item1, IGroupable item2)
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
{
序列化调整中
2023-01-24 23:10:57 +08:00
IGroupable root1 = SelectionService.GetGroupRoot(item1);
IGroupable root2 = SelectionService.GetGroupRoot(item2);
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
序列化调整中
2023-01-24 23:10:57 +08:00
return (root1.Id == root2.Id);
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
}
序列化调整中
2023-01-24 23:10:57 +08:00
#endregion
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
序列化调整中
2023-01-24 23:10:57 +08:00
private void ExecuteLockCommand(object parameter)
调整了一下各种命令的位置，便于其他应用调用
2022-12-08 20:54:45 +08:00
{
}
序列化调整中
2023-01-24 23:10:57 +08:00
private void ExecuteUnlockCommand(object parameter)
添加项目文件。
2021-07-23 09:42:22 +08:00
{
}
EnableSnapping完成
2023-01-26 20:05:21 +08:00
添加项目文件。
2021-07-23 09:42:22 +08:00
使用PointBase代替Point
2023-01-08 09:22:37 +08:00
public RectangleBase GetBoundingRectangle(IEnumerable<DesignerItemViewModelBase> items)
添加项目文件。
2021-07-23 09:42:22 +08:00
{
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);
}
使用PointBase代替Point
2023-01-08 09:22:37 +08:00
return new RectangleBase(new PointBase(x1, y1), new PointBase(x2, y2));
添加项目文件。
2021-07-23 09:42:22 +08:00
}
Flowchart
2022-12-04 23:07:20 +08:00
#region 用于wpf大小与物理像素之间转换
public void SetScreenScale()
{
ScreenScale = ScreenHelper.ResetScreenScale();
}
#endregion
添加项目文件。
2021-07-23 09:42:22 +08:00
}
}
Reference in New Issue Copy Permalink