public void GetDown_親の妹()
        {
            var model = new NodeManager();

            var nodes = new QuartetEditorDescription()
            {
                Node = CreateItemList(
                    CreateItem("ノード1"),
                    CreateItem("ノード2")
                    )
            };

            nodes.Node[0].Children = CreateItemList(
                CreateItem("ノード1-1"),
                CreateItem("ノード1-2")
                );
            nodes.Node[1].Children = CreateItemList(
                CreateItem("ノード2-1"),
                CreateItem("ノード2-2")
                );

            SetQED(ref model, nodes);
            var selected = FindNode(model, "ノード1-2");

            var find = this.GetDown(model, selected);

            Assert.AreSame("ノード2", find.Name);
        }
        /// <summary>
        /// 階層付きテキストファイルをノードに変換する
        /// </summary>
        /// <returns></returns>
        static public bool FromTreeText(string treeText, char headerChar, out QuartetEditorDescription QED)
        {
            QED = new QuartetEditorDescription();
            var    nodes    = new List <QuartetEditorDescriptionItem>();
            string lineFeed = FileUtility.GetLineFeedCode(treeText);

            // 行頭の制御文字がない場合はエラー
            int index = 0;

            if (!treeText.StartsWith(headerChar.ToString()))
            {
                index = treeText.IndexOf(lineFeed + headerChar.ToString());
                if (index == -1)
                {
                    return(false);
                }
                index += lineFeed.Length;
            }

            treeText = treeText.SafeSubstring(index);
            FromTreeText(ref treeText,
                         headerChar,
                         lineFeed,
                         nodes,
                         1);

            QED.Node = nodes;

            // バージョンは1.0で固定
            QED.Version = 1.0;

            return(true);
        }
        private void SetQED(ref NodeManager target, QuartetEditorDescription qed)
        {
            var pbObj = new PrivateObject(target);

            // private void Load(QuartetEditorDescription model)
            pbObj.Invoke("Load", qed);
        }
        public void GetYounger_ルート以外()
        {
            var model = new NodeManager();

            var nodes = new QuartetEditorDescription()
            {
                Node = CreateItemList(
                    CreateItem("ノード1"),
                    CreateItem("ノード2")
                    )
            };

            nodes.Node[0].Children = CreateItemList(
                CreateItem("ノード1-1"),
                CreateItem("ノード1-2")
                );

            SetQED(ref model, nodes);
            var selected = FindNode(model, "ノード1-1");

            var pbObj = new PrivateObject(model);

            var find = pbObj.Invoke("GetYounger", selected) as Node;

            Assert.AreSame("ノード1-2", find.Name);
        }
        /// <summary>
        /// 階層付きテキストデータに変換する
        /// </summary>
        /// <returns></returns>
        static public string ToTreeText(QuartetEditorDescription data, char headerChar)
        {
            StringBuilder export = new StringBuilder();
            int           level  = 1;

            foreach (var item in data.Node)
            {
                ToTreeText(item, export, headerChar, level);
            }
            return(export.ToString());
        }
        /// <summary>
        /// QuartetEditorDescriptionを設定します
        /// </summary>
        /// <param name="model"></param>
        public void Load(QuartetEditorDescription model)
        {
            this.TreeSource.Clear();
            this.UndoRedoModel.Clear();
            foreach (var item in model.Node)
            {
                this.TreeSource.Add(new Node(item));
            }

            this.Tree.First().IsSelected = true;
            this.OffEditFlag();
        }
        public void GetNext_3階層またぎ()
        {
            var model = new NodeManager();

            var nodes = new QuartetEditorDescription()
            {
                Node = CreateItemList(
                    CreateItem("ノード1"),
                    CreateItem("ノード2")
                    )
            };

            nodes.Node[0].Children = CreateItemList(
                CreateItem("ノード1-1"),
                CreateItem("ノード1-2")
                );
            nodes.Node[0].Children[1].Children = CreateItemList(
                CreateItem("ノード1-2-1"),
                CreateItem("ノード1-2-2")
                );
            nodes.Node[0].Children[1].Children[1].Children = CreateItemList(
                CreateItem("ノード1-2-2-1"),
                CreateItem("ノード1-2-2-2")
                );
            nodes.Node[1].Children = CreateItemList(
                CreateItem("ノード2-1"),
                CreateItem("ノード2-2")
                );
            nodes.Node[1].Children[0].Children = CreateItemList(
                CreateItem("ノード2-1-1"),
                CreateItem("ノード2-1-2")
                );
            nodes.Node[1].Children[0].Children[0].Children = CreateItemList(
                CreateItem("ノード2-1-1-1"),
                CreateItem("ノード2-1-1-2")
                );

            SetQED(ref model, nodes);
            var selected = FindNode(model, "ノード1-2-2-2");

            var pbObj = new PrivateObject(model);

            // private Node GetNext(Node item)
            var find = pbObj.Invoke("GetNext", selected) as Node;

            Assert.AreSame("ノード2-1-1-1", find.Name);
        }
        /// <summary>
        /// HTMLデータに変換する
        /// </summary>
        /// <returns></returns>
        static public string ToHTML(QuartetEditorDescription data, string title)
        {
            StringBuilder export = new StringBuilder();
            int           level  = 1;

            export.AppendLine(@"<!DOCTYPE HTML>");
            export.AppendLine("<html lang=\"ja\">");
            export.AppendLine(@"<head>");
            export.AppendLine("<meta charset=\"utf-8\">");
            export.AppendLine("<style type=\"text/css\" media=\"screen\">");
            {
                string css;
                var    assembly = System.Reflection.Assembly.GetExecutingAssembly();
                using (var resourceStream = assembly.GetManifestResourceStream("QuartetEditor.Assets.ExportHTMLStyle.css"))
                {
                    using (var resourceReader = new System.IO.StreamReader(resourceStream))
                    {
                        css = resourceReader.ReadToEnd();
                    }
                }
                export.AppendLine(css);
            }
            export.AppendLine("</style>");
            export.AppendLine(string.Format(@"<title>{0}</title>", HttpUtility.HtmlEncode(title)));
            export.AppendLine(@"</head>");
            export.AppendLine(@"<body>");

            var idDictionary = new Dictionary <QuartetEditorDescriptionItem, string>();

            export.AppendLine(@"<p>");
            export.AppendLine(@"<ul>");
            foreach (var item in data.Node)
            {
                ToHTMLList(item, ref idDictionary, export, level);
            }
            export.AppendLine(@"</ul>");
            export.AppendLine(@"</p>");

            foreach (var item in data.Node)
            {
                ToHTML(item, idDictionary, export, level);
            }

            export.AppendLine(@"</body>");
            export.AppendLine(@"</html>");
            return(export.ToString());
        }
        public void GetUp_同階層()
        {
            var model = new NodeManager();

            var nodes = new QuartetEditorDescription()
            {
                Node = CreateItemList(
                    CreateItem("ノード1"),
                    CreateItem("ノード2")
                    )
            };

            SetQED(ref model, nodes);
            var selected = FindNode(model, "ノード2");
            var find     = this.GetUp(model, selected);

            Assert.AreSame("ノード1", find.Name);
        }
Exemple #10
0
        /// <summary>
        /// ファイルを保存する
        /// </summary>
        private bool Save(string path, FileType type)
        {
            try
            {
                bool   overwrite      = File.Exists(path);
                bool   result         = false;
                string overwiteSuffix = Path.GetRandomFileName().Substring(0, 5);
                if (overwrite)
                {
                    File.Move(path, path + "." + overwiteSuffix);
                }

                switch (type)
                {
                case FileType.QEDocument:
                {
                    var data = new QuartetEditorDescription(this.Content.Tree);
                    result = FileUtility.SaveJsonObject(path, data);
                }
                break;

                case FileType.TreeText:
                {
                    var header = ConfigManager.Current.Config.TreeTextCharacters;
                    var data   = NodeConverterUtility.ToTreeText(new QuartetEditorDescription(this.Content.Tree), header.First());
                    result = FileUtility.SaveText(path, data, Encoding.UTF8);
                }
                break;

                default:
                    throw new NotImplementedException();
                }

                if (result && overwrite)
                {
                    File.Delete(path + "." + overwiteSuffix);
                }
                return(result);
            }
            catch
            {
            }
            return(false);
        }
        public void GetOlder_ない()
        {
            var model = new NodeManager();

            var nodes = new QuartetEditorDescription()
            {
                Node = CreateItemList(
                    CreateItem("ノード1"),
                    CreateItem("ノード2")
                    )
            };

            SetQED(ref model, nodes);
            var selected = FindNode(model, "ノード1");

            var pbObj = new PrivateObject(model);

            var find = pbObj.Invoke("GetOlder", selected) as Node;

            Assert.AreSame(null, find);
        }
        public void GetPrev_同階層()
        {
            var model = new NodeManager();

            var nodes = new QuartetEditorDescription()
            {
                Node = CreateItemList(
                    CreateItem("ノード1"),
                    CreateItem("ノード2"),
                    CreateItem("ノード3")
                    )
            };

            SetQED(ref model, nodes);
            var selected = FindNode(model, "ノード2");

            var pbObj = new PrivateObject(model);

            // private Node GetPrev(Node item)
            var find = pbObj.Invoke("GetPrev", selected) as Node;

            Assert.AreSame("ノード1", find.Name);
        }
        /// <summary>
        /// QEDデータ構造をテキストデータに変換する
        /// </summary>
        /// <returns></returns>
        static public string ToText(QuartetEditorDescription data, ExportSettingModel setting)
        {
            StringBuilder export = new StringBuilder();
            int           level  = 0;

            if (setting.EnableLineWrap)
            {
                // 折り返しありの場合
                foreach (var item in data.Node)
                {
                    ToTextWithLineWrap(item, export, setting, level);
                }
                return(export.ToString());
            }
            else
            {
                // 折り返しなしの場合
                foreach (var item in data.Node)
                {
                    ToText(item, export, level);
                }
                return(export.ToString());
            }
        }
Exemple #14
0
        /// <summary>
        /// QuartetEditorドキュメントクラス
        /// </summary>
        static QEDocument()
        {
#if DEBUG
            var desctiption = new QuartetEditorDescription();
            desctiption.Node.Add(new QuartetEditorDescriptionItem()
            {
                Name = "ノード1", Content = "ノード1"
            });
            desctiption.Node[0].Children.Add(new QuartetEditorDescriptionItem()
            {
                Name = "ノード1-1", Content = "ノード1-1"
            });
            desctiption.Node[0].Children.Add(new QuartetEditorDescriptionItem()
            {
                Name = "ノード1-2", Content = "ノード1-2"
            });
            desctiption.Node[0].Children[1].Children.Add(new QuartetEditorDescriptionItem()
            {
                Name = "ノード1-2-1", Content = "ノード1-2-1"
            });
            desctiption.Node[0].Children[1].Children.Add(new QuartetEditorDescriptionItem()
            {
                Name = "ノード1-2-2", Content = "ノード1-2-2"
            });
            desctiption.Node.Add(new QuartetEditorDescriptionItem()
            {
                Name = "ノード2", Content = "ノード2"
            });
            desctiption.Node[1].Children.Add(new QuartetEditorDescriptionItem()
            {
                Name = "ノード2-1", Content = "ノード2-1"
            });
            desctiption.Node[1].Children[0].Children.Add(new QuartetEditorDescriptionItem()
            {
                Name = "ノード2-1-1", Content = "ノード2-1-1"
            });
            desctiption.Node[1].Children[0].Children.Add(new QuartetEditorDescriptionItem()
            {
                Name = "ノード2-1-2", Content = "ノード2-1-2"
            });
            desctiption.Node[1].Children.Add(new QuartetEditorDescriptionItem()
            {
                Name = "ノード2-2", Content = "ノード2-2"
            });
            desctiption.Node[1].Children[1].Children.Add(new QuartetEditorDescriptionItem()
            {
                Name = "ノード2-2-1", Content = "ノード2-2-1"
            });
            desctiption.Node[1].Children[1].Children.Add(new QuartetEditorDescriptionItem()
            {
                Name = "ノード2-2-2", Content = "ノード2-2-2"
            });
            desctiption.Node.Add(new QuartetEditorDescriptionItem()
            {
                Name = "ノード3", Content = "ノード3"
            });

            Current.Content.Load(desctiption);

            Current.IsEdited = false;
#endif
        }