Exemple #1
0
        public void Init(VXmlCatalog dc, TreeNode tn)
        {
            g = new VSUIPanel(pnMain, "1");
            g.Load(Properties.Resources.CreateNode);

            CONT      = dc;
            TN        = tn;
            this.Text = "Create child node for " + tn.Text;
            cbNodeType.Items.Clear();

            PARENT      = CONT.GetNode(VSLib.ConvertStringToLong(tn.Name));
            n_type_code = DEFX.BR_CHILD_VALID_TYPE_CODES(PARENT.NodeTypeCode);
            n_type      = DEFX.BR_CREATE_VALID_TYPES(PARENT.NodeTypeCode);


            for (int i = 0; i < n_type.Length; i++)
            {
                if (n_type_code[i] != DEFX.NODE_TYPE_REFERENCE)
                {
                    cbNodeType.Items.Add(n_type[i]);
                }
            }

            g.AddControl("type", cbNodeType);
            g.AddControl("select", btnSelectFile);
            g.AddControl("ok", btnCreate);
            g.AddControl("cancel", btnCancel);

            g.Display();
        }
Exemple #2
0
        /// <summary>
        /// Edit node value
        /// </summary>
        private void ACTION_EditNode()
        {
            string v = "";

            if (CONTEXT_LIST_VIEW_ITEM != null)
            {
                v = CONTEXT_LIST_VIEW_ITEM.SubItems[2].Text;
            }
            else
            {
                v = CONTEXT_XML_NODE.Value;
            }

            string res = VSUILib.VSUICommonFunctions.InputBox("Edit node value", "Value", value: v, numeric: false);

            if (res == VSUILib.VSUICommonFunctions.CANCELLED)
            {
                return;
            }

            cont.Begin();

            if (CONTEXT_LIST_VIEW_ITEM == null)
            {
                CONTEXT_XML_NODE.Value = res;
                ACTION_SetTreeNodeName(CONTEXT_TREE_NODE, CONTEXT_XML_NODE);
            }
            else
            {
                if (MENU_NODE_SELECTED_TYPE == DEFX.GET_NODETYPE(DEFX.NODE_TYPE_ATTRIBUTE))
                {
                    CONTEXT_XML_NODE.SetAttribute(MENU_NODE_SELECTED_NAME, res);
                }
                else if (MENU_NODE_SELECTED_TYPE == DEFX.GET_NODETYPE(DEFX.NODE_TYPE_COMMENT))
                {
                    VXmlComment cnode = CONTEXT_XML_NODE.GetCommentNode(MENU_NODE_SELECTED_NAME);
                    cnode.Value = res;
                }
                else if (MENU_NODE_SELECTED_TYPE == DEFX.GET_NODETYPE(DEFX.NODE_TYPE_TEXT))
                {
                    VXmlText t = CONTEXT_XML_NODE.GetTextNode(MENU_NODE_SELECTED_NAME);
                    t.Value = res;
                }
                else if (MENU_NODE_SELECTED_TYPE == DEFX.GET_NODETYPE(DEFX.NODE_TYPE_TAG))
                {
                    VXmlTag t  = CONTEXT_XML_NODE.GetTagNode(MENU_NODE_SELECTED_NAME);
                    string  tv = t.Value;
                    if (tv != res)
                    {
                        CONTEXT_XML_NODE.RemoveTag(tv);
                        CONTEXT_XML_NODE.SetTag(res);
                    }
                }
                SELECT_Node(true, CONTEXT_TREE_NODE);
            }
            cont.Commit();
        }
Exemple #3
0
        private void cbNodeType_SelectedIndexChanged(object sender, EventArgs e)
        {
            short type = n_type_code[cbNodeType.SelectedIndex];

            VSUIControl[] controls = new VSUIControl[5];
            controls[0]         = new VSUIControl("select");
            controls[0].Visible = (type == DEFX.NODE_TYPE_CONTENT);

            controls[1]         = new VSUIControl("file");
            controls[1].Visible = (type == DEFX.NODE_TYPE_CONTENT);

            controls[2]         = new VSUIControl("title");
            controls[2].Visible = (type == DEFX.NODE_TYPE_CONTENT);

            controls[3]         = new VSUIControl("value");
            controls[3].Caption = (type == DEFX.NODE_TYPE_CATALOG) ? "Title:" : "Value:";

            controls[4] = new VSUIControl("name");

            if ((type == DEFX.NODE_TYPE_CONTENT) | (type == DEFX.NODE_TYPE_COMMENT) | (type == DEFX.NODE_TYPE_TEXT) | (type == DEFX.NODE_TYPE_TAG))
            {
                controls[4].Value = DEFX.GET_NODETYPE(type);
            }
            else
            {
                controls[4].Value = "";
            }

            controls[4].Enabled = (controls[4].Value == "");

            g.Set(controls);

            if (!controls[4].Enabled)
            {
                controls[4].Value = "";
            }
            else
            {
                g.SetFocus("name");
            }

            btnCreate.Enabled = (cbNodeType.SelectedIndex >= 0);
        }
Exemple #4
0
        /// <summary>
        /// Delete Node and all subtree
        /// </summary>
        private void ACTION_DeleteNode()
        {
            string nm = (CONTEXT_LIST_VIEW_ITEM == null) ? CONTEXT_TREE_NODE.Text : (CONTEXT_LIST_VIEW_ITEM.SubItems[1].Text + " {" + CONTEXT_LIST_VIEW_ITEM.SubItems[2].Text + "}");

            if (MessageBox.Show("Do you want to proceed and delete node '" + nm + "'?", "Delete node", MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.Yes)
            {
                if (CONTEXT_LIST_VIEW_ITEM == null)
                {
                    VXmlNode NodeToDelete = cont.GetNode(VSLib.ConvertStringToLong(CONTEXT_TREE_NODE.Name));
                    VXmlNode pnode        = NodeToDelete.ParentNode;
                    if (CONTEXT_REF_NODE == null)
                    {
                        if (pnode == null)
                        {
                            if (MessageBox.Show("You are about to delete root node." + "\r\n" +
                                                "Storage will be closed in this case after deletion." + "\r\n" +
                                                "Do you want to proceed?", "Delete node", MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.No)
                            {
                                return;
                            }
                        }
                    }

                    tsNode.Text = "Deleting node ...";
                    Application.DoEvents();
                    Cursor.Current = Cursors.WaitCursor;
                    cont.Begin();
                    try
                    {
                        if (CONTEXT_LIST_VIEW_ITEM != null)
                        {
                            string rid = NodeToDelete.ID;
                            NodeToDelete.Remove();
                            CONTEXT_LIST_VIEW_ITEM.Remove();
                            for (int i = 0; i < CONTEXT_TREE_NODE.Nodes.Count; i++)
                            {
                                if (CONTEXT_TREE_NODE.Nodes[i].Name == rid)
                                {
                                    CONTEXT_TREE_NODE.Nodes[i].Remove();
                                    break;
                                }
                            }
                        }
                        else
                        {
                            if (CONTEXT_REF_NODE == null)
                            {
                                CONTEXT_XML_NODE.Remove();
                                if (pnode == null)
                                {
                                    Cursor.Current = Cursors.Default;
                                    ACTION_CloseStorage();
                                    return;
                                }
                            }
                            else
                            {
                                CONTEXT_REF_NODE.Remove();
                            }

                            tvCat.SelectedNode = CONTEXT_TREE_NODE.Parent;
                            CONTEXT_TREE_NODE.Remove();
                        }
                    }
                    catch (VXmlException e1)
                    {
                        MessageBox.Show(e1.Message, "Error", MessageBoxButtons.OK);
                    }
                    cont.Commit();
                    tsNode.Text = "";
                    SELECT_Node();
                    Cursor.Current = Cursors.Default;
                }
                else
                {
                    if (MENU_NODE_SELECTED_TYPE == DEFX.GET_NODETYPE(DEFX.NODE_TYPE_ATTRIBUTE))
                    {
                        CONTEXT_XML_NODE.RemoveAttribute(MENU_NODE_SELECTED_NAME);
                    }
                    else if (MENU_NODE_SELECTED_TYPE == DEFX.GET_NODETYPE(DEFX.NODE_TYPE_COMMENT))
                    {
                        CONTEXT_XML_NODE.RemoveComment(MENU_NODE_SELECTED_NAME);
                    }
                    else if (MENU_NODE_SELECTED_TYPE == DEFX.GET_NODETYPE(DEFX.NODE_TYPE_TEXT))
                    {
                        CONTEXT_XML_NODE.RemoveText(MENU_NODE_SELECTED_NAME);
                    }
                    //else // Tag
                    //    CONTEXT_XML_NODE.RemoveTag.RemoveTagByName(MENU_NODE_SELECTED_NAME);

                    SELECT_Node(true, CONTEXT_TREE_NODE);
                }
            }
        }
Exemple #5
0
        /// <summary>
        /// Show/hide buttons and menu items
        /// </summary>
        private void SHOW_Buttons()
        {
            mOpenStorage.Enabled   = mCreateStorage.Enabled = !OPENED;
            mDeleteStorage.Enabled = mCloseStorage.Enabled = OPENED;

            mnuCopyToClip.Enabled = mnuDownloadContent.Visible = mnuSaveXML.Visible = mnuSaveXMLWithContent.Visible = false;
            mnuViewXML.Visible    = mnuLoadXML.Visible = false;

            mnuCreate.Visible = mCreate.Enabled = false;

            mnuDelete.Visible = mDelete.Enabled = false;

            mnuEdit.Visible = mEdit.Enabled = false;

            mnuCheckIn.Visible = mCheckIn.Enabled = false;

            mnuCheckOut.Visible = mCheckOut.Enabled = false;

            mnuSnap.Visible = mSnap.Enabled = false;

            mnuUndoCheckOut.Visible = mUndoCheckOut.Enabled = false;

            mnuRenameNode.Visible = mnuLookUp.Visible = false;

            mnuSearch.Enabled = mnuSearchTextBox.Enabled = false;

            if (OPENED)
            {
                mnuSearch.Enabled = mnuSearchTextBox.Enabled = true;
                if (CONTEXT_LIST_VIEW_ITEM == null)
                {
                    VXmlNode n = cont.GetNode(VSLib.ConvertStringToLong(CONTEXT_TREE_NODE.Name));

                    mnuCheckIn.Visible = mCheckIn.Enabled = (CONTEXT_LIST_VIEW_ITEM == null) & DEFX.BR_CHARGEIN_IS_VALID_TYPE(n.NodeTypeCode);

                    mnuCheckOut.Visible = mSnap.Enabled = mnuSnap.Visible = mCheckOut.Enabled = (CONTEXT_LIST_VIEW_ITEM == null) & (DEFX.BR_CHARGEOUT_IS_VALID_TYPE(n.NodeTypeCode) & (!n.IsChargedOut));

                    mnuUndoCheckOut.Visible = mUndoCheckOut.Enabled = (CONTEXT_LIST_VIEW_ITEM == null) & ((n.IsChargedOut) & (n.GUID != ""));

                    mnuCreate.Visible = mCreate.Enabled = (CONTEXT_LIST_VIEW_ITEM == null) & (!n.IsChargedOut) & (DEFX.BR_CHILD_VALID_TYPE_CODES(n.NodeTypeCode).Length > 0);

                    mnuEdit.Visible = mEdit.Enabled = !n.IsChargedOut;

                    mnuDelete.Visible = mDelete.Enabled = (!n.IsChargedOut);

                    mnuCopyToClip.Enabled = true;

                    mnuDownloadContent.Visible = (n.NodeTypeCode == DEFX.NODE_TYPE_CONTENT);

                    mnuSaveXML.Visible = mnuLoadXML.Visible = mnuSaveXMLWithContent.Visible = mnuViewXML.Visible = (CONTEXT_LIST_VIEW_ITEM == null) & DEFX.BR_XML_IS_VALID_TYPE(n.NodeTypeCode);

                    mnuRenameNode.Visible = DEFX.BR_NODE_RENAME(n.NodeTypeCode);

                    mnuLookUp.Visible = (n.NodeTypeCode == DEFX.NODE_TYPE_REFERENCE);
                }
                else
                {
                    mnuDelete.Visible     = mDelete.Enabled = mnuEdit.Visible = mEdit.Enabled = true;
                    mnuCopyToClip.Enabled = true;
                }
            }
        }
Exemple #6
0
        private void btnCreate_Click(object sender, EventArgs e)
        {
            short node_type = 0;

            string V = "";
            string N = "";

            for (int i = 0; i < n_type.Length; i++)
            {
                if (n_type[i] == cbNodeType.Text)
                {
                    node_type = n_type_code[i];
                    break;
                }
            }

            RC = 0;
            g.Read();
            N = g.GetValue("name");
            V = g.GetValue("value");

            if ((N == "") & DEFX.BR_NODE_NEED_NAME(node_type))
            {
                MessageBox.Show("Name field is not defined", "Error");
            }
            else if ((node_type == DEFX.NODE_TYPE_CONTENT) &
                     ((g.GetValue("file") == "") | (g.GetValue("title") == "")))
            {
                MessageBox.Show("File name or Title not defined", "Error");
            }
            else
            {
                VXmlNode node = CONT.GetNode(VSLib.ConvertStringToLong(TN.Name));
                try
                {
                    if (node_type == DEFX.NODE_TYPE_CONTENT)
                    {
                        VXmlContent c = node.CreateContent(g.GetValue("file"));
                    }
                    else if (node_type == DEFX.NODE_TYPE_CATALOG)
                    {
                        VXmlCatalog cat    = (VXmlCatalog)CONT.GetNode(node.Id);
                        VXmlCatalog newcat = cat.CreateCatalog(g.GetValue("name"));
                        if (V != "")
                        {
                            newcat.Value = V;
                        }
                    }
                    else if (node_type == DEFX.NODE_TYPE_DOCUMENT)
                    {
                        VXmlCatalog  cat = (VXmlCatalog)CONT.GetNode(node.Id);
                        VXmlDocument d   = cat.CreateDocument(N);
                        if (V != "")
                        {
                            d.Value = V;
                        }
                    }
                    else if (node_type == DEFX.NODE_TYPE_ATTRIBUTE)
                    {
                        node.SetAttribute(N, V);
                    }
                    else if (node_type == DEFX.NODE_TYPE_COMMENT)
                    {
                        node.CreateComment(V);
                    }
                    else if (node_type == DEFX.NODE_TYPE_TEXT)
                    {
                        node.CreateTextNode(V);
                    }
                    else if (node_type == DEFX.NODE_TYPE_TAG)
                    {
                        node.SetTag(V.Trim());
                    }
                    else if (node_type == DEFX.NODE_TYPE_ELEMENT)
                    {
                        VXmlElement el = node.CreateElement(N, V);
                    }
                    else
                    {
                        MessageBox.Show("Invalid node type '" + DEFX.GET_NODETYPE(node_type) + "'", "Error");
                        RC = 1;
                    }
                }
                catch (VXmlException ex)
                {
                    MessageBox.Show(ex.Message, "Error");
                    RC = 1;
                }
                if (RC == 0)
                {
                    this.Close();
                }
            }
        }