Mind Editoe

AIStudio.Wpf.Mind/ViewModels/MindDiagramViewModel.cs

@@ -0,0 +1,382 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using AIStudio.Wpf.DiagramDesigner;
+
+namespace AIStudio.Wpf.Mind.ViewModels
+{
+    public class MindDiagramViewModel : DiagramViewModel, IMindDiagramViewModel
+    {
+        #region
+        private MindType _mindType = Mind.MindType.Mind;
+        public MindType MindType
+        {
+            get
+            {
+                return _mindType;
+            }
+            set
+            {
+                if (SetProperty(ref _mindType, value))
+                {
+                    ExecutedChangeMindTypeCommand(value);
+                }
+            }
+        }
+        #endregion
+
+        #region 命令
+
+        public SimpleCommand AddParentCommand
+        {
+            get; private set;
+        }
+
+        public SimpleCommand AddChildCommand
+        {
+            get; private set;
+        }
+
+        public SimpleCommand AddPeerCommand
+        {
+            get; private set;
+        }
+
+        public SimpleCommand DeleteSelfCommand
+        {
+            get; private set;
+        }
+
+        public SimpleCommand MoveForwardCommand
+        {
+            get; private set;
+        }
+
+        public SimpleCommand MoveBackCommand
+        {
+            get; private set;
+        }
+
+        private SimpleCommand _changeMindTypeCommand;
+        public SimpleCommand ChangeMindTypeCommand
+        {
+            get
+            {
+                return this._changeMindTypeCommand ?? (this._changeMindTypeCommand = new SimpleCommand(MindExecuteEnable, this.ExecutedChangeMindTypeCommand));
+            }
+        }      
+
+        public SimpleCommand ChangeMindThemeCommand
+        {
+            get; private set;
+        }
+
+        public SimpleCommand ResetLayout
+        {
+            get; private set;
+        }
+
+        public SimpleCommand Expand2Level1
+        {
+            get; private set;
+        }
+
+        public SimpleCommand Expand2Level2
+        {
+            get; private set;
+        }
+
+        public SimpleCommand Expand2Level3
+        {
+            get; private set;
+        }
+
+        public SimpleCommand Expand2Level4
+        {
+            get; private set;
+        }
+
+        public SimpleCommand Expand2Level5
+        {
+            get; private set;
+        }
+
+        public SimpleCommand Expand2Level6
+        {
+            get; private set;
+        }
+        #endregion
+
+        public MindDiagramViewModel()
+        {
+            AddChildCommand = new SimpleCommand(MindExecuteEnable, ExecuteAddChildCommand);
+            AddParentCommand = new SimpleCommand(MindLevelEnable, ExecuteAddParentCommand);
+            AddPeerCommand = new SimpleCommand(MindLevelEnable, ExecuteAddPeerCommand);
+            DeleteSelfCommand = new SimpleCommand(MindLevelEnable, ExecuteDeleteSelfCommand);
+            MoveForwardCommand = new SimpleCommand(MindExecuteEnable, ExecuteMoveForwardCommand);
+            MoveBackCommand = new SimpleCommand(MindExecuteEnable, ExecuteMoveBackCommand);
+        }
+
+        public bool MindExecuteEnable(object para)
+        {
+            if (ExecuteEnable(para) == false) return false;
+
+            if (SelectedItem is MindNode) return true;
+
+            return false;
+        }
+
+        private bool MindLevelEnable(object obj)
+        {
+            if (MindExecuteEnable(obj) == false) return false;
+
+            return (SelectedItem as MindNode).NodeLevel != NodeLevel.Level1;
+        }
+
+        #region 操作
+        private void ExecutedChangeMindTypeCommand(object obj)
+        {
+            if (obj is MindType mindType)
+            {
+                Items.OfType<MindNode>().ToList().ForEach(item => { item.MindType = mindType; });
+
+                Items.OfType<MindNode>().FirstOrDefault()?.LayoutUpdated();
+            }
+        }
+
+        public void ExecuteAddChildCommand(object parameter)
+        {
+            List<MindNode> items = new List<MindNode>();
+            if (parameter is MindNode parent)
+            {
+
+            }
+            else if (parameter is IEnumerable<MindNode> para)
+            {
+                parent = para.FirstOrDefault();//第一个固定为父节点
+                items = para.Skip(1).ToList();
+            }
+            else
+            {
+                parent = SelectedItem as MindNode;
+            }
+
+            if (items?.Count == 0)
+            {
+                var node = new MindNode(this, (NodeLevel)Math.Min((int)parent.NodeLevel + 1, (int)NodeLevel.Level3), this.MindType) { Text = "分支主题" };
+                items.Add(node);
+            }
+
+            DoCommandManager.DoNewCommand(this.ToString(),
+                () => {
+                    foreach (var item in items)
+                    {
+                        parent.AddChild(item);
+                    }
+                    parent.LayoutUpdated();
+                },
+                () => {
+                    foreach (var item in items)
+                    {
+                        parent.RemoveChild(item);
+                    }
+                    parent.LayoutUpdated();
+                });
+
+        }
+
+        public void ExecuteAddParentCommand(object parameter)
+        {
+            List<MindNode> items = new List<MindNode>();
+            if (parameter is MindNode node)
+            {
+
+            }
+            else if (parameter is IEnumerable<MindNode> para)
+            {
+                node = para.FirstOrDefault();//第一个固定为父节点
+                items = para.Skip(1).ToList();
+            }
+            else
+            {
+                node = SelectedItem as MindNode;
+            }
+            if (items?.Count == 0)
+            {
+                items.Add(new MindNode(this, node.NodeLevel, this.MindType) { Text = "分支主题" });
+            }
+
+            if (node.Parent is MindNode parent)
+            {
+                DoCommandManager.DoNewCommand(this.ToString(),
+                     () => {
+                         int index = parent.Children.IndexOf(node);
+
+                         parent.AddChild(items[0], index + 1);
+                         parent.RemoveChild(node);
+                         items[0].AddChild(node);
+
+                         parent.LayoutUpdated();
+                     },
+                     () => {
+                         int index = parent.Children.IndexOf(items[0]);
+                         items[0].RemoveChild(node);
+                         parent.AddChild(node, index + 1);
+
+                         parent.LayoutUpdated();
+                     });
+
+
+            }
+        }
+
+        public void ExecuteAddPeerCommand(object parameter)
+        {
+            List<MindNode> items = new List<MindNode>();
+            if (parameter is MindNode pear)
+            {
+
+            }
+            else if (parameter is IEnumerable<MindNode> para)
+            {
+                pear = para.FirstOrDefault();//第一个固定为同级节点
+                items = para.Skip(1).ToList();
+            }
+            else
+            {
+                pear = SelectedItem as MindNode;
+            }
+
+            if (items?.Count == 0)
+            {
+                var node = new MindNode(this, pear.NodeLevel, this.MindType) { Text = "分支主题" };
+                items.Add(node);
+            }
+
+
+            if (pear.Parent is MindNode parent)
+            {
+                DoCommandManager.DoNewCommand(this.ToString(),
+                    () => {
+                        int index = parent.Children.IndexOf(pear);
+                        for (int i = 0; i < items.Count; i++)
+                        {
+                            parent.AddChild(items[i], index + i + 1);
+                        }
+
+                        parent.LayoutUpdated();
+                    },
+                    () => {
+                        for (int i = 0; i < items.Count; i++)
+                        {
+                            parent.RemoveChild(items[i]);
+                        }
+                        parent.LayoutUpdated();
+                    });
+
+            }
+
+        }
+
+        private void ExecuteMoveBackCommand(object parameter)
+        {
+            if (parameter is MindNode node)
+            {
+
+            }
+            else
+            {
+                node = SelectedItem as MindNode;
+            }
+
+            if (node.Parent is MindNode parent)
+            {
+                DoCommandManager.DoNewCommand(this.ToString(),
+                    () => {
+                        int index = parent.Children.IndexOf(node);
+                        if (index < parent.Children.Count - 1)
+                        {
+                            parent.RemoveChild(node);
+                            parent.AddChild(node, index + 1);
+                            parent.LayoutUpdated();
+                        }
+                    },
+                    () => {
+                        int index = parent.Children.IndexOf(node);
+                        if (index > 0)
+                        {
+                            parent.RemoveChild(node);
+                            parent.AddChild(node, index - 1);
+                            parent.LayoutUpdated();
+                        }
+                    });
+            }
+
+        }
+
+        private void ExecuteMoveForwardCommand(object parameter)
+        {
+            if (parameter is MindNode node)
+            {
+
+            }
+            else
+            {
+                node = SelectedItem as MindNode;
+            }
+
+            if (node.Parent is MindNode parent)
+            {
+                DoCommandManager.DoNewCommand(this.ToString(),
+                  () => {
+                      int index = parent.Children.IndexOf(node);
+                      if (index > 0)
+                      {
+                          parent.RemoveChild(node);
+                          parent.AddChild(node, index - 1);
+                          parent.LayoutUpdated();
+                      }
+                  },
+                  () => {
+                      int index = parent.Children.IndexOf(node);
+                      if (index < parent.Children.Count - 1)
+                      {
+                          parent.RemoveChild(node);
+                          parent.AddChild(node, index + 1);
+                          parent.LayoutUpdated();
+                      }
+                  });
+            }
+
+        }
+
+        private void ExecuteDeleteSelfCommand(object parameter)
+        {
+            if (parameter is MindNode node)
+            {
+
+            }
+            else
+            {
+                node = SelectedItem as MindNode;
+            }
+
+            if (node.Parent is MindNode parent)
+            {
+                int index = parent.Children.IndexOf(node);
+                DoCommandManager.DoNewCommand(this.ToString(),
+                  () => {
+                      parent.RemoveChild(node, true);
+                      parent.LayoutUpdated();
+                  },
+                  () => {
+                      parent.AddChild(node, index);
+                      parent.LayoutUpdated();
+                  });
+            }
+
+        }
+        #endregion
+
+    }
+}