/// <summary> /// Get the context menu associated with a metatree node /// </summary> /// <param name="node"></param> /// <returns></returns> public ContextMenuStrip GetSingleNodeContextMenu( MetaTreeNode node) { bool singleNodeSelected = true; return(GetNodeContextMenu(node, singleNodeSelected)); }
/// <summary> /// Get the context menu associated with a metatree node checking to see if multiple nodes are selected in the tree /// </summary> /// <param name="node"></param> /// <returns></returns> public ContextMenuStrip GetNodeContextMenu( MetaTreeNode node) { bool singleNodeSelected = QbContentsTree.SingleNodeSelected(); return(GetNodeContextMenu(node, singleNodeSelected)); }
private void DeleteFavoriteMenuItem_Click(object sender, EventArgs e) { SessionManager.LogCommandUsage("ContentsFavoritesDelete"); MetaTreeNode node = QbContentsTree.CurrentContentsMetaTreeNode; if (node == null) { return; } if (String.IsNullOrEmpty(node.Target)) { return; } DialogResult dr = MessageBoxMx.Show( "Are you sure you want to delete: '" + node.Label + "' ?", "Confirm Delete", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question); if (dr != DialogResult.Yes) { return; } SessionManager.Instance.MainMenuControl.DeleteFavorite(node); }
public void SetItemEnabledState( ToolStripMenuItem contentsCutQuery, ToolStripMenuItem contentsCopyQuery, ToolStripMenuItem contentsDeleteQuery, ToolStripMenuItem contentsRenameQuery) { foreach (TreeListNode node in ContentsTreeCtl.TreeList.Selection) { // if any node in the selection turns the menu to false, it stays false MetaTreeNode mtn = ContentsTreeCtl.GetMetaTreeNode(node); bool hasWriteAccess = Permissions.UserHasWriteAccess(SS.I.UserName, mtn.Target); if (contentsCutQuery.Enabled) { contentsCutQuery.Enabled = hasWriteAccess; } if (contentsDeleteQuery.Enabled) { contentsDeleteQuery.Enabled = hasWriteAccess; } if (contentsRenameQuery.Enabled) { contentsRenameQuery.Enabled = hasWriteAccess; } if (contentsCopyQuery.Enabled) { contentsCopyQuery.Enabled = (hasWriteAccess || (MetaTreeNode.IsUserObjectNodeType(mtn.Type) && !MetaTreeNode.IsLeafNodeType(mtn.Type))); } } }
/// <summary> /// Setup the form /// </summary> void Setup() { // Temporary surrogates for current and other temp lists that gets added to the preferred project TempNodes = new List <MetaTreeNode>(); foreach (TempCidList tcl in SS.I.TempCidLists) { UserObject uo = new UserObject(UserObjectType.CnList); uo.ParentFolder = SS.I.PreferredProjectId; uo.ParentFolderType = (uo.ParentFolder.ToUpper().StartsWith("FOLDER_")) ? FolderTypeEnum.User : FolderTypeEnum.System; uo.Id = tcl.Id; uo.Name = "*" + tcl.Name; uo.AccessLevel = UserObjectAccess.Private; uo.Count = tcl.Count; MetaTreeNode mtn = UserObjectTree.GetValidUserObjectTypeFolder(uo); mtn = UserObjectTree.AddObjectToTree(uo); ParentFolder = uo.ParentFolder; TempNodes.Add(mtn); } ListTree1.FillTree(UserObjectType.CnList); ListTree2.FillTree(UserObjectType.CnList); StatusMessage.Caption = ""; return; }
/// <summary> /// Get subtree starting at specified node /// </summary> /// <param name="rootNodeName"></param> /// <returns></returns> public MetaTreeNode GetAfsSubtree(string rootNodeName) { if (ServiceFacade.UseRemoteServices) { NativeMethodTransportObject resultObject = ServiceFacade.CallServiceMethod( ServiceCodes.MobiusMetaDataService, MobiusMetaDataService.GetAfsSubtree, new object[] { rootNodeName }); if (resultObject == null) { return(null); } MetaTreeNode mtn = resultObject.Value as MetaTreeNode; return(mtn); } else { if (MetaTreeFactoryInstance == null) { MetaTreeFactoryInstance = new Mobius.MetaFactoryNamespace.MetaTreeFactory(); } return(MetaTreeFactoryInstance.GetAfsSubtree(rootNodeName)); } }
internal void SetupMouseDown(ContentsTreeControl control, MouseEventArgs e) { ContentsTreeControl = control; CurrentContentsTreeMouseDownEvent = e; // save event info for later use MetaTreeNode mtn = control.GetMetaTreeNodeAt(e.Location, out CurrentContentsTreeListNode); if (mtn == null || mtn.Target == null) { return; } CurrentContentsMetaTreeNode = mtn; if (e.Button != MouseButtons.Right) { return; // all done if other than right button } if (mtn.Owner != SS.I.UserName) { return; // not allowed to do anything with another user's folder } if (mtn.Type == MetaTreeNodeType.Project || mtn.Type == MetaTreeNodeType.SystemFolder || mtn.Type == MetaTreeNodeType.UserFolder) // can only create a user folder under these { CreateUserFolderMenuItem.Visible = true; } else { CreateUserFolderMenuItem.Visible = false; } TreePopupMenu.Show(control, new System.Drawing.Point(e.X, e.Y)); return; }
/// <summary> /// Filter out the nodes that should be hidden from the user /// </summary> /// <param name="nodes"></param> public static void FilterNodesForUser(Dictionary <string, MetaTreeNode> nodes) { HashSet <string> allowedMts = ClientState.UserInfo?.RestrictedViewAllowedMetaTables; HashSet <string> blockedMts = ClientState.UserInfo?.GenerallyRestrictedMetatables; if (!nodes.ContainsKey("ROOT")) { return; } MetaTreeNode root = nodes["ROOT"]; try { if (blockedMts != null) { FilterRestrictedMetatableNodeForUser(root, blockedMts, nodes); } if (allowedMts != null) { FilterNodeForUser(root, allowedMts, nodes); } } catch (Exception ex) { throw new Exception(ex.Message, ex); } return; }
/// <summary> /// Handle special KeyDown events /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void CommandLine_KeyDown(object sender, KeyEventArgs e) { LastCommandLineControlKeyDownTime = DateTime.Now; if (CheckForEscapePressed(e)) { } else if (e.KeyCode == Keys.Enter) // command entered { e.Handled = true; ExecuteCommandLine(); return; #if false // experimental code that opens the currently selected item in the dropdown rather than doing a more-complete search int i1 = ListControl.SelectedIndex; if (ListControl.Visible && i1 >= 0 && // something selected i1 < MatchingContentsNodes.Count) // within list of nodes found in the latest quicksearch { MetaTreeNode mtn = MatchingContentsNodes[i1]; QbUtil.CallCurrentProcessTreeItemOperationMethod("Open", mtn.Target); HideQuickSearchPopup(); } else { ExecuteCommandLine(); // just execute the command line } return; #endif } }
private void ContentsTree_MouseDown(object sender, MouseEventArgs e) { CurrentContentsTreeMouseDownEvent = e; // save event info for later use MetaTreeNode mtn = QbContentsTreeCtl.GetMetaTreeNodeAt(QbContentsTreeCtl.PointToClient(Cursor.Position), out CurrentContentsTreeListNode); if (mtn == null || mtn.Target == null) { return; } CurrentContentsMetaTreeNode = mtn; if (e.Button != MouseButtons.Right) { return; // all done if other than right button } ContextMenuStrip ms = ContentsTreeContextMenus.GetNodeContextMenu(mtn); bool displayingSearchResults = (QbContentsTreeCtl.DisplayingAsList); ContentsTreeContextMenus.ShowInTreeMenuItem.Visible = displayingSearchResults; // if showing search results enable item to show in tree if (ms != null) { ms.Show(QbContentsTreeCtl, new System.Drawing.Point(e.X, e.Y)); } return; }
/// <summary> /// Insert the rows for a metatree node including its children into the metatree_nodes table /// Called via command: Update MetatreeNodeTable /// </summary> /// <param name="toks"></param> /// <param name="dao"></param> public static int InsertMetatreeNodeRows( MetaTreeNode mtn, DbCommandMx dao) { int insCnt = 0; foreach (MetaTreeNode cn in mtn.Nodes) { string names = ""; string values = ""; AddInsertColumn("parent_name", ref names, ref values, mtn.Name); AddInsertColumn("parent_label", ref names, ref values, mtn.Label); AddInsertColumn("parent_type", ref names, ref values, mtn.Type); AddInsertColumn("child_name", ref names, ref values, cn.Name); AddInsertColumn("child_label", ref names, ref values, cn.Label); AddInsertColumn("child_type", ref names, ref values, cn.Type); AddInsertColumn("child_size", ref names, ref values, cn.Size); AddInsertColumn("child_update_dt", ref names, ref values, cn.UpdateDateTime); string sql = "insert into " + MetatreeNodesTableName + " (" + names + ") " + "values (" + values + ")"; dao.Prepare(sql); dao.ExecuteNonReader(); insCnt++; } return(insCnt); }
private void ContentsTree_FocusedNodeChanged(object sender, EventArgs e) { ContentsTreeControl ctc = sender as ContentsTreeControl; if (ctc == null) { return; } MetaTreeNode node = ctc.GetMetaTreeNode(ctc.FocusedTreeListNode); if (node == null) { return; } if (String.IsNullOrEmpty(node.Target)) { } else if (node.Type == MetaTreeNodeType.MetaTable || node.Type == MetaTreeNodeType.Annotation || node.Type == MetaTreeNodeType.CalcField || node.Type == MetaTreeNodeType.CnList || // for open list node.Type == MetaTreeNodeType.Query) // for open condFormat { AddTableButton.Enabled = true; // set enabled flag for "Add >>>" (to query) button } else { AddTableButton.Enabled = false; } }
bool Save(bool prompt) { UserObject uo2; if (!IsValidCalcField()) { return(false); } if (!GetCalcFieldForm()) { return(false); } if (prompt) { uo2 = UserObjectSaveDialog.Show("Save Calculated Field Definition", UoIn); if (uo2 == null) { return(false); } } else { uo2 = UoIn.Clone(); } if (!UserObjectUtil.UserHasWriteAccess(uo2)) { // is the user authorized to save this? MessageBoxMx.ShowError("You are not authorized to save this calculated field"); return(false); } SessionManager.DisplayStatusMessage("Saving calculated field..."); string content = CalcField.Serialize(); uo2.Content = content; //need the name of the folder to which the object will be saved MetaTreeNode targetFolder = UserObjectTree.GetValidUserObjectTypeFolder(uo2); if (targetFolder == null) { MessageBoxMx.ShowError("Failed to save your calculated field."); return(false); } UserObjectDao.Write(uo2); string tName = "CALCFIELD_" + uo2.Id.ToString(); QbUtil.UpdateMetaTableCollection(tName); MainMenuControl.UpdateMruList(tName); string title = "Edit Calculated Field - " + uo2.Name; Text = title; UoIn = uo2.Clone(); // now becomes input object SessionManager.DisplayStatusMessage(""); return(true); }
/// <summary> /// Get a MetaTreeNode from either MetaTree or UserObjectTree /// searching both by name and target /// </summary> /// <param name="name"></param> /// <returns></returns> public static MetaTreeNode GetNode( string name) { MetaTreeNode mtn = MetaTree.GetNode(name); // check main tree first if (mtn == null) // check UserObject tree if not in main tree { mtn = UserObjectTree.GetNodeByName(name); } if (mtn == null) // try by main tree target { mtn = MetaTree.GetNodeByTarget(name); } if (mtn == null) // try UserObject tree target { mtn = UserObjectTree.GetNodeByTarget(name); } if (mtn != null) { return(mtn); } else { return(null); } }
/// <summary> /// Build the basic projects nodes without assay, library or other assoc info /// </summary> /// <param name="projectNodeName"></param> /// <param name="pNodes"></param> public void BuildAfsProjectNodes( string projectNodeName, Dictionary <string, MetaTreeNode> pNodes) { MetaTreeNode projNode, assayNode; List <AfsProject> projects = AfsProject.Select(projectNodeName); foreach (AfsProject p in projects) { if (!pNodes.ContainsKey(p.MbsProjectName)) // add project node { projNode = new MetaTreeNode(MetaTreeNodeType.Project); projNode.Name = projNode.Target = p.MbsProjectName; projNode.Label = p.ProjectLabel; projNode.Owner = "AFS"; pNodes[p.MbsProjectName] = projNode; if (Nodes.ContainsKey(p.MbsDhtFolderName)) // link to project parent if exists { projNode.Parent = Nodes[p.MbsDhtFolderName]; } } } return; }
/// <summary> /// Build assay nodes /// </summary> /// <param name="projectNodeName"></param> /// <param name="pNodes"></param> public void BuildAfsAssayNodes( string projectNodeName, Dictionary <string, MetaTreeNode> pNodes) { MetaTreeNode projNode, assayNode; List <AfsAssay> assays = AfsAssay.Select(projectNodeName); foreach (AfsAssay a in assays) { if (!pNodes.ContainsKey(a.MbsProjectName)) { continue; } projNode = pNodes[a.MbsProjectName]; assayNode = new MetaTreeNode(MetaTreeNodeType.MetaTable); assayNode.Name = a.MbsProjectName + "_" + a.AssayDb + "_" + a.AssayId; // assign unique name for project so label with assay use gets passed through assayNode.Target = a.AssayDb + "_" + a.AssayId; // target must match a metatable name assayNode.Label = a.AssayLabel; if (!Lex.IsNullOrEmpty(a.AssayUse)) // append any assay use { assayNode.Label += " (" + a.AssayUse + ")"; } assayNode.Owner = "AFS"; projNode.Nodes.Add(assayNode); } return; }
/// <summary> /// Pass the tree operation to the proper handler /// </summary> /// <param name="op"></param> /// <param name="args"></param> public static void TreeItemOperation( string op, string args) { if (Lex.Eq(op, "Open")) { MetaTreeNode mtn = MetaTreeNodeCollection.GetNode(args); if (mtn == null || !mtn.IsUserObjectType) { return; } Instance.ObjectName.Text = mtn.Label; Instance.SelectedNode = mtn; Instance.OK_Click(null, null); return; } else { Instance.ContentsTreeWithSearch.ContentsTreeCtl.FindInContents(args); } return; }
private void Setup() { InSetup = true; // Setup preferred project MetaTreeNode mtn = MetaTree.GetNode(SS.I.PreferredProjectId); // If not found create folder node // The following default folder node should exist in the MetaTree root node: // <child name = "default_folder" l = "Private Queries, Lists..." type = "project" item = "default_folder" /> if (mtn == null) { mtn = new MetaTreeNode(MetaTreeNodeType.Project); mtn.Name = mtn.Target = "DEFAULT_FOLDER"; mtn.Label = "Private Queries, Lists..."; } PreferredProject.Text = mtn.Label; PreferredProjectId = SS.I.PreferredProjectId; PreferredProjectChanged = false; // Setup default directory DefaultFolder.Text = ClientDirs.DefaultMobiusUserDocumentsFolder; // Setup zoom TableColumnZoom.ZoomPct = SS.I.TableColumnZoom; // Setup zoom controls GraphicsColumnZoom.ZoomPct = SS.I.GraphicsColumnZoom; ZoomChanged = false; ScrollGridByRow.Checked = !SS.I.ScrollGridByPixel; ScrollGridByPixel.Checked = SS.I.ScrollGridByPixel; InitialScrollGridByPixel = SS.I.ScrollGridByPixel; // Setup look and feel LookAndFeelOption.Properties.Items.Clear(); List <SkinInfoMx> skins = LookAndFeelMx.GetSkins(); foreach (SkinInfoMx si in skins) { LookAndFeelOption.Properties.Items.Add(new ImageComboBoxItem(si.ExternalName, si.ImageIndex)); } // Basic old styles (these cause dialog box to close for some reason) CurrentLookAndFeel = SS.I.UserIniFile.Read("LookAndFeel", "Blue"); LookAndFeelOption.Text = LookAndFeelMx.GetExternalSkinName(CurrentLookAndFeel); ChangingLookAndFeelModes = false; InSetup = false; FindRelatedCpdsInQuickSearch.Checked = SS.I.FindRelatedCpdsInQuickSearch; RestoreWindowsAtStartup.Checked = SS.I.RestoreWindowsAtStartup; return; }
private void FavoritesMenuItem_MouseDown(object sender, MouseEventArgs e) { ToolStripMenuItem mi = (ToolStripMenuItem)sender; MetaTreeNode node = mi.Tag as MetaTreeNode; UpdateAndRenderMruList(node); return; }
private void QueryListMenuItem_MouseDown(object sender, MouseEventArgs e) { ToolStripMenuItem mi = (ToolStripMenuItem)sender; MetaTreeNode node = mi.Tag as MetaTreeNode; SetMobiusSourceQuery(node); return; }
/// <summary> /// Save the SpotfireLink UserObject /// </summary> /// <param name="prompt"></param> /// <returns></returns> bool Save(bool prompt) { UserObject uo2; if (!IsValidSpotfireLink()) { return(false); } if (!GetSpotfireLinkForm()) { return(false); } if (prompt) { uo2 = UserObjectSaveDialog.Show("Save Spotfire link Definition", UoIn); if (uo2 == null) { return(false); } } else { uo2 = UoIn.Clone(); } uo2.Content = SpotfireViewProps.Serialize(); if (!UserObjectUtil.UserHasWriteAccess(uo2)) { // is the user authorized to save this? MessageBoxMx.ShowError("You are not authorized to save this Spotfire link"); return(false); } SessionManager.DisplayStatusMessage("Saving Spotfire link..."); //need the name of the folder to which the object will be saved MetaTreeNode targetFolder = UserObjectTree.GetValidUserObjectTypeFolder(uo2); if (targetFolder == null) { MessageBoxMx.ShowError("Failed to save your Spotfire link."); return(false); } UserObjectDao.Write(uo2); MainMenuControl.UpdateMruList(uo2.InternalName); string title = "Edit Spotfire Link - " + uo2.Name; Text = title; UoIn = uo2.Clone(); // now becomes input object SessionManager.DisplayStatusMessage(""); return(true); }
void UpdateAndRenderMruList(MetaTreeNode node) { if (node == null) { return; } MainMenu.UpdateMruList(node.Target, false); UpdateSelectedNodesSet(); SelectedNodes.Add(node.Target); RenderMruList(); }
/// <summary> /// Set visibility of menu items based on owner /// </summary> public void SetItemEnabledState( MetaTreeNode node, ToolStripMenuItem contentsCutQuery, ToolStripMenuItem contentsCopyQuery, ToolStripMenuItem contentsDeleteQuery, ToolStripMenuItem contentsRenameQuery) { contentsCutQuery.Enabled = contentsRenameQuery.Enabled = contentsDeleteQuery.Enabled = Permissions.UserHasWriteAccess(SS.I.UserName, node.Target); contentsCopyQuery.Enabled = true; // can alway copy if user can see it }
private void SelectFromContentsTreeMenuItem_Click(object sender, EventArgs e) { MetaTreeNode node = SelectFromContents.SelectSingleItem( "Select a Query", "Select a Query to use to use for data retrieval", MetaTreeNodeType.Query, null, false); SetMobiusSourceQuery(node); return; }
/// <summary> /// ContentsTreeItemSelected /// </summary> /// <param name="nodeTarget"></param> private void ContentsTreeItemSelected(string nodeTarget) { MetaTreeNode node = MetaTreeNodeCollection.GetNode(nodeTarget); if (node == null || !node.IsUserObjectType) { return; } ObjectName.Text = node.Name; // show node name SelectedNode = node; // The selected node }
void SetMobiusSourceQuery(MetaTreeNode node) { if (node == null || node.Type != MetaTreeNodeType.Query) { return; } SelectedQueryName = node.Label; SelectedQueryId = UserObject.ParseObjectIdFromInternalName(node.Name); SourceQueryComboBox.Text = SelectedQueryName; return; }
/// <summary> /// Add a MetaTableItem to the DataTable /// </summary> /// <param name="mtName"></param> void AddMetaTableItemToDataTable( string mtName) { MetaTreeNode mtn = MetaTreeNodeCollection.GetNode(mtName); if (mtn != null && mtn.IsFolderType) { return; // ignore folders } MetaTable mt = MetaTableCollection.Get(mtName); if (mt == null) { MessageBoxMx.ShowError("The selected item is not a recognized data table: " + mtName); return; } string allowedTypes = Qc.MetaColumn.TableMap; if (Lex.IsDefined(allowedTypes)) // see if supplied table is allowed { int ai; string[] sa = allowedTypes.Split(','); for (ai = 0; ai < sa.Length; ai++) { string allowedType = sa[ai]; if (Lex.IsUndefined(allowedType)) { continue; } if (Lex.Contains(mt.Name, allowedType.Trim())) { break; } } if (ai >= sa.Length) { MessageBoxMx.ShowError("The selected data table is not is not of a type that can be added here (" + allowedTypes + ")"); return; } } MetaTableItem i = new MetaTableItem(); i.ExternalName = mt.Label; i.InternalName = mt.Name; AddMetaTableItemToDataTable(i); return; }
public static void ShowProjectDescription( string projNodeName) { StreamWriter sw; string html, htmlFileName, flowScheme = "", flowSchemeFileName = ""; ProjectDescriptionDialog form = new ProjectDescriptionDialog(); MetaTreeNode mtn = MetaTree.GetNode(projNodeName); string title = (mtn != null ? mtn.Label : projNodeName); html = GetProjectHtmlDescription(projNodeName); if (Lex.IsNullOrEmpty(html)) { html = "Unable to retrieve project description"; } string[] sa = html.Split('\v'); if (sa.Length >= 2) // write flowscheme if exists { html = sa[0]; flowScheme = sa[1]; flowSchemeFileName = ClientDirs.TempDir + @"\FlowScheme" + UIMisc.PopupCount + ".xml"; sw = new StreamWriter(flowSchemeFileName); sw.Write(flowScheme); sw.Close(); } htmlFileName = ClientDirs.TempDir + @"\PopupHtml" + UIMisc.PopupCount + ".htm"; sw = new StreamWriter(htmlFileName); sw.Write(html); sw.Close(); UIMisc.PositionPopupForm(form); form.Text = title; form.Show(); form.WebBrowser.Navigate(htmlFileName); if (flowSchemeFileName != "") { form.OpenFlowSchemeDiagram(flowSchemeFileName); } form.Tabs.SelectedTabPageIndex = 0; UsageDao.LogEvent("ShowProject", projNodeName); return; }
private void ContentsTree_DoubleClick(object sender, EventArgs e) { MetaTreeNode node = QbContentsTreeCtl.FocusedMetaTreeNode; if (node == null || node.Target == null || node.Target == "") { return; } if (node.Type != MetaTreeNodeType.Url && node.Type != MetaTreeNodeType.Action) // if not immediate action node then post message { ExecuteNodeAction(node); } }
private void Combine_Click(object sender, EventArgs e) { ListLogicType op; MetaTreeNode mtn1 = GetListMetaTreeNode(ListTree1.TreeList.FocusedNode); if (mtn1 == null) { return; } MetaTreeNode mtn2 = GetListMetaTreeNode(ListTree2.TreeList.FocusedNode); if (mtn2 == null) { return; } if (ListAnd.Checked) { op = ListLogicType.Intersect; } else if (ListOr.Checked) { op = ListLogicType.Union; } else { op = ListLogicType.Difference; } int count = CidListDao.ExecuteListLogic(mtn1.Target, mtn2.Target, op); UserObject uo = CidListCommand.ReadCurrentListHeader(); TempCidList tl = CidListCommand.GetTempList("Current"); if (uo != null && tl != null) { tl.Count = uo.Count; tl.Id = uo.Id; } UpdateNode("Current"); // refresh the node to show the new count StatusMessage.Caption = count + " " + MetaTable.PrimaryKeyColumnLabel + "s have passed the combine and have been saved in *Current"; SessionManager.CurrentResultKeys = CidListCommand.ReadCurrentListRemote().ToStringList(); SessionManager.DisplayCurrentCount(); return; }