예제 #1
0
        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            httpServer.Stop();
            //保存配置文件
            XmlTreeNode rootNode = new XmlTreeNode("root");

            rootNode.AddItem("LastFolderPath", lastFolderPath);
            Encoding utf8Encoding = new UTF8Encoding(false);
            String   xml          = rootNode.ToXml(utf8Encoding);

            IoHelper.CreateMultiFolder(Path.GetDirectoryName(configFilePath));
            File.WriteAllText(configFilePath, xml, Encoding.UTF8);

            Environment.Exit(0);
        }
예제 #2
0
        /// <summary>
        /// SERIALIZATION: Creates a XML Serialized copy of the link
        /// </summary>
        /// <param name="p_XmlParentTreeNode"></param>
        /// <returns></returns>
        public XmlTreeNode SerializeToXML(XmlTreeNode p_XmlParentTreeNode)
        {
            XmlTreeNode v_Out = new XmlTreeNode(SerializationUtils.GetFullTypeName(this), p_XmlParentTreeNode);

            NodeGraphView v_View       = Input.Parent.ParentView;
            NodeGraphNode v_InputNode  = Input.Parent;
            NodeGraphNode v_OutputNode = Output.Parent;

            v_Out.AddParameter("InputNodeId", v_View.GetNodeIndex(v_InputNode).ToString());
            v_Out.AddParameter("OutputNodeId", v_View.GetNodeIndex(v_OutputNode).ToString());
            v_Out.AddParameter("InputNodeConnectorIdx", v_InputNode.GetConnectorIndex(Input).ToString());
            v_Out.AddParameter("OutputNodeConnectorIdx", v_OutputNode.GetConnectorIndex(Output).ToString());

            return(v_Out);
        }
        protected override void CreateRootNode(ref XmlTreeNode rootNode)
        {
            var provider = MembershipProviderExtensions.GetMembersMembershipProvider();

            // only show member types if we're using umbraco members on the website
            if (provider.IsUmbracoMembershipProvider())
            {
                rootNode.NodeType = "init" + TreeAlias;
                rootNode.NodeID   = "init";
            }
            else
            {
                rootNode = null;
            }
        }
예제 #4
0
        private void btnSaveTree_Click(object sender, EventArgs e)
        {
            ContextMenuNow = null;
            try
            {
                XmlTreeNode.SaveToXml(treeView1);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }

            btnSaveTree.Enabled      = false;
            btnUseDefautTree.Enabled = false;
        }
 void BaseContentTree_BeforeNodeRender(ref XmlTree sender, ref XmlTreeNode node, EventArgs e)
 {
     if (node.Menu != null && node.NodeType == "content")
     {
         //Find the publish action and add 1 for the index, so the position of the ubpublish  is direct after the publish menu item
         IAction action = node.Menu.Find(p => p.Alias == "rights");
         if (action != null)
         {
             int index = node.Menu.FindIndex(p => p.Alias == "rights");
             //Insert unpublish action
             node.Menu.Insert(index, UsergroupPermissions.Instance);
             node.Menu.Insert(index, ContextMenuSeperator.Instance);
         }
     }
 }
        protected override void CreateRootNode(ref XmlTreeNode rootNode)
        {
            Permissions permissions = PermissionService.Instance.GetCurrentLoggedInUserPermissions();

            if (permissions != null && PermissionService.Instance.GetCurrentLoggedInUserPermissions().HasPermission(GeneralPermissionType.AccessLicenses))
            {
                AssignNodeValues(rootNode, GetNodeIdentifier(LicenseTreeNodeType.License), DeveloperTerms.Licenses, Constants.TreeIcons.LicenseKey, "license");
                rootNode.Source = null;
                rootNode.Action = "javascript:(function(){" + ClientTools.Scripts.ChangeContentFrameUrl(WebUtils.GetPageUrl(Constants.Pages.LicenseCheck)) + "})";
            }
            else
            {
                rootNode = null;
            }
        }
예제 #7
0
        /// <summary>
        /// This is called if the tree has been expanded, and it's used to render and child nodes for this tree
        /// </summary>
        /// <param name="tree">current tree</param>
        public override void Render(ref XmlTree tree)
        {
            XmlTreeNode node;

            foreach (RelationType relationType in RelationType.GetAll().OrderBy(relationType => relationType.Name))
            {
                node        = XmlTreeNode.Create(this);
                node.NodeID = relationType.Id.ToString();
                node.Text   = relationType.Name;
                node.Icon   = "settingAgent.gif";
                node.Action = string.Concat("javascript:openRelationType('", node.NodeID, "');");

                tree.Add(node);
            }
        }
예제 #8
0
        /// <summary>
        /// Render the top Root Nodes.
        /// - Calendar -> The Root of all Calendars
        /// - Locations -> The Root of all Locations
        /// </summary>
        /// <param name="tree">The current tree</param>
        private void PopulateRootNodes(ref XmlTree tree)
        {
            XmlTreeNode xNode = CreateNode("Global Settings", -1);

            tree.Add(xNode);

            var rootNode      = new DynamicNode(-1);
            var homepageNodes = rootNode.Descendants(Constants.HomepageAlias);

            foreach (var node in homepageNodes)
            {
                xNode = CreateNode(node.Name, node.Id);
                tree.Add(xNode);
            }
        }
예제 #9
0
        /// <summary>
        /// Render the top Root Nodes.
        /// - Calendar -> The Root of all Calendars
        /// - Locations -> The Root of all Locations
        /// </summary>
        /// <param name="tree">The current tree</param>
        private void PopulateRootNodes(ref XmlTree tree)
        {
            XmlTreeNode xNode = XmlTreeNode.Create(this);

            xNode.NodeID = "1";
            xNode.Text   = "Calendar";
            //xNode.Action = "javascript:openCustom('" + "1" + "');";
            xNode.Icon     = "calendar.png";
            xNode.OpenIcon = "folder_o.gif";
            xNode.NodeType = "EventCalendarBase";

            var treeService = new TreeService(-1, TreeAlias, ShowContextMenu, IsDialog, DialogMode, app, "CalendarBase");

            xNode.Source = treeService.GetServiceUrl();

            xNode.Menu.Clear();
            xNode.Menu.Add(ActionNew.Instance);
            xNode.Menu.Add(ActionRefresh.Instance);

            tree.Add(xNode);

            xNode        = XmlTreeNode.Create(this);
            xNode.NodeID = "2";
            xNode.Text   = "Locations";
            //xNode.Action = "javascript:openCustom('" + "1" + "');";
            xNode.Icon     = "map.png";
            xNode.OpenIcon = "folder_o.gif";
            xNode.NodeType = "EventLocationBase";

            treeService  = new TreeService(-1, TreeAlias, ShowContextMenu, IsDialog, DialogMode, app, "LocationBase");
            xNode.Source = treeService.GetServiceUrl();

            xNode.Menu.Clear();
            xNode.Menu.Add(ActionNew.Instance);
            xNode.Menu.Add(ActionRefresh.Instance);

            tree.Add(xNode);

            //xNode = XmlTreeNode.Create(this);
            //xNode.NodeID = "3";
            //xNode.Text = "Settings";
            //xNode.Action = "javascript:openSettings();";
            //xNode.Icon = "cog.png";
            //xNode.NodeType = "GeneralSettings";
            //xNode.Menu.Clear();

            //tree.Add(xNode);
        }
예제 #10
0
        /// <summary>
        /// SERIALIZATION: Creates a NodeGraphLink from XML, used for inherited classes
        /// </summary>
        /// <param name="p_ObjectXml"></param>
        /// <param name="p_View"></param>
        /// <returns></returns>
        public static NodeGraphLink DeserializeFromXML(XmlTreeNode p_ObjectXml, NodeGraphView p_View)
        {
            string className = p_ObjectXml.m_nodeName;

            object[] arguments = { p_ObjectXml, p_View };

            System.Reflection.Assembly v_Assembly = System.Reflection.Assembly.GetExecutingAssembly();

            object v_Out = v_Assembly.CreateInstance(className, false,
                                                     System.Reflection.BindingFlags.CreateInstance,
                                                     null,
                                                     arguments, System.Globalization.CultureInfo.GetCultureInfo("en-us"),
                                                     null);

            return(v_Out as NodeGraphLink);
        }
예제 #11
0
        public override void Render(ref XmlTree tree)
        {
            Repository    repository = new Repository();
            List <Entity> entities   = repository.GetAll();

            foreach (Entity entity in entities)
            {
                XmlTreeNode xNode = XmlTreeNode.Create(this);
                xNode.NodeID   = entity.Id.ToString();
                xNode.Text     = entity.Name;
                xNode.Action   = "javascript:openUpacSyndication(" + entity.Id + ");";
                xNode.Icon     = "feed.png";
                xNode.OpenIcon = "feed.png";
                tree.Add(xNode);
            }
        }
예제 #12
0
        /// <summary>
        /// CLIPBOARD: If contains a NodeGraphClipboard.xml, deserializes and add nodes to current view.
        /// </summary>
        public void PasteSelectionFromClipBoard()
        {
            if (Clipboard.ContainsFileDropList())
            {
                if (Clipboard.GetFileDropList().Contains(Path.GetTempPath() + "NodeGraphClipboard.xml"))
                {
                    XmlTree     v_Contents     = XmlTree.FromFile(Path.GetTempPath() + "NodeGraphClipboard.xml");
                    XmlTreeNode v_ContentsRoot = v_Contents.m_rootNode;
                    XmlTreeNode v_NodesRoot    = v_ContentsRoot.GetFirstChild("Nodes");
                    XmlTreeNode v_LinksRoot    = v_ContentsRoot.GetFirstChild("Links");

                    int PreviousNodeCount = this.m_NodeCollection.Count;

                    NodeGraphNode v_CurrentNode;

                    foreach (XmlTreeNode i_Node in v_NodesRoot.m_childNodes)
                    {
                        v_CurrentNode    = NodeGraphNode.DeserializeFromXML(i_Node, this);
                        v_CurrentNode.X += 10;
                        v_CurrentNode.Y += 10;
                        v_CurrentNode.UpdateHitRectangle();
                        this.NodeCollection.Add(v_CurrentNode);
                    }


                    int v_InId, v_InConnectorIdx, v_OutId, v_OutConnectorIdx;

                    foreach (XmlTreeNode i_Link in v_LinksRoot.m_childNodes)
                    {
                        v_InId            = int.Parse(i_Link.m_attributes["InputNodeId"]);
                        v_InConnectorIdx  = int.Parse(i_Link.m_attributes["InputNodeConnectorIdx"]);
                        v_OutId           = int.Parse(i_Link.m_attributes["OutputNodeId"]);
                        v_OutConnectorIdx = int.Parse(i_Link.m_attributes["OutputNodeConnectorIdx"]);


                        // Relinking
                        this.m_Links.Add(new NodeGraphLink(
                                             // P_INPUT
                                             this.m_NodeCollection[PreviousNodeCount + v_InId].Connectors[v_InConnectorIdx],
                                             // P_OUTPUT
                                             this.m_NodeCollection[PreviousNodeCount + v_OutId].Connectors[v_OutConnectorIdx]
                                             ));
                    }
                }
                ParentPanel.Refresh();
            }
        }
예제 #13
0
        protected override void OnRenderFileNode(ref XmlTreeNode xNode)
        {
            xNode.Action = xNode.Action.Replace("openFile", "openScriptEditor");

            // add special icons for javascript files
            if (xNode.Text.Contains(".js"))
            {
                xNode.Icon     = "icon-script";
                xNode.OpenIcon = "icon-script";
            }
            else
            {
                xNode.Icon     = "icon-code";
                xNode.OpenIcon = "icon-code";
            }

            xNode.Text = xNode.Text.StripFileExtension();
        }
예제 #14
0
        // adds nodes to tree
        public override void Render(ref XmlTree tree)
        {
            List <string> nodes = new List <string>()
            {
                "hello", "dolly"
            };
            int i = 0;

            foreach (var s in nodes)
            {
                XmlTreeNode xNode = XmlTreeNode.Create(this);
                xNode.NodeID = i.ToString();
                xNode.Text   = s;
                xNode.Icon   = "fundmedia.png";
                xNode.Action = "javascript:openFundMedia(" + i.ToString() + ")";
                tree.Add(xNode);
            }
        }
        /// <summary>
        /// Called when [before node render].
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="node">The node.</param>
        /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        protected override void OnBeforeNodeRender(ref XmlTree sender, ref XmlTreeNode node, EventArgs e)
        {
            var xpath     = this.GetXPathFromCookie(this.GetDataTypeId());
            var xPathType = this.GetXPathFilterTypeFromCookie(this.GetDataTypeId());
            var xDoc      = new XmlDocument();

            var xmlNode = umbraco.library.GetMedia(int.Parse(node.NodeID), false).Current.OuterXml;

            var xmlString = "<root>" + xmlNode + "</root>";
            var xml       = XElement.Parse(xmlString);

            node.DetermineClickable(xpath, xPathType, xml);

            //ensure that the NodeKey is passed through
            node.Source = this.GetTreeServiceUrlWithParams(int.Parse(node.NodeID), this.GetDataTypeId());

            base.OnBeforeNodeRender(ref sender, ref node, e);
        }
        public override void Render(ref XmlTree tree)
        {
            foreach (Language l in Language.getAll)
            {
                XmlTreeNode xNode = XmlTreeNode.Create(this);
                xNode.NodeID   = l.id.ToString(); //"language_" + l.id.ToString();
                xNode.Text     = l.FriendlyName;
                xNode.Action   = "javascript:openLanguage(" + l.id + ");";
                xNode.Icon     = "icon-flag-alt";
                xNode.OpenIcon = "icon-flag-alt";

                OnBeforeNodeRender(ref tree, ref xNode, EventArgs.Empty);
                if (xNode != null)
                {
                    tree.Add(xNode);
                    OnAfterNodeRender(ref tree, ref xNode, EventArgs.Empty);
                }
            }
        }
예제 #17
0
        private void CreateChildNode(TreeNode node, XmlTreeNode list, DataTable dt, string fAclid)
        {
            DataRow[] drTmp = dt.Select("fname ='" + fAclid + "'");
            if (drTmp != null && drTmp.Length > 0)
            {
                for (int i = 0; i < drTmp.Length; i++)
                {
                    string       aclid    = drTmp[i]["ACLID"].ToString();
                    TreeNodeItem item     = list.GetItemByAclid(aclid);
                    TreeNode     treeNode = new TreeNode();
                    treeNode.Text = item.Descript;
                    treeNode.Tag  = item;
                    //创建子节点
                    CreateChildNode(treeNode, list, dt, aclid);

                    node.Nodes.Add(treeNode);
                }
            }
        }
예제 #18
0
        public override void Render(ref XmlTree tree)
        {
            foreach (DataTypeDefinition dt in DataTypeDefinition.GetAll())
            {
                XmlTreeNode xNode = XmlTreeNode.Create(this);
                xNode.NodeID   = dt.Id.ToString();
                xNode.Text     = dt.Text;
                xNode.Action   = "javascript:openDataType(" + dt.Id + ");";
                xNode.Icon     = "developerDatatype.gif";
                xNode.OpenIcon = "developerDatatype.gif";

                OnBeforeNodeRender(ref tree, ref xNode, EventArgs.Empty);
                if (xNode != null)
                {
                    tree.Add(xNode);
                    OnAfterNodeRender(ref tree, ref xNode, EventArgs.Empty);
                }
            }
        }
예제 #19
0
            public static void SaveToXml(XmlTreeNode obj)
            {
                try
                {
                    //先序列化
                    System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(obj.GetType());
                    System.IO.StringWriter sw = new System.IO.StringWriter();
                    xs.Serialize(sw, obj);

                    System.IO.File.WriteAllText(localConfigPath, sw.ToString(), Encoding.UTF8);

                    sw.Flush();
                    sw.Close();
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }
            }
예제 #20
0
        //从XML得到事件包
        public static EventPackage FromXml(String xml)
        {
            EventPackage rtnPackage = null;

            XmlTreeNode treeNode    = XmlTreeNode.FromXml(xml);
            String      packageName = treeNode.Key;

            if (packageName.Equals("EventPackage"))
            {
                rtnPackage = new EventPackage();
            }
            else
            {
                return(null);
            }

            rtnPackage.SetRootPackage(treeNode);
            return(rtnPackage);
        }
예제 #21
0
        public override void Render(ref XmlTree tree)
        {
            foreach (MediaType dt in MediaType.GetAll)
            {
                XmlTreeNode xNode = XmlTreeNode.Create(this);
                xNode.NodeID   = dt.Id.ToString();
                xNode.Text     = dt.Text;
                xNode.Action   = string.Format("javascript:openMediaType({0});", dt.Id);
                xNode.Icon     = "settingDataType.gif";
                xNode.OpenIcon = "settingDataType.gif";

                OnBeforeNodeRender(ref tree, ref xNode, EventArgs.Empty);
                if (xNode != null)
                {
                    tree.Add(xNode);
                    OnAfterNodeRender(ref tree, ref xNode, EventArgs.Empty);
                }
            }
        }
예제 #22
0
        private void CreateNode(ref XmlTree tree, string name, string action)
        {
            var node = XmlTreeNode.Create(this);

            node.NodeID      = 1.ToString();
            node.NodeType    = "ContentConveyor";
            node.Text        = name;
            node.Action      = "javascript:openDashboard('" + action + "');";
            node.Icon        = "../../../App_Plugins/BackOffice/ContentConveyor/Images/Icons/importDocumenttype.png";
            node.OpenIcon    = "../../../App_Plugins/BackOffice/ContentConveyor/Images/Icons/importDocumenttype.png";
            node.HasChildren = false;
            node.Menu        = new List <IAction>();
            OnBeforeNodeRender(ref tree, ref node, EventArgs.Empty);
            if (node != null)
            {
                tree.Add(node);
                OnAfterNodeRender(ref tree, ref node, EventArgs.Empty);
            }
        }
예제 #23
0
        private void CreateNode(ref XmlTree tree, string name, string action)
        {
            var node = XmlTreeNode.Create(this);

            node.NodeID      = 1.ToString();
            node.NodeType    = "ContentConveyor";
            node.Text        = name;
            node.Action      = "javascript:openDashboard('" + action + "');";
            node.Icon        = "icon-box";
            node.OpenIcon    = "icon-box";
            node.HasChildren = false;
            node.Menu        = new List <IAction>();
            OnBeforeNodeRender(ref tree, ref node, EventArgs.Empty);
            if (node != null)
            {
                tree.Add(node);
                OnAfterNodeRender(ref tree, ref node, EventArgs.Empty);
            }
        }
예제 #24
0
        /// <summary>
        /// Converts an XmlTreeNode to a TreeNode
        /// </summary>
        /// <param name="xNode"></param>
        /// <returns></returns>
        public static TreeNode FromXmlTreeNode(XmlTreeNode xNode, CheckboxTree cbTree)
        {
            TreeNode node = new TreeNode(xNode.Text, xNode.NodeID, cbTree.ImagesRootPath + xNode.Icon, xNode.Action, "");

            node.ImageUrl = "";

            node.PopulateOnDemand = (string.IsNullOrEmpty(xNode.Source) ? false : true);
            //node.SelectAction = (string.IsNullOrEmpty(xNode.Source) ? TreeNodeSelectAction.Select : TreeNodeSelectAction.Expand);
            node.SelectAction = TreeNodeSelectAction.None;

            string nodeMarkup = "";

            //add our custom checkbox
            if (cbTree.ShowCheckBoxes)
            {
                nodeMarkup += string.Format("<span class=\"treeCheckBox\"><input type='checkbox' id='{0}' name='{0}' value='{1}' onclick='{2}(this);' /></span>",
                                            "chk" + node.Value, node.Value, cbTree.OnClientNodeChecked);
            }

            if (xNode.Icon.StartsWith("."))
            {
                nodeMarkup += "<div class=\"sprTree " + xNode.Icon.TrimStart('.') + "\"><img class=\"webfx-tree-icon\" src=\"../images/nada.gif\"/> </div>";
            }
            else
            {
                nodeMarkup += "<span class=\"treeIcon\"><img src=\"" + cbTree.ImagesRootPath + xNode.Icon + "\"/></span>";
            }

            //show the node as being not published
            if (xNode.NotPublished.Value)
            {
                nodeMarkup += string.Format("<span class=\"treeText\" style='color:{0};'>{1}</span>", cbTree.UnpublishedColor, node.Text);
            }
            else
            {
                nodeMarkup += string.Format("<span class=\"treeText\">{0}</span>", node.Text);
            }

            node.Text = nodeMarkup;

            return(node);
        }
예제 #25
0
        private void RenderLocations(ref XmlTree tree)
        {
            if (null != this._db)
            {
                var locations = this._db.Query <EventLocation>("SELECT * FROM ec_locations");

                foreach (var c in locations)
                {
                    XmlTreeNode node = XmlTreeNode.Create(this);

                    node.NodeID   = c.Id.ToString();
                    node.NodeType = "LocationEntry";
                    node.Text     = c.LocationName;
                    node.Icon     = "map.png";
                    node.Action   = "javascript:openLocation(" + c.Id.ToString() + ")";

                    tree.Add(node);
                }
            }
        }
        static XmlTreeNode GetClosestElement(XmlTreeNode treeNode)
        {
            XmlTreeNode element = treeNode.Parent as XmlTreeNode;

            if (treeNode.Parent != null)
            {
                foreach (XmlTreeNode child in treeNode.Parent.Nodes)
                {
                    if (child.Node != null && child.NodeType == XmlNodeType.Element)
                    {
                        element = child;
                    }
                    if (child == treeNode)
                    {
                        break;
                    }
                }
            }
            return(element);
        }
예제 #27
0
        ///
        /// Override the render method to create the newsletter tree
        ///
        ///
        public override void Render(ref XmlTree Tree)
        {
            Tree.treeCollection.Clear();

            var nodeWorkout = XmlTreeNode.Create(this);

            nodeWorkout.NodeID = "Workout" + Guid.NewGuid();
            nodeWorkout.Text   = "Workout";
            nodeWorkout.Icon   = "b_user.png";
            nodeWorkout.Action = string.Format("javascript:openRepository({0});", 1355);
            Tree.Add(nodeWorkout);

            var nodeExercise = XmlTreeNode.Create(this);

            nodeExercise.NodeID = "Exercise" + Guid.NewGuid();
            nodeExercise.Text   = "Exercise";
            nodeExercise.Icon   = "b_user.png";
            nodeExercise.Action = string.Format("javascript:openRepository({0});", 1355);
            Tree.Add(nodeExercise);
        }
예제 #28
0
 /// <summary>
 /// This will call the normal Render method by passing the converted XmlTree to an XmlDocument.
 /// TODO: need to update this render method to do everything that the obsolete render method does and remove the obsolete method
 /// </summary>
 /// <param name="tree"></param>
 public override void Render(ref XmlTree tree)
 {
     using (IRecordsReader macros = SqlHelper.ExecuteReader("select id, macroName from cmsMacro order by macroName"))
     {
         while (macros.Read())
         {
             XmlTreeNode xNode = XmlTreeNode.Create(this);
             xNode.NodeID   = macros.GetInt("id").ToString();
             xNode.Text     = macros.GetString("macroName");
             xNode.Action   = "javascript:openMacro(" + macros.GetInt("id") + ");";
             xNode.Icon     = "developerMacro.gif";
             xNode.OpenIcon = "developerMacro.gif";
             OnBeforeNodeRender(ref tree, ref xNode, EventArgs.Empty);
             if (xNode != null)
             {
                 tree.Add(xNode);
             }
             OnAfterNodeRender(ref tree, ref xNode, EventArgs.Empty);
         }
     }
 }
예제 #29
0
        public override void Render(ref XmlTree tree)
        {
            StyleSheet sn = new StyleSheet(m_id);

            foreach (StylesheetProperty n in sn.Properties)
            {
                XmlTreeNode xNode = XmlTreeNode.Create(this);
                xNode.NodeID   = n.Id.ToString();
                xNode.Text     = n.Text;
                xNode.Action   = "javascript:openStylesheetProperty(" + n.Id + ");";
                xNode.Icon     = "settingCssItem.gif";
                xNode.OpenIcon = "settingCssItem.gif";

                OnBeforeNodeRender(ref tree, ref xNode, EventArgs.Empty);
                if (xNode != null)
                {
                    tree.Add(xNode);
                    OnAfterNodeRender(ref tree, ref xNode, EventArgs.Empty);
                }
            }
        }
        XmlSchemaInfo GetSchemaInfo()
        {
            XmlTreeNode tn = node;

            if (tn.NodeType == XmlNodeType.Text ||
                tn.NodeType == XmlNodeType.CDATA)
            {
                tn = (XmlTreeNode)tn.Parent;
            }
            if (tn == null)
            {
                return(null);
            }
            XmlNode xn = tn.Node;

            if (xn != null && model != null)
            {
                XmlSchemaInfo info = model.GetTypeInfo(xn);
                return(info);
            }
            return(null);
        }
예제 #31
0
        public EditNodeValue(XmlTreeView view, XmlTreeNode n, string newValue)
        {
            this.view = view;
            this.n = n;
            this.xn = n.Node;
            this.newValue = newValue;

            if (xn is XmlElement) {
                this.oldValue = xn.InnerText;
            } else if (xn is XmlProcessingInstruction) {
                XmlProcessingInstruction pi = ((XmlProcessingInstruction)xn);
                this.oldValue = pi.Data;
            } else if (xn != null) {
                this.oldValue = xn.Value;
            }
        }
예제 #32
0
 public TreeParent(XmlTreeView xview, XmlDocument doc, XmlTreeNode node)
     : this(xview.TreeView, doc, node)
 {
 }
예제 #33
0
        /// <summary>
        /// Move or copy a node from one place to another place in the tree.
        /// </summary>
        /// <param name="view">The MyTreeView that we are inserting into</param>
        /// <param name="source">The node that we are moving.  This node may not be in the tree
        /// and that is ok, so it might be a node that is being cut&paste from another process
        /// for example</param>
        /// <param name="target">The existing node that establishes where in the tree we want
        /// to move the source node to</param>
        /// <param name="where">The position relative to the target node (before or after)</param>
        /// <param name="copy">Whether we are moving or copying the source node</param>
        public MoveNode(XmlTreeView view, XmlTreeNode source, XmlTreeNode target, InsertPosition where, bool copy)
        {
            XmlNode sn = source.Node;
            XmlNode dn = target.Node;

            this.copy = copy;
            TreeView tv = view.TreeView;
            XmlDocument doc = view.Model.Document;
            this.view = view;
            this.sourcePosition = source.Index;

            view.Model.BeginUpdate();
            try {
                if (copy) {
                    this.wasExpanded = source.IsExpanded;
                    XmlTreeNode newSource = view.CreateTreeNode();
                    if (sn != null) {
                        sn = sn.CloneNode(true);
                        newSource.Node = sn;
                    }
                    source = newSource;
                }

                this.sourceParent = new TreeParent(tv, doc, source);
                this.tp = new TreeParent(tv, doc, target);

                // normalize destination based on source node type.
                // for example, if source is an attribute, then it can only be
                // inserted amongst attributes of another node.
                if (tp.IsRoot && where != InsertPosition.Child) {
                    if (sn is XmlAttribute)
                        throw new Exception(SR.RootLevelAttributes);
                    if (sn is XmlText || sn is XmlCDataSection)
                        throw new Exception(SR.RootLevelText);
                    if (sn is XmlElement && sn.OwnerDocument.DocumentElement != null && sn.OwnerDocument.DocumentElement != sn)
                        throw new Exception(SR.RootLevelElements);
                    if (dn is XmlDeclaration && where == InsertPosition.Before)
                        throw new Exception(SR.RootLevelBeforeXmlDecl);
                }
                if (where != InsertPosition.Child) {
                    if (sn is XmlAttribute) {
                        if (!(dn is XmlAttribute)) {
                            if (tp.AttributeCount != 0) {
                                // move target to valid location for attributes.
                                target = tp.GetChild(tp.AttributeCount - 1);
                                where = InsertPosition.After;
                            } else {
                                // append the attribute.
                                where = InsertPosition.Child;
                                target = (XmlTreeNode)target.Parent;
                            }

                        }
                    } else if (dn is XmlAttribute) {
                        if (!(sn is XmlAttribute)) {
                            int skip = tp.AttributeCount;
                            if (tp.Count > skip) {
                                // Move non-attribute down to beginning of child elements.
                                target = tp.GetChild(skip);
                                where = InsertPosition.Before;
                            } else {
                                // append the node.
                                where = InsertPosition.Child;
                                target = (XmlTreeNode)target.Parent;
                            }
                        }
                    }
                }
                this.source = source;
                this.target = target;
                this.where = where;
                this.tp = new TreeParent(tv, doc, target);

                if (where == InsertPosition.Child) {
                    this.tp.SetParent(target);
                }
            } finally {
                view.Model.EndUpdate();
            }
        }
예제 #34
0
 public TreeData(XmlTreeNode node)
 {
     img = node.ImageIndex;
     XmlNode x = node.Node;
     if (x != null) {
         nodeType = (int)x.NodeType;
         this.xml = x.OuterXml;
     }
 }
예제 #35
0
 static bool IsDocumentElement(XmlTreeNode node)
 {
     return node.Node != null && node.Node == node.Node.OwnerDocument.DocumentElement;
 }
예제 #36
0
 public EditAttributeName(XmlTreeNode node, string newName)
 {
     this.a = (XmlAttribute)node.Node;
     this.node = node;
     this.p = this.a.OwnerElement;
     Debug.Assert(this.p != null);
     name = XmlHelpers.ParseName(this.p, newName, XmlNodeType.Attribute);
 }
예제 #37
0
 /// <summary>
 /// Insert a new element as a sibling or child of current node. This command can create
 /// new XmlTreeNodes and new XmlNodes to go with it, or it can 
 /// </summary>
 public InsertNode(XmlTreeView view)
 {
     this.view = view;
     this.newNode = view.CreateTreeNode();
     this.doc = view.Model.Document;
     this.position = InsertPosition.Child;
 }
예제 #38
0
        public XmlTreeNode GetTreeNode(XmlDocument owner, XmlTreeNode target, XmlTreeView view)
        {
            XmlTreeNode node = view.CreateTreeNode();

            if (this.img == -1 && this.xml != null){
                Regex regex = new Regex(@"[:_.\w]+\s*=\s*(""[^""]*"")|('[^']*')\s*");
                Match m = regex.Match(xml);
                string trimmed = xml.Trim();
                if (m.Success && m.Index == 0 && m.Length == xml.Length) {
                    nodeType = (int)XmlNodeType.Attribute;
                    img = (int)NodeImage.Attribute - 1;
                } else if (trimmed.StartsWith("<?")) {
                    nodeType = (int)XmlNodeType.ProcessingInstruction;
                    img = (int)NodeImage.PI - 1;
                } else if (trimmed.StartsWith("<!--")) {
                    nodeType = (int)XmlNodeType.Comment;
                    img = (int)NodeImage.Comment - 1;
                } else if (trimmed.StartsWith("<![CDATA[")) {
                    nodeType = (int)XmlNodeType.CDATA;
                    img = (int)NodeImage.CData - 1;
                } else if (trimmed.StartsWith("<")) {
                    nodeType = (int)XmlNodeType.Element;
                    img = (int)NodeImage.Element - 1;
                } else {
                    nodeType = (int)XmlNodeType.Text;
                    img = (int)NodeImage.Text - 1;
                }
            }

            XmlNode xn = null;
            XmlNode context = (target != null) ? target.Node : owner;

            if (this.nodeType == (int)XmlNodeType.Attribute) {
                int i = this.xml.IndexOf('=');
                if (i > 0) {
                    string name = this.xml.Substring(0, i).Trim();
                    XmlName qname = XmlHelpers.ParseName(context, name, XmlNodeType.Attribute);
                    xn = owner.CreateAttribute(qname.Prefix, qname.LocalName, qname.NamespaceUri);
                    string s = this.xml.Substring(i + 1).Trim();
                    if (s.Length > 2) {
                        char quote = s[0];
                        s = s.Substring(1, s.Length - 2); // strip off quotes
                        // un-escape quotes in the value.
                        xn.Value = s.Replace(quote == '\'' ? "&apos;" : "&quot;", quote.ToString());
                    }
                }

            } else {
                XmlNamespaceManager nsmgr = XmlHelpers.GetNamespaceScope(context);
                XmlParserContext pcontext = new XmlParserContext(owner.NameTable, nsmgr, null, XmlSpace.None);
                XmlTextReader r = null;
                if (this.xml != null) {
                    r = new XmlTextReader(this.xml, XmlNodeType.Element, pcontext);
                } else {
                    r = new XmlTextReader(this.stm, XmlNodeType.Element, pcontext);
                }
                r.WhitespaceHandling = WhitespaceHandling.Significant;

                // TODO: add multi-select support, so we can insert multiple nodes also.
                // And find valid nodes (for example, don't attempt to insert Xml declaration
                // if target node is not at the top of the document, etc).
                // For now we just favor XML elements over other node types.
                ArrayList list = new ArrayList();
                while (true){
                    XmlNode rn = owner.ReadNode(r);
                    if (rn == null)
                        break;
                    if (rn is XmlElement){
                        xn = rn;
                        NormalizeNamespaces((XmlElement)rn, nsmgr);
                    }
                    list.Add(rn);
                }
                if (xn == null && list.Count>0)
                    xn = list[0] as XmlNode;
            }
            node.Node = xn;

            if (!(xn is XmlAttribute)) {
                view.Invalidate();
                if (xn is XmlElement){
                    if (node.Nodes.Count <= 1){
                        this.img = ((int)NodeImage.Leaf -1);
                    }
                }
            }
            return node;
        }
예제 #39
0
 public static void SetData(XmlTreeNode node)
 {
     if (node.Node != null) {
         Clipboard.SetDataObject(new TreeData(node));
     }
 }
예제 #40
0
 public CutCommand(XmlTreeView view, XmlTreeNode node)
 {
     this.node = node;
     this.parent = new TreeParent(view, view.Model.Document, node);
     index = node.Index;
 }
예제 #41
0
 public void SetParent(XmlTreeNode parent)
 {
     this.parent = parent;
     if (parent != null && parent.Node != null) {
         this.SetXmlParent(parent.Node);
     }
 }
예제 #42
0
 public void Remove(XmlTreeNode n)
 {
     if (n.Node != null) {
         Remove(n.Node);
     }
     n.Remove();
 }
예제 #43
0
 public EditProcessingInstructionName(XmlProcessingInstruction pi, NodeLabelEditEventArgs e)
 {
     this.pi = pi;
     this.p = this.pi.ParentNode;
     this.node = e.Node as XmlTreeNode;
     Debug.Assert(this.p != null);
     name = e.Label;
     this.newpi = pi.OwnerDocument.CreateProcessingInstruction(name, pi.Data);
 }
예제 #44
0
 public EditAttributeName(XmlTreeNode node, XmlName newName, bool autoGenPrefixes)
 {
     this.a = (XmlAttribute)node.Node;
     this.node = node;
     name = newName;
     this.autoGenPrefixes = autoGenPrefixes;
 }
예제 #45
0
 public EditProcessingInstructionName(XmlTreeNode node, string newName)
 {
     this.pi = (XmlProcessingInstruction)node.Node;
     this.p = this.pi.ParentNode;
     this.node = node;
     Debug.Assert(this.p != null);
     name = newName;
     this.newpi = pi.OwnerDocument.CreateProcessingInstruction(name, pi.Data);
 }
예제 #46
0
        public ChangeNode(XmlTreeView view, XmlTreeNode node, XmlNodeType nt)
        {
            this.doc = view.Model.Document;
            this.nt = nt;
            this.view = view;
            this.node = node;
            XmlNode n = node.Node;
            if (n == null) return;

            init:
            this.oldnt = n.NodeType;
            string innerXml = (oldnt == XmlNodeType.Element) ? n.InnerXml : SpecialUnescape(oldnt, n.Value);
            string outerXml = n.OuterXml;
            string qname = n.Name;
            string localName = n.LocalName;
            string ns = n.NamespaceURI;
            bool noName = false;
            if (qname.StartsWith("#")) {
                qname = localName = "";
            }
            noName = string.IsNullOrEmpty(qname);

            if (noName && IsNamedNodeType(nt)) {
                // Try parsing the content of the node as markup! (but first check for special unescaping
                // that we do for nested comment/cdata blocks)
                PasteCommand paste = new PasteCommand(doc, view, InsertPosition.Before, new TreeData(innerXml));
                XmlTreeNode nte = paste.NewNode;
                if (nte != null && IsNamedNodeType(nte.NodeType)) {
                    // then it worked - we extracted a node with a name, so start over.
                    n = newNode = nte.Node;
                    goto init;
                }
            }
            if (newNode == null || newNode.NodeType != nt) {
                switch (nt) {
                    case XmlNodeType.Element:
                        if (noName) {
                            qname = "element";
                        }
                        newNode = doc.CreateElement(qname, ns);
                        newNode.InnerXml = innerXml;
                        break;
                    case XmlNodeType.Attribute:
                        if (noName) {
                            qname = "attribute";
                        }
                        newNode = doc.CreateAttribute(qname, ns);
                        newNode.Value = innerXml;
                        break;
                    case XmlNodeType.Comment:
                        newNode = doc.CreateComment(SpecialEscape(nt, noName ? innerXml : outerXml));
                        break;
                    case XmlNodeType.ProcessingInstruction:
                        if (noName) {
                            localName = "pi";
                        }
                        newNode = doc.CreateProcessingInstruction(localName, innerXml);
                        break;
                    case XmlNodeType.Text:
                        newNode = doc.CreateTextNode(noName ? innerXml : outerXml);
                        break;
                    case XmlNodeType.CDATA:
                        newNode = doc.CreateCDataSection(SpecialEscape(nt, noName ? innerXml : outerXml));
                        break;
                }
            }
            InsertNode icmd = new InsertNode(node, InsertPosition.Before, newNode, true, true);
            newTreeNode = icmd.NewNode;
            DeleteNode del = new DeleteNode(doc, node);
            group = new CompoundCommand(this.Name);
            group.Add(icmd);
            group.Add(del);
        }
예제 #47
0
 /// <summary>
 /// Insert an existing XmlNode into the tree and create a corresponding XmlTreeNode for it.
 /// </summary>
 /// <param name="target">Anchor point for insertion</param>
 /// <param name="position">Where to insert the new node relative to target node</param>
 /// <param name="xnode">Provided XmlNode that the new XmlTreeNode will wrap</param>
 /// <param name="selectNewNode">Whether to select the node in the tree after it's inserted.</param>
 public InsertNode(XmlTreeNode target, InsertPosition position, XmlNode xnode, bool selectNewNode, bool expandNewNode)
 {
     this.view = target.XmlTreeView;
     this.doc = this.view.Model.Document;
     this.position = position;
     this.type = xnode.NodeType;
     this.newNode = new XmlTreeNode(this.view, xnode);
     Initialize(newNode, target, position);
     this.selectNewNode = selectNewNode;
     this.expandNewNode = expandNewNode;
 }
예제 #48
0
        InsertNode xmlns; // generated prefix

        #endregion Fields

        #region Constructors

        public EditElementName(XmlElement n, NodeLabelEditEventArgs e)
        {
            this.xe = n;
            this.node = e.Node as XmlTreeNode;
            this.name = XmlHelpers.ParseName(n, e.Label, n.NodeType);
        }
예제 #49
0
 public PasteCommand(XmlDocument doc, XmlTreeView view, InsertPosition position, TreeData data)
 {
     this.td = data;
     this.doc = doc;
     this.target = (XmlTreeNode)view.SelectedNode;
     if (this.target == null && view.TreeView.Nodes.Count > 0) {
         this.target = (XmlTreeNode)view.TreeView.Nodes[0];
     }
     if (this.target != null && this.target.NodeType != XmlNodeType.Element &&
         this.target.NodeType != XmlNodeType.Document) {
         position = InsertPosition.After;
     }
     this.position = position;
     this.view = view;
     if (td != null) {
         this.source = td.GetTreeNode(this.doc, this.target, this.view);
     }
 }
예제 #50
0
 public EditElementName(XmlTreeNode node, string newName)
 {
     this.xe = (XmlElement)node.Node; ;
     this.node = node;
     this.name = XmlHelpers.ParseName(this.xe, newName, node.NodeType);
 }
예제 #51
0
 public NudgeNode(XmlTreeView view, XmlTreeNode node, NudgeDirection dir)
 {
     this.node = node;
     this.dir = dir;
     this.view = view;
 }
예제 #52
0
 public EditElementName(XmlTreeNode node, XmlName newName, bool autoGenPrefixes)
 {
     this.xe = (XmlElement)node.Node; ;
     this.node = node;
     this.name = newName;
     this.autoGenPrefixes = autoGenPrefixes;
 }
예제 #53
0
 bool CanHaveChildren(XmlTreeNode target)
 {
     return target.NodeType == XmlNodeType.Element ||
             target.NodeType == XmlNodeType.Document;
 }
예제 #54
0
 public EditNodeName(XmlTreeNode node, string newName)
 {
     if (node.Node == null) {
         throw new ArgumentException(SR.NodeNotCreated);
     }
     switch (node.NodeType) {
         case XmlNodeType.Element:
             cmd = new EditElementName(node, newName);
             break;
         case XmlNodeType.Attribute:
             cmd = new EditAttributeName(node, newName);
             break;
         case XmlNodeType.ProcessingInstruction:
             cmd = new EditProcessingInstructionName(node, newName);
             break;
         default:
             throw new ArgumentException(
                 string.Format(SR.NodeNameNotEditable, node.NodeType.ToString()));
     }
 }
예제 #55
0
 public DeleteNode(XmlDocument doc, XmlTreeNode e)
 {
     this.e = e;
     this.doc = doc;
 }
예제 #56
0
		public void Edit(object sender, System.EventArgs e)
		{
			if ( Nodes.Count > 0 && SelectedNode != null && parent.LabelEdit )
			{
				editingNode = (XmlTreeNode) SelectedNode;

				if ( editingNode.ConnectedXmlElement != null )
				{
					if ( !closingHandlerAssigned )
					{
						Form parentForm = FindForm();
						parentForm.Closing += new CancelEventHandler( parent.form_Closing );
						closingHandlerAssigned = true;
					}

					int height = editingNode.Bounds.Height;
					int width =  editingNode.Bounds.Width;
					int left = editingNode.Bounds.Left;
					int top = editingNode.Bounds.Top;

					editingNode.ExpandAll();

					if ( editingNode.ConnectedXmlElement.HasChildNodes && editingNode.ConnectedXmlElement.FirstChild.NodeType != XmlNodeType.Text )
					{
						height = editingNode.NextNode.Bounds.Bottom - editingNode.Bounds.Top;
						width = Width - left;
					}

					editBox = new TextBox();
					editBox.Multiline = true;
					editBox.BorderStyle = BorderStyle.FixedSingle;
					editBox.ScrollBars = ScrollBars.Both;
					editBox.Leave += new EventHandler( editBox_Leave );
					editBox.KeyUp += new KeyEventHandler( editBox_KeyUp );
					editBox.SetBounds( left, top, width, height );
					editingNode.RecurseSubNodes( editingNode.Parent );
					editBox.Text = editingNode.SelfAndChildren;
					Controls.Add( editBox );
					editBox.Focus();
				}
			}
		}
예제 #57
0
        // This constructor takes the reference node
        public TreeParent(TreeView view, XmlDocument doc, XmlTreeNode node)
        {
            //this.node = node;
            if (node != null) this.nodeInTree = ((TreeView)node.TreeView == view);
            this.view = view;
            this.doc = doc;
            this.parent = (XmlTreeNode)node.Parent;

            //this.xnode = node.Node;
            if (node.Parent != null) {
                this.xparent = ((XmlTreeNode)node.Parent).Node;
            } else if (node.Node != null) {
                this.xparent = node.Node.ParentNode;
            }
            if (this.xparent == null){
                this.xparent = this.doc;
            }
            originalParent = this.xparent;
            if (this.parent == null) {
                this.xparent = this.originalParent = this.doc;
            }
        }
예제 #58
0
        InsertNode xmlns; // generated prefix

        #endregion Fields

        #region Constructors

        public EditAttributeName(XmlAttribute attr, NodeLabelEditEventArgs e)
        {
            this.a = attr;
            this.node = e.Node as XmlTreeNode;
            this.p = this.a.OwnerElement;
            Debug.Assert(this.p != null);
            name = XmlHelpers.ParseName(this.p, e.Label, XmlNodeType.Attribute);
        }
예제 #59
0
        private void RecurseAndAssignNodes( XmlNode elem )
		{
			string attrs = string.Empty;
			XmlTreeNode addedNode = null;

			if ( elem.NodeType == XmlNodeType.Element )
			{
				foreach ( XmlAttribute attr in elem.Attributes )
				{
					attrs += " " + attr.Name + "=\"" + attr.Value + "\"";
				}
			}

			if ( elem.Equals( document.DocumentElement ) )
			{
				addedNode = new XmlTreeNode( "<" + elem.Name + attrs + ">", elem );
				Nodes.Add( addedNode );
				InnerXmlTreeView.CurrentNode = addedNode;
				Nodes.Add( new XmlTreeNode( "</" + elem.Name + ">", null ) );
			}
			else if ( elem.HasChildNodes && elem.ChildNodes[0].NodeType == XmlNodeType.Text )
			{
				addedNode = new XmlTreeNode( "<" + elem.Name + attrs + ">" + elem.InnerText + "</" + elem.Name + ">", elem );
				InnerXmlTreeView.CurrentNode.Nodes.Add( addedNode );
				InnerXmlTreeView.CurrentNode = addedNode;
			}
			else if ( elem is XmlElement && ( (XmlElement) elem ).IsEmpty )
			{
				addedNode = new XmlTreeNode( "<" + elem.Name + attrs + "/>", elem );
				InnerXmlTreeView.CurrentNode.Nodes.Add( addedNode );
				InnerXmlTreeView.CurrentNode = addedNode;
			}
			else
			{
				addedNode = new XmlTreeNode( "<" + elem.Name + attrs + ">", elem );
				InnerXmlTreeView.CurrentNode.Nodes.Add( addedNode );
				InnerXmlTreeView.CurrentNode = addedNode;
				InnerXmlTreeView.CurrentNode.Parent.Nodes.Add( new XmlTreeNode( "</" + elem.Name + ">", null ) );
			}

			foreach ( XmlNode child in elem.ChildNodes )
			{
				if ( child.NodeType == XmlNodeType.Element )
				{
					RecurseAndAssignNodes( child );
				}
				else if ( child.NodeType == XmlNodeType.Comment )
				{
					InnerXmlTreeView.CurrentNode.Nodes.Add( new XmlTreeNode( child.OuterXml, child ) );
				}
			}

			if ( InnerXmlTreeView.CurrentNode.Parent != null )
			{
				InnerXmlTreeView.CurrentNode = InnerXmlTreeView.CurrentNode.Parent;
			}
		}
예제 #60
0
        public void Insert(int pos, InsertPosition position, XmlTreeNode n, bool selectIt)
        {
            if (n.Node != null) {
                this.Insert(pos, position, n.Node);
            }

            int i = pos;
            if (position == InsertPosition.After) i++;
            if (parent == null) {
                view.Nodes.Insert(i, n);
            }
            else {
                parent.Nodes.Insert(i, n);
                if (selectIt && !parent.IsExpanded) {
                    parent.Expand(); // this will change image index of leaf nodes.
                }
            }
            n.Invalidate();
            if (selectIt) {
                view.SelectedNode = n;
            }
        }