结构调整，便于后续扩展

AIStudio.Wpf.ADiagram/ViewModels/DiagramsViewModel.cs

@@ -1,7 +1,7 @@
-using AIStudio.Wpf.ADiagram.Commands;
-using AIStudio.Wpf.ADiagram.Demos.Flowchart;
-using AIStudio.Wpf.ADiagram.Demos.Others;
-using AIStudio.Wpf.ADiagram.Helpers;
+using AIStudio.Wpf.BaseDiagram.Commands;
+using AIStudio.Wpf.Flowchart;
+using AIStudio.Wpf.BaseDiagram.Extensions.ViewModels;
+using AIStudio.Wpf.BaseDiagram.Helpers;
 using AIStudio.Wpf.ADiagram.Models;
 using Newtonsoft.Json;
 using System;
@@ -20,14 +20,12 @@ using ZXing;
 
 namespace AIStudio.Wpf.ADiagram.ViewModels
 {
-    public class DiagramsViewModel : BindableBase
+    public partial class DiagramsViewModel : BindableBase
     {
         private IDiagramServiceProvider _service { get { return DiagramServicesProvider.Instance.Provider; } }
-        public MainWindowViewModel MainWindowViewModel { get; set; }
        
-        public DiagramsViewModel(MainWindowViewModel mainWindowViewModel, string title, string status, DiagramType diagramType)
+        public DiagramsViewModel(string title, string status, DiagramType diagramType)
         {
-            MainWindowViewModel = mainWindowViewModel;
             Title = title;
             Status = status;
             DiagramType = diagramType;
@@ -40,9 +38,8 @@ namespace AIStudio.Wpf.ADiagram.ViewModels
 
             Init();
         }
-        public DiagramsViewModel(MainWindowViewModel mainWindowViewModel, string filename)
+        public DiagramsViewModel(string filename)
         {
-            MainWindowViewModel = mainWindowViewModel;
             FileName = filename;
             OpenFile(filename);
         }

AIStudio.Wpf.ADiagram/ViewModels/FlowchartViewModel.cs

@@ -0,0 +1,106 @@
+using AIStudio.Wpf.ADiagram.ViewModels;
+using AIStudio.Wpf.Flowchart.ViewModels;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Media;
+using Util.DiagramDesigner;
+
+namespace AIStudio.Wpf.Flowchart
+{
+    public class FlowchartViewModel : DiagramsViewModel
+    {
+        public FlowchartViewModel(string title, string status, DiagramType diagramType) : base(title, status, diagramType)
+        {
+
+        }
+        public FlowchartViewModel(string filename) : base(filename)
+        {
+
+        }
+
+        protected override void InitDiagramViewModel()
+        {
+            base.InitDiagramViewModel();
+
+            DiagramViewModel.ShowGrid = true;
+            DiagramViewModel.GridCellSize = new Size(100, 100);
+            DiagramViewModel.CellHorizontalAlignment = CellHorizontalAlignment.Center;
+            DiagramViewModel.CellVerticalAlignment = CellVerticalAlignment.Center;
+        }
+
+        protected override void Init()
+        {
+            base.Init();
+
+            DesignerItemViewModelBase start = new StartFlowNode() { Left = 100, Top = 0, Color = Colors.Yellow.ToString() };
+            DiagramViewModel.DirectAddItemCommand.Execute(start);
+
+            DesignerItemViewModelBase middle1 = new MiddleFlowNode() { Left = 100, Top = 100, Color = Colors.Yellow.ToString(), Text = "主管审批", UserIds= new List<string> { "操作员1", "操作员2" }, ActType = "or" };
+            DiagramViewModel.DirectAddItemCommand.Execute(middle1);
+
+            DesignerItemViewModelBase decide = new DecideFlowNode() { Left = 100, Top = 200, Color = Colors.Yellow.ToString(), Text = "5" };
+            DiagramViewModel.DirectAddItemCommand.Execute(decide);
+
+            DesignerItemViewModelBase middle2 = new MiddleFlowNode() { Left = 200, Top = 300, Color = Colors.Yellow.ToString(), Text = "分管领导", UserIds = new List<string> { "操作员1", "操作员2" }, ActType = "and" };
+            DiagramViewModel.DirectAddItemCommand.Execute(middle2);
+
+            DesignerItemViewModelBase cobegin = new COBeginFlowNode() { Left = 100, Top = 400, Color = Colors.Yellow.ToString() };
+            DiagramViewModel.DirectAddItemCommand.Execute(cobegin);
+
+            DesignerItemViewModelBase middle3 = new MiddleFlowNode() { Left = 100, Top = 500, Color = Colors.Yellow.ToString(), Text = "财务审批", UserIds = new List<string> { "Admin" }, ActType = "or" };
+            DiagramViewModel.DirectAddItemCommand.Execute(middle3);
+
+            DesignerItemViewModelBase middle4 = new MiddleFlowNode() { Left = 200, Top = 500, Color = Colors.Yellow.ToString(), Text = "人力审批", RoleIds = new List<string> { "操作员", "管理员" }, ActType = "or" };
+            DiagramViewModel.DirectAddItemCommand.Execute(middle4);
+
+            DesignerItemViewModelBase coend = new COEndFlowNode() { Left = 100, Top = 600, Color = Colors.Yellow.ToString() };
+            DiagramViewModel.DirectAddItemCommand.Execute(coend);
+
+            DesignerItemViewModelBase end = new EndFlowNode() { Left = 100, Top = 700, Color = Colors.Yellow.ToString() };
+            DiagramViewModel.DirectAddItemCommand.Execute(end);
+
+            ConnectorViewModel connector1 = new ConnectorViewModel(start.BottomConnector, middle1.TopConnector);     
+            DiagramViewModel.DirectAddItemCommand.Execute(connector1);
+
+            ConnectorViewModel connector2 = new ConnectorViewModel(middle1.BottomConnector, decide.TopConnector);
+            DiagramViewModel.DirectAddItemCommand.Execute(connector2);
+
+            ConnectorViewModel connector3 = new ConnectorViewModel(decide.RightConnector, middle2.TopConnector);
+            DiagramViewModel.DirectAddItemCommand.Execute(connector3);
+            connector3.AddText(">=3");
+
+            ConnectorViewModel connector4 = new ConnectorViewModel(middle2.BottomConnector, cobegin.TopConnector);
+            DiagramViewModel.DirectAddItemCommand.Execute(connector4);
+
+            ConnectorViewModel connector5 = new ConnectorViewModel(decide.BottomConnector, cobegin.TopConnector);
+            DiagramViewModel.DirectAddItemCommand.Execute(connector5);
+            connector5.AddText("<3");
+
+            ConnectorViewModel connector6 = new ConnectorViewModel(cobegin.BottomConnector, middle3.TopConnector);
+            DiagramViewModel.DirectAddItemCommand.Execute(connector6);
+
+            ConnectorViewModel connector7 = new ConnectorViewModel(cobegin.BottomConnector, middle4.TopConnector);
+            DiagramViewModel.DirectAddItemCommand.Execute(connector7);
+
+            ConnectorViewModel connector8 = new ConnectorViewModel(middle3.BottomConnector, coend.TopConnector);
+            DiagramViewModel.DirectAddItemCommand.Execute(connector8);
+
+            ConnectorViewModel connector9 = new ConnectorViewModel(middle4.BottomConnector, coend.TopConnector);
+            DiagramViewModel.DirectAddItemCommand.Execute(connector9);
+
+            ConnectorViewModel connector10 = new ConnectorViewModel(coend.BottomConnector, end.TopConnector);
+            DiagramViewModel.DirectAddItemCommand.Execute(connector10);
+
+            DiagramViewModel.ClearSelectedItems();
+
+            FlowchartService.InitOAData(DiagramViewModel.Items.OfType<FlowNode>().ToList(), DiagramViewModel.Items.OfType<ConnectorViewModel>().ToList());
+        }
+
+ 
+    }
+}

AIStudio.Wpf.ADiagram/ViewModels/LogicalViewModel.cs

@@ -0,0 +1,413 @@
+using AIStudio.Wpf.ADiagram.ViewModels;
+using AIStudio.Wpf.Logical.ViewModels;
+using System;
+using System.Linq;
+using System.Windows;
+using System.Windows.Media;
+using Util.DiagramDesigner;
+
+namespace AIStudio.Wpf.Logical
+{
+    public class LogicalViewModel : DiagramsViewModel
+    {
+        public LogicalViewModel(string title, string status, DiagramType diagramType) : base(title, status, diagramType)
+        {
+
+        }
+        public LogicalViewModel(string filename) : base(filename)
+        {
+
+        }
+
+        protected override void InitDiagramViewModel()
+        {
+            base.InitDiagramViewModel();
+
+            DiagramViewModel.ShowGrid = true;
+            DiagramViewModel.GridCellSize = new Size(150, 100);
+            DiagramViewModel.PageSizeOrientation = PageSizeOrientation.Horizontal;
+            DiagramViewModel.CellHorizontalAlignment = CellHorizontalAlignment.Left;
+            DiagramViewModel.CellVerticalAlignment = CellVerticalAlignment.None;
+
+            DiagramViewModel.Items.CollectionChanged += Items_CollectionChanged;
+        }
+
+        protected override void Init()
+        {
+            base.Init();
+
+            TimerDesignerItemViewModel timer = new TimerDesignerItemViewModel() { Left = 0, Top = 10 };
+            timer.Value = 0.5;
+            DiagramViewModel.DirectAddItemCommand.Execute(timer);
+
+            InputItemViewModel in1 = new InputItemViewModel() { Left = 0, Top = 50 };
+            in1.LinkPoint = LogicalService.LinkPoint[0];
+            DiagramViewModel.DirectAddItemCommand.Execute(in1);
+
+            InputItemViewModel in2 = new InputItemViewModel() { Left = 0, Top = 80 };
+            in2.LinkPoint = LogicalService.LinkPoint[1];
+            DiagramViewModel.DirectAddItemCommand.Execute(in2);
+
+            AddGateItemViewModel item1 = new AddGateItemViewModel() { Left = 150, Top = 50 };
+            DiagramViewModel.DirectAddItemCommand.Execute(item1);
+
+            ConstantDesignerItemViewModel constant = new ConstantDesignerItemViewModel() { Left = 150, Top = 118 };
+            DiagramViewModel.DirectAddItemCommand.Execute(constant);
+
+            GTGateItemViewModel gTGate = new GTGateItemViewModel() { Left = 300, Top = 50 };
+            DiagramViewModel.DirectAddItemCommand.Execute(gTGate);
+
+            InputItemViewModel in3 = new InputItemViewModel() { Left = 300, Top = 118 };
+            in3.LinkPoint = LogicalService.LinkPoint[2];
+            DiagramViewModel.DirectAddItemCommand.Execute(in3);
+
+            InputItemViewModel in4 = new InputItemViewModel() { Left = 300, Top = 148 };
+            in4.LinkPoint = LogicalService.LinkPoint[3];
+            DiagramViewModel.DirectAddItemCommand.Execute(in4);
+
+            SELGateItemViewModel sELGate = new SELGateItemViewModel() { Left = 450, Top = 50 };
+            DiagramViewModel.DirectAddItemCommand.Execute(sELGate);
+
+            OutputItemViewModel out1 = new OutputItemViewModel() { Left = 600, Top = 50 };
+            out1.LinkPoint = LogicalService.LinkPoint[4];
+            DiagramViewModel.DirectAddItemCommand.Execute(out1);
+
+            ConnectorViewModel connector1 = new ConnectorViewModel(in1.Output[0], item1.Input[0]);
+            DiagramViewModel.DirectAddItemCommand.Execute(connector1);
+
+            ConnectorViewModel connector2 = new ConnectorViewModel(in2.Output[0], item1.Input[1]);
+            DiagramViewModel.DirectAddItemCommand.Execute(connector2);
+
+            ConnectorViewModel connector3 = new ConnectorViewModel(item1.Output[0], gTGate.Input[0]);
+            DiagramViewModel.DirectAddItemCommand.Execute(connector3);
+
+            ConnectorViewModel connector4 = new ConnectorViewModel(constant.Output[0], gTGate.Input[1]);
+            DiagramViewModel.DirectAddItemCommand.Execute(connector4);
+
+            ConnectorViewModel connector5 = new ConnectorViewModel(gTGate.Output[0], sELGate.Input[0]);
+            DiagramViewModel.DirectAddItemCommand.Execute(connector5);
+
+            ConnectorViewModel connector6 = new ConnectorViewModel(in3.Output[0], sELGate.Input[1]);
+            DiagramViewModel.DirectAddItemCommand.Execute(connector6);
+
+            ConnectorViewModel connector7 = new ConnectorViewModel(in4.Output[0], sELGate.Input[2]);
+            DiagramViewModel.DirectAddItemCommand.Execute(connector7);
+
+            ConnectorViewModel connector8 = new ConnectorViewModel(sELGate.Output[0], out1.Input[0]);
+            DiagramViewModel.DirectAddItemCommand.Execute(connector8);
+        }
+
+        private void Items_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
+        {
+            if (e.OldItems != null)
+            {
+                foreach (var item in e.OldItems.OfType<TimerDesignerItemViewModel>())
+                {
+                    item.Do -= Do;
+                }
+            }
+            if (e.NewItems != null)
+            {
+                foreach (var item in e.NewItems.OfType<TimerDesignerItemViewModel>())
+                {
+                    item.Do += Do;
+                }
+            }
+
+            RaisePropertyChanged("Items");
+        }
+
+        protected override bool AddVerify(SelectableDesignerItemViewModelBase arg)
+        {
+            if (base.AddVerify(arg) == false)
+                return false;
+
+            if (arg is ConnectorViewModel connector)
+            {
+                if (connector.SinkConnectorInfo is FullyCreatedConnectorInfo fully)
+                {
+                    if (DiagramViewModel.Items.OfType<ConnectorViewModel>().Any(p => p.SinkConnectorInfo == fully))
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        private void Do()
+        {
+            foreach (var item in DiagramViewModel.Items.OfType<ConstantDesignerItemViewModel>())
+            {
+                foreach (var output in item.Output)
+                {
+                    output.Value.ConnectorValue = item.Value;
+                    output.Value.ColorViewModel.FillColor.Color = Colors.Green;
+                }
+            }
+
+            foreach (var item in DiagramViewModel.Items.OfType<InputItemViewModel>())
+            {
+                if (item.LinkPoint != null)
+                {
+                    foreach (var output in item.Output)
+                    {
+                        output.Value.ConnectorValue = item.LinkPoint.Value;
+                        output.Value.ColorViewModel.FillColor.Color = Colors.Green;
+                    }
+                }
+            }
+
+            foreach (var item in DiagramViewModel.Items.OfType<LogicalGateItemViewModelBase>().OrderBy(p => p.OrderNumber))
+            {
+                if (item.LogicalType != LogicalType.None)
+                {
+                    foreach (var input in item.Input)
+                    {
+                        var connector = GetSourceItem(input.Value);
+                        if (connector == null)
+                        {
+                            continue;
+                        }
+
+                        if (connector.SourceConnectorInfo.DataItem is LogicalGateItemViewModelBase)
+                        {
+                            input.Value.ConnectorValue = connector.SourceConnectorInfo.ConnectorValue;
+
+                            input.Value.ColorViewModel.FillColor.Color = connector.SourceConnectorInfo.ColorViewModel.FillColor.Color;
+                            connector.ColorViewModel.LineColor.Color = connector.SourceConnectorInfo.ColorViewModel.FillColor.Color;
+
+                            if (item.LogicalType == LogicalType.Output)
+                            {
+                                input.Value.ValueTypePoint = connector.SourceConnectorInfo.ValueTypePoint;
+                            }
+                            else if (item.LogicalType == LogicalType.NOT)
+                            {
+                                input.Value.ValueTypePoint = (connector.SourceConnectorInfo.ValueTypePoint == ValueTypePoint.Bool) ? ValueTypePoint.Bool : ValueTypePoint.Int;
+                            }
+                        }
+                    }
+
+                    foreach (var output in item.Output)
+                    {
+                        if (item.LogicalType == LogicalType.Output)
+                        {
+                            var first = item.Input.Values.FirstOrDefault();
+                            output.Value.ConnectorValue = first.ConnectorValue;
+                            output.Value.ValueTypePoint = first.ValueTypePoint;
+                            (item as OutputItemViewModel).Value = first.ConnectorValue;
+                            (item as OutputItemViewModel).LinkPoint.Value = first.ConnectorValue;
+                        }
+                        else if (item.LogicalType == LogicalType.ADD)
+                        {
+                            output.Value.ConnectorValue = item.Input.Values.Select(p => p.ConnectorValue).Sum();
+                        }
+                        else if (item.LogicalType == LogicalType.SUB)
+                        {
+                            var first = item.Input.Values.Select(p => p.ConnectorValue).FirstOrDefault();
+                            var second = item.Input.Values.Where((value, index) => index != 0).Select(p => p.ConnectorValue).Sum();
+                            output.Value.ConnectorValue = first - second;
+                        }
+                        else if (item.LogicalType == LogicalType.MUL)
+                        {
+                            double result = 0;
+                            foreach (var input in item.Input.Values)
+                            {
+                                if (result == 0)
+                                {
+                                    result = 1;
+                                }
+                                result *= input.ConnectorValue;
+                            }
+                            output.Value.ConnectorValue = result;
+                        }
+                        else if (item.LogicalType == LogicalType.DIV)
+                        {
+                            double result = item.Input.Values.Select(p => p.ConnectorValue).FirstOrDefault();
+                            foreach (var input in item.Input.Values.Where((value, index) => index != 0))
+                            {
+                                result /= input.ConnectorValue;
+                            }
+                            output.Value.ConnectorValue = result;
+                        }
+                        else if (item.LogicalType == LogicalType.AVE)
+                        {
+                            output.Value.ConnectorValue = item.Input.Values.Select(p => p.ConnectorValue).Average();
+                        }
+                        else if (item.LogicalType == LogicalType.MOD)
+                        {
+                            output.Value.ConnectorValue = item.Input[0].ConnectorValue % item.Input[1].ConnectorValue;
+                        }
+                        else if (item.LogicalType == LogicalType.AND)
+                        {
+                            output.Value.ConnectorValue = Convert.ToInt32(item.Input[0].ConnectorValue) & Convert.ToInt32(item.Input[1].ConnectorValue);
+                        }
+                        else if (item.LogicalType == LogicalType.OR)
+                        {
+                            output.Value.ConnectorValue = Convert.ToInt32(item.Input[0].ConnectorValue) | Convert.ToInt32(item.Input[1].ConnectorValue);
+                        }
+                        else if (item.LogicalType == LogicalType.XOR)
+                        {
+                            output.Value.ConnectorValue = Convert.ToInt32(Convert.ToInt32(item.Input[0].ConnectorValue) ^ Convert.ToInt32(item.Input[1].ConnectorValue));
+                        }
+                        else if (item.LogicalType == LogicalType.NOT)
+                        {
+                            if (item.Input[0].ValueTypePoint == ValueTypePoint.Bool)
+                            {
+                                output.Value.ConnectorValue = Convert.ToInt32(!Convert.ToBoolean(item.Input[0].ConnectorValue));
+                                output.Value.ValueTypePoint = ValueTypePoint.Bool;
+                            }
+                            else
+                            {
+                                output.Value.ConnectorValue = ~Convert.ToInt32(item.Input[0].ConnectorValue);
+                                output.Value.ValueTypePoint = ValueTypePoint.Int;
+                            }
+
+                        }
+                        else if (item.LogicalType == LogicalType.SHL)
+                        {
+                            output.Value.ConnectorValue = Convert.ToInt32(item.Input[0].ConnectorValue) << Convert.ToInt32(item.Input[1].ConnectorValue);
+                        }
+                        else if (item.LogicalType == LogicalType.SHR)
+                        {
+                            output.Value.ConnectorValue = Convert.ToInt32(item.Input[0].ConnectorValue) >> Convert.ToInt32(item.Input[1].ConnectorValue);
+                        }
+                        else if (item.LogicalType == LogicalType.ROL)
+                        {
+                            output.Value.ConnectorValue = (Convert.ToInt32(item.Input[0].ConnectorValue) << Convert.ToInt32(item.Input[1].ConnectorValue)) | (Convert.ToInt32(item.Input[0].ConnectorValue) >> 32 - Convert.ToInt32(item.Input[1].ConnectorValue));
+                        }
+                        else if (item.LogicalType == LogicalType.ROR)
+                        {
+                            output.Value.ConnectorValue = (Convert.ToInt32(item.Input[0].ConnectorValue) >> Convert.ToInt32(item.Input[1].ConnectorValue)) | (Convert.ToInt32(item.Input[0].ConnectorValue) << 32 - Convert.ToInt32(item.Input[1].ConnectorValue));
+                        }
+                        else if (item.LogicalType == LogicalType.SEL)
+                        {
+                            output.Value.ConnectorValue = (item.Input[0].ConnectorValue == output.Key) ? item.Input[1].ConnectorValue : item.Input[2].ConnectorValue;
+                        }
+                        else if (item.LogicalType == LogicalType.MAX)
+                        {
+                            output.Value.ConnectorValue = item.Input.Values.Select(p => p.ConnectorValue).Max();
+                        }
+                        else if (item.LogicalType == LogicalType.MIN)
+                        {
+                            output.Value.ConnectorValue = item.Input.Values.Select(p => p.ConnectorValue).Min();
+                        }
+                        else if (item.LogicalType == LogicalType.LIMIT)
+                        {
+                            output.Value.ConnectorValue = (item.Input[0].ConnectorValue > item.Input[1].ConnectorValue) ? item.Input[1].ConnectorValue : item.Input[0].ConnectorValue;
+                        }
+                        else if (item.LogicalType == LogicalType.GT)
+                        {
+                            output.Value.ConnectorValue = (item.Input[0].ConnectorValue > item.Input[1].ConnectorValue) ? 1 : 0;
+                        }
+                        else if (item.LogicalType == LogicalType.LT)
+                        {
+                            output.Value.ConnectorValue = (item.Input[0].ConnectorValue < item.Input[1].ConnectorValue) ? 1 : 0;
+                        }
+                        else if (item.LogicalType == LogicalType.GE)
+                        {
+                            output.Value.ConnectorValue = (item.Input[0].ConnectorValue >= item.Input[1].ConnectorValue) ? 1 : 0;
+                        }
+                        else if (item.LogicalType == LogicalType.LE)
+                        {
+                            output.Value.ConnectorValue = (item.Input[0].ConnectorValue <= item.Input[1].ConnectorValue) ? 1 : 0;
+                        }
+                        else if (item.LogicalType == LogicalType.EQ)
+                        {
+                            output.Value.ConnectorValue = (item.Input[0].ConnectorValue == item.Input[1].ConnectorValue) ? 1 : 0;
+                        }
+                        else if (item.LogicalType == LogicalType.NE)
+                        {
+                            output.Value.ConnectorValue = (item.Input[0].ConnectorValue != item.Input[1].ConnectorValue) ? 1 : 0;
+                        }
+                        else if (item.LogicalType == LogicalType.ABS)
+                        {
+                            output.Value.ConnectorValue = Math.Abs(item.Input[0].ConnectorValue);
+                        }
+                        else if (item.LogicalType == LogicalType.SQRT)
+                        {
+                            output.Value.ConnectorValue = Math.Sqrt(item.Input[0].ConnectorValue);
+                        }
+                        else if (item.LogicalType == LogicalType.LN)
+                        {
+                            output.Value.ConnectorValue = Math.Log10(item.Input[0].ConnectorValue);
+                        }
+                        else if (item.LogicalType == LogicalType.LOG)
+                        {
+                            output.Value.ConnectorValue = Math.Log(item.Input[0].ConnectorValue);
+                        }
+                        else if (item.LogicalType == LogicalType.EXP)
+                        {
+                            output.Value.ConnectorValue = Math.Exp(item.Input[0].ConnectorValue);
+                        }
+                        else if (item.LogicalType == LogicalType.SIN)
+                        {
+                            output.Value.ConnectorValue = Math.Sin(item.Input[0].ConnectorValue);
+                        }
+                        else if (item.LogicalType == LogicalType.COS)
+                        {
+                            output.Value.ConnectorValue = Math.Cos(item.Input[0].ConnectorValue);
+                        }
+                        else if (item.LogicalType == LogicalType.TAN)
+                        {
+                            output.Value.ConnectorValue = Math.Tan(item.Input[0].ConnectorValue);
+                        }
+                        else if (item.LogicalType == LogicalType.ASIN)
+                        {
+                            output.Value.ConnectorValue = Math.Asin(item.Input[0].ConnectorValue);
+                        }
+                        else if (item.LogicalType == LogicalType.ACOS)
+                        {
+                            output.Value.ConnectorValue = Math.Acos(item.Input[0].ConnectorValue);
+                        }
+                        else if (item.LogicalType == LogicalType.ATAN)
+                        {
+                            output.Value.ConnectorValue = Math.Atan(item.Input[0].ConnectorValue);
+                        }
+                        else if (item.LogicalType == LogicalType.EXPT)
+                        {
+                            output.Value.ConnectorValue = Math.Exp(item.Input[0].ConnectorValue);
+                        }
+
+                        if (output.Value.ValueTypePoint == ValueTypePoint.Bool)
+                        {
+                            if (output.Value.ConnectorValue == 0)
+                            {
+                                output.Value.ColorViewModel.FillColor.Color = Colors.Red;
+                                if (item.LogicalType == LogicalType.Output)
+                                {
+                                    item.ColorViewModel.FillColor.Color = Colors.Red;
+                                }
+                            }
+                            else
+                            {
+                                output.Value.ColorViewModel.FillColor.Color = Colors.Green;
+                                if (item.LogicalType == LogicalType.Output)
+                                {
+                                    item.ColorViewModel.FillColor.Color = Colors.Green;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            output.Value.ColorViewModel.FillColor.Color = Colors.Green;
+                        }
+                    }
+                }
+            }
+        }
+
+        private ConnectorViewModel GetSourceItem(FullyCreatedConnectorInfo sinkConnector)
+        {
+            foreach (var connector in DiagramViewModel.Items.OfType<ConnectorViewModel>())
+            {
+                if (connector.SinkConnectorInfo == sinkConnector)
+                {
+                    return connector;
+                }
+            }
+            return null;
+        }
+    }
+}

AIStudio.Wpf.ADiagram/ViewModels/MainWindowViewModel.cs

@@ -1,9 +1,6 @@
-using AIStudio.Wpf.ADiagram.Commands;
-using AIStudio.Wpf.ADiagram.Demos.Flowchart;
-using AIStudio.Wpf.ADiagram.Demos.Logical;
-using AIStudio.Wpf.ADiagram.Enums;
-using AIStudio.Wpf.ADiagram.Helpers;
-using AIStudio.Wpf.ADiagram.Views;
+using AIStudio.Wpf.ADiagram.Views;
+using AIStudio.Wpf.Flowchart;
+using AIStudio.Wpf.Logical;
 using ControlzEx.Theming;
 using Dragablz;
 using Fluent;
@@ -18,6 +15,8 @@ using System.Windows;
 using System.Windows.Input;
 using System.Windows.Media;
 using Util.DiagramDesigner;
+using AIStudio.Wpf.BaseDiagram.Helpers;
+using AIStudio.Wpf.BaseDiagram.Commands;
 
 namespace AIStudio.Wpf.ADiagram.ViewModels
 {
@@ -32,7 +31,7 @@ namespace AIStudio.Wpf.ADiagram.ViewModels
 
             ConnectorViewModel.PathFinder = new OrthogonalPathFinder();
             DiagramsViewModels = new ObservableCollection<DiagramsViewModel>();
-            DiagramsViewModels.Add(new DiagramsViewModel(this, "新建-1", "*", DiagramType.Normal));
+            DiagramsViewModels.Add(new DiagramsViewModel("新建-1", "*", DiagramType.Normal));
             DiagramsViewModel = DiagramsViewModels.FirstOrDefault();
 
             StandardColor = GenerateStandardGradients();
@@ -78,8 +77,8 @@ namespace AIStudio.Wpf.ADiagram.ViewModels
             }
         }
 
-        private ColorType _colorObject;
-        public ColorType ColorType
+        private Models.ColorType _colorObject;
+        public Models.ColorType ColorType
         {
             get
             {
@@ -217,7 +216,7 @@ namespace AIStudio.Wpf.ADiagram.ViewModels
                 return
                     () =>
                     {
-                        return new DiagramsViewModel(this, NewNameHelper.GetNewName(DiagramsViewModels.Select(p => p.Title), "新建-"), "*", DiagramType.Normal);
+                        return new DiagramsViewModel(NewNameHelper.GetNewName(DiagramsViewModels.Select(p => p.Title), "新建-"), "*", DiagramType.Normal);
                     };
             }
         }
@@ -774,7 +773,7 @@ namespace AIStudio.Wpf.ADiagram.ViewModels
                 return;
             }
 
-            var flow = new DiagramsViewModel(this, filename);
+            var flow = new DiagramsViewModel(filename);
             DiagramsViewModels.Add(flow);
             DiagramsViewModel = flow;
 
@@ -884,15 +883,15 @@ namespace AIStudio.Wpf.ADiagram.ViewModels
             IsOpenBackstage = false;
             if (type == DiagramType.FlowChart.ToString())
             {
-                DiagramsViewModel = new FlowchartViewModel(this, NewNameHelper.GetNewName(DiagramsViewModels.Select(p => p.Title), "新建-"), "*", (DiagramType)Enum.Parse(typeof(DiagramType), type));
+                DiagramsViewModel = new FlowchartViewModel(NewNameHelper.GetNewName(DiagramsViewModels.Select(p => p.Title), "新建-"), "*", (DiagramType)Enum.Parse(typeof(DiagramType), type));
             }
             else if (type == DiagramType.Logical.ToString())
             {
-                DiagramsViewModel = new LogicalViewModel(this, NewNameHelper.GetNewName(DiagramsViewModels.Select(p => p.Title), "新建-"), "*", (DiagramType)Enum.Parse(typeof(DiagramType), type));
+                DiagramsViewModel = new LogicalViewModel(NewNameHelper.GetNewName(DiagramsViewModels.Select(p => p.Title), "新建-"), "*", (DiagramType)Enum.Parse(typeof(DiagramType), type));
             }
             else
             {
-                DiagramsViewModel = new DiagramsViewModel(this, NewNameHelper.GetNewName(DiagramsViewModels.Select(p => p.Title), "新建-"), "*", (DiagramType)Enum.Parse(typeof(DiagramType), type));
+                DiagramsViewModel = new DiagramsViewModel(NewNameHelper.GetNewName(DiagramsViewModels.Select(p => p.Title), "新建-"), "*", (DiagramType)Enum.Parse(typeof(DiagramType), type));
             }
 
             DiagramsViewModels.Add(DiagramsViewModel);
@@ -1135,9 +1134,9 @@ namespace AIStudio.Wpf.ADiagram.ViewModels
 
             switch (ColorType)
             {
-                case ColorType.Text: DiagramsViewModel.SetFont(new FontViewModel() { FontColor = (Color)para }, "FontColor"); break;
-                case ColorType.Fill: DiagramsViewModel.SetColor(new ColorViewModel() { FillColor = new ColorObject() { Color = (Color)para } }, "FillColor"); break;
-                case ColorType.Line: DiagramsViewModel.SetColor(new ColorViewModel() { LineColor = new ColorObject() { Color = (Color)para } }, "LineColor"); break;
+                case Models.ColorType.Text: DiagramsViewModel.SetFont(new FontViewModel() { FontColor = (Color)para }, "FontColor"); break;
+                case Models.ColorType.Fill: DiagramsViewModel.SetColor(new ColorViewModel() { FillColor = new ColorObject() { Color = (Color)para } }, "FillColor"); break;
+                case Models.ColorType.Line: DiagramsViewModel.SetColor(new ColorViewModel() { LineColor = new ColorObject() { Color = (Color)para } }, "LineColor"); break;
             }
         }
 

AIStudio.Wpf.ADiagram/ViewModels/ToolBoxViewModel.cs

@@ -1,21 +1,18 @@
-using AIStudio.Wpf.ADiagram.Models;
+using AIStudio.Wpf.BaseDiagram.Commands;
+using AIStudio.Wpf.BaseDiagram.Extensions.ViewModels;
+using AIStudio.Wpf.BaseDiagram.Helpers;
+using AIStudio.Wpf.ADiagram.Models;
+using AIStudio.Wpf.Flowchart;
+using AIStudio.Wpf.Flowchart.ViewModels;
+using AIStudio.Wpf.Logical.ViewModels;
+using Newtonsoft.Json;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Linq;
+using System.Windows.Input;
 using Util.DiagramDesigner;
 using Util.DiagramDesigner.Helpers;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Collections.ObjectModel;
-using AIStudio.Wpf.ADiagram.Demos.Flowchart;
-using AIStudio.Wpf.ADiagram.Demos.Logical;
-using AIStudio.Wpf.ADiagram.Demos.Others;
-using System.Windows.Input;
-using AIStudio.Wpf.ADiagram.Commands;
-using System.IO;
-using Newtonsoft.Json;
-using AIStudio.Wpf.ADiagram.Helpers;
-using static AIStudio.Wpf.ADiagram.Helpers.NewNameHelper;
 
 namespace AIStudio.Wpf.ADiagram.ViewModels
 {
@@ -195,7 +192,7 @@ namespace AIStudio.Wpf.ADiagram.ViewModels
             if (Directory.Exists(_svg))
             {
                 var files = Directory.GetFiles(_svg);
-                foreach (var filename in files.OrderBy(p => p, new NaturalStringComparer()).Where(p => p.ToLower().EndsWith(".svg")))
+                foreach (var filename in files.OrderBy(p => p, new NewNameHelper.NaturalStringComparer()).Where(p => p.ToLower().EndsWith(".svg")))
                 {
                     SvgToolBoxCategory.ToolBoxItems.Add(new SvgToolBoxData(filename, typeof(SvgDesignerItemViewModel)));
                 }