private void tvConnections_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e) { try { ShowHideTreeContextMenuItems(tvConnections.SelectedNode); tvConnections.SelectedNode = e.Node; if (e.Button == MouseButtons.Left) { if (Settings.Default.SingleClickOnConnectionOpensIt && (ConnectionTreeNode.GetNodeType(e.Node) == TreeNodeType.Connection | ConnectionTreeNode.GetNodeType(e.Node) == TreeNodeType.PuttySession)) { Runtime.OpenConnection(); } if (Settings.Default.SingleClickSwitchesToOpenConnection && ConnectionTreeNode.GetNodeType(e.Node) == TreeNodeType.Connection) { Runtime.SwitchToOpenConnection((ConnectionInfo)e.Node.Tag); } } } catch (Exception ex) { Runtime.MessageCollector.AddExceptionStackTrace("tvConnections_NodeMouseClick (UI.Window.ConnectionTreeWindow) failed", ex); } }
public static void Prot_Event_Closed(object sender) { try { ProtocolBase Prot = (ProtocolBase)sender; MessageCollector.AddMessage(MessageClass.InformationMsg, Language.strConnenctionCloseEvent, true); MessageCollector.AddMessage(MessageClass.ReportMsg, string.Format(Language.strConnenctionClosedByUser, Prot.InterfaceControl.Info.Hostname, Prot.InterfaceControl.Info.Protocol.ToString(), Environment.UserName)); Prot.InterfaceControl.Info.OpenConnections.Remove(Prot); if (Prot.InterfaceControl.Info.OpenConnections.Count < 1 && Prot.InterfaceControl.Info.IsQuickConnect == false) { ConnectionTreeNode.SetNodeImage(Prot.InterfaceControl.Info.TreeNode, TreeImageType.ConnectionClosed); } if (Prot.InterfaceControl.Info.PostExtApp != "") { ExternalTool extA = GetExtAppByName(Prot.InterfaceControl.Info.PostExtApp); if (extA != null) { extA.Start(Prot.InterfaceControl.Info); } } } catch (Exception ex) { MessageCollector.AddMessage(MessageClass.ErrorMsg, Language.strConnenctionCloseEventFailed + Environment.NewLine + ex.Message, true); } }
private void tvConnections_AfterSelect(object sender, TreeViewEventArgs e) { try { if ((ConnectionTreeNode.GetNodeType(e.Node) == TreeNodeType.Connection) || (ConnectionTreeNode.GetNodeType(e.Node) == TreeNodeType.PuttySession)) { Windows.configForm.SetPropertyGridObject(e.Node.Tag); } else if (ConnectionTreeNode.GetNodeType(e.Node) == TreeNodeType.Container) { Windows.configForm.SetPropertyGridObject((ContainerInfo)e.Node.Tag); } else if ((ConnectionTreeNode.GetNodeType(e.Node) == TreeNodeType.Root) || (ConnectionTreeNode.GetNodeType(e.Node) == TreeNodeType.PuttyRoot)) { Windows.configForm.SetPropertyGridObject(e.Node.Tag); } else { return; } Windows.configForm.pGrid_SelectedObjectChanged(); ShowHideTreeContextMenuItems(e.Node); Runtime.LastSelected = ConnectionTreeNode.GetConstantID(e.Node); } catch (Exception ex) { Runtime.MessageCollector.AddExceptionStackTrace("tvConnections_AfterSelect (UI.Window.ConnectionTreeWindow) failed", ex); } }
private void AddContainerToList(XmlNode xmlNode, TreeNode treeNode) { var containerInfo = new ContainerInfo(); if (treeNode.Parent != null) { if (ConnectionTreeNode.GetNodeType(treeNode.Parent) == TreeNodeType.Container) { containerInfo.Parent = (ContainerInfo)treeNode.Parent.Tag; } } _previousContainer = containerInfo; //NEW containerInfo.TreeNode = treeNode; containerInfo.Name = xmlNode.Attributes["Name"].Value; if (_confVersion >= 0.8) { containerInfo.IsExpanded = xmlNode.Attributes["Expanded"].Value == "True"; } var connectionInfo = _confVersion >= 0.9 ? GetConnectionInfoFromXml(xmlNode) : new ConnectionInfo(); connectionInfo.Parent = containerInfo; connectionInfo.IsContainer = true; containerInfo.ConnectionInfo = connectionInfo; ContainerList.Add(containerInfo); treeNode.Tag = containerInfo; treeNode.ImageIndex = (int)TreeImageType.Container; treeNode.SelectedImageIndex = (int)TreeImageType.Container; }
public static void OpenConnection(ConnectionInfo.Force Force) { try { if (Windows.treeForm.tvConnections.SelectedNode.Tag == null) { return; } if (ConnectionTreeNode.GetNodeType(ConnectionTree.SelectedNode) == TreeNodeType.Connection | ConnectionTreeNode.GetNodeType(ConnectionTree.SelectedNode) == TreeNodeType.PuttySession) { OpenConnection((ConnectionInfo)Windows.treeForm.tvConnections.SelectedNode.Tag, Force); } else if (ConnectionTreeNode.GetNodeType(ConnectionTree.SelectedNode) == TreeNodeType.Container) { foreach (TreeNode tNode in ConnectionTree.SelectedNode.Nodes) { if (ConnectionTreeNode.GetNodeType(tNode) == TreeNodeType.Connection | ConnectionTreeNode.GetNodeType(ConnectionTree.SelectedNode) == TreeNodeType.PuttySession) { if (tNode.Tag != null) { OpenConnection((ConnectionInfo)tNode.Tag, Force); } } } } } catch (Exception ex) { MessageCollector.AddMessage(MessageClass.ErrorMsg, Language.strConnectionOpenFailed + Environment.NewLine + ex.Message); } }
private static void AddNodeToMenu(TreeNodeCollection treeNodeCollection, ToolStripDropDownItem toolStripMenuItem) { try { foreach (TreeNode treeNode in treeNodeCollection) { var menuItem = new ToolStripMenuItem(); menuItem.Text = treeNode.Text; menuItem.Tag = treeNode; if (ConnectionTreeNode.GetNodeType(treeNode) == TreeNodeType.Container) { menuItem.Image = Resources.Folder; menuItem.Tag = treeNode.Tag; toolStripMenuItem.DropDownItems.Add(menuItem); AddNodeToMenu(treeNode.Nodes, menuItem); } else if (ConnectionTreeNode.GetNodeType(treeNode) == TreeNodeType.Connection | ConnectionTreeNode.GetNodeType(treeNode) == TreeNodeType.PuttySession) { menuItem.Image = Windows.treeForm.imgListTree.Images[treeNode.ImageIndex]; menuItem.Tag = treeNode.Tag; toolStripMenuItem.DropDownItems.Add(menuItem); } menuItem.MouseUp += ConnectionsMenuItem_MouseUp; } } catch (Exception ex) { Runtime.MessageCollector.AddExceptionMessage("frmMain.AddNodeToMenu() failed", ex, MessageClass.ErrorMsg, true); } }
private static void tvConnections_NodeMouseDoubleClick(object sender, TreeNodeMouseClickEventArgs e) { if (ConnectionTreeNode.GetNodeType(ConnectionTree.SelectedNode) == TreeNodeType.Connection | ConnectionTreeNode.GetNodeType(ConnectionTree.SelectedNode) == TreeNodeType.PuttySession) { Runtime.OpenConnection(); } }
private static void ImportFileOrGroup(XmlNode xmlNode, TreeNode parentTreeNode) { XmlNode propertiesNode = xmlNode.SelectSingleNode("./properties"); string name = propertiesNode.SelectSingleNode("./name").InnerText; TreeNode treeNode = new TreeNode(name); parentTreeNode.Nodes.Add(treeNode); ContainerInfo containerInfo = new ContainerInfo(); containerInfo.TreeNode = treeNode; containerInfo.Name = name; ConnectionInfo connectionInfo = ConnectionInfoFromXml(propertiesNode); connectionInfo.Parent = containerInfo; connectionInfo.IsContainer = true; containerInfo.CopyFrom(connectionInfo); // We can only inherit from a container node, not the root node or connection nodes if (ConnectionTreeNode.GetNodeType(parentTreeNode) == TreeNodeType.Container) { containerInfo.Parent = (ContainerInfo)parentTreeNode.Tag; } else { connectionInfo.Inheritance.DisableInheritance(); } treeNode.Name = name; treeNode.Tag = containerInfo; treeNode.ImageIndex = (int)TreeImageType.Container; treeNode.SelectedImageIndex = (int)TreeImageType.Container; foreach (XmlNode childNode in xmlNode.SelectNodes("./group|./server")) { switch (childNode.Name) { case "group": ImportFileOrGroup(childNode, treeNode); break; case "server": ImportServer(childNode, treeNode); break; } } containerInfo.IsExpanded = bool.Parse(propertiesNode.SelectSingleNode("./expanded").InnerText); if (containerInfo.IsExpanded) { treeNode.Expand(); } Runtime.ContainerList.Add(containerInfo); }
private static void ImportComputers(string ldapPath, TreeNode parentTreeNode) { try { const string ldapFilter = "(objectClass=computer)"; var ldapSearcher = new DirectorySearcher(); var ldapResults = default(SearchResultCollection); var ldapResult = default(SearchResult); ldapSearcher.SearchRoot = new DirectoryEntry(ldapPath); ldapSearcher.PropertiesToLoad.AddRange(new[] { "securityEquals", "cn" }); ldapSearcher.Filter = ldapFilter; ldapSearcher.SearchScope = SearchScope.OneLevel; ldapResults = ldapSearcher.FindAll(); foreach (SearchResult tempLoopVar_ldapResult in ldapResults) { ldapResult = tempLoopVar_ldapResult; var with_2 = ldapResult.GetDirectoryEntry(); var displayName = Convert.ToString(with_2.Properties["cn"].Value); var description = Convert.ToString(with_2.Properties["Description"].Value); var hostName = Convert.ToString(with_2.Properties["dNSHostName"].Value); var treeNode = ConnectionTreeNode.AddNode(TreeNodeType.Connection, displayName); var connectionInfo = new ConnectionInfo(); var inheritanceInfo = new ConnectionInfoInheritance(connectionInfo); inheritanceInfo.TurnOnInheritanceCompletely(); inheritanceInfo.Description = false; if (parentTreeNode.Tag is ContainerInfo) { connectionInfo.Parent = (ContainerInfo)parentTreeNode.Tag; } connectionInfo.Inheritance = inheritanceInfo; connectionInfo.Name = displayName; connectionInfo.Hostname = hostName; connectionInfo.Description = description; connectionInfo.TreeNode = treeNode; treeNode.Name = displayName; treeNode.Tag = connectionInfo; //set the nodes tag to the conI //add connection to connections Runtime.ConnectionList.Add(connectionInfo); parentTreeNode.Nodes.Add(treeNode); } } catch (Exception ex) { Runtime.MessageCollector.AddExceptionMessage("Config.Import.ActiveDirectory.ImportComputers() failed.", ex, logOnly: true); } }
private static TreeNode GetContainerTreeNode(TreeNode treeNode) { if ((ConnectionTreeNode.GetNodeType(treeNode) == TreeNodeType.Root) || (ConnectionTreeNode.GetNodeType(treeNode) == TreeNodeType.Container)) { return(treeNode); } if (ConnectionTreeNode.GetNodeType(treeNode) == TreeNodeType.Connection) { return(treeNode.Parent); } return(null); }
private void tsExtAppEntry_Click(object sender, EventArgs e) { var extA = (ExternalTool)((ToolStripButton)sender).Tag; if (ConnectionTreeNode.GetNodeType(ConnectionTree.SelectedNode) == TreeNodeType.Connection | ConnectionTreeNode.GetNodeType(ConnectionTree.SelectedNode) == TreeNodeType.PuttySession) { extA.Start((ConnectionInfo)ConnectionTree.SelectedNode.Tag); } else { extA.Start(); } }
public void AddFolder() { try { TreeNode newNode = ConnectionTreeNode.AddNode(TreeNodeType.Container); ContainerInfo newContainerInfo = new ContainerInfo(); newContainerInfo.CopyFrom(DefaultConnectionInfo.Instance); newNode.Tag = newContainerInfo; newContainerInfo.TreeNode = newNode; TreeNode selectedNode = ConnectionTree.SelectedNode; TreeNode parentNode; if (selectedNode == null) { parentNode = tvConnections.Nodes[0]; } else { if (ConnectionTreeNode.GetNodeType(selectedNode) == TreeNodeType.Connection) { parentNode = selectedNode.Parent; } else { parentNode = selectedNode; } } newContainerInfo.Name = newNode.Text; // We can only inherit from a container node, not the root node or connection nodes if (ConnectionTreeNode.GetNodeType(parentNode) == TreeNodeType.Container) { newContainerInfo.Parent = (ContainerInfo)parentNode.Tag; } else { newContainerInfo.Inheritance.DisableInheritance(); } Runtime.ContainerList.Add(newContainerInfo); parentNode.Nodes.Add(newNode); tvConnections.SelectedNode = newNode; tvConnections.SelectedNode.BeginEdit(); } catch (Exception ex) { Runtime.MessageCollector.AddExceptionStackTrace(Language.strErrorAddFolderFailed, ex); } }
private static void StartExternalApp(Tools.ExternalTool externalTool) { try { if (ConnectionTreeNode.GetNodeType(ConnectionTree.SelectedNode) == TreeNodeType.Connection | ConnectionTreeNode.GetNodeType(ConnectionTree.SelectedNode) == TreeNodeType.PuttySession) { externalTool.Start((ConnectionInfo)ConnectionTree.SelectedNode.Tag); } } catch (Exception ex) { Runtime.MessageCollector.AddExceptionStackTrace("cMenTreeToolsExternalAppsEntry_Click failed (UI.Window.ConnectionTreeWindow)", ex); } }
private static void StartExternalApp(Tools.ExternalTool externalTool) { try { if (ConnectionTreeNode.GetNodeType(ConnectionTree.SelectedNode) == TreeNodeType.Connection | ConnectionTreeNode.GetNodeType(ConnectionTree.SelectedNode) == TreeNodeType.PuttySession) { externalTool.Start((ConnectionInfo)ConnectionTree.SelectedNode.Tag); } } catch (Exception ex) { Runtime.MessageCollector.AddMessage(MessageClass.ErrorMsg, "cMenTreeToolsExternalAppsEntry_Click failed (UI.Window.ConnectionTreeWindow)" + Environment.NewLine + ex.Message, true); } }
public static void Import(string fileName, TreeNode parentTreeNode) { var name = Path.GetFileNameWithoutExtension(fileName); var treeNode = new TreeNode(name); parentTreeNode.Nodes.Add(treeNode); var containerInfo = new ContainerInfo { TreeNode = treeNode, Name = name }; var connectionInfo = new ConnectionInfo(); connectionInfo.Inheritance = new ConnectionInfoInheritance(connectionInfo); connectionInfo.Name = name; connectionInfo.TreeNode = treeNode; connectionInfo.Parent = containerInfo; connectionInfo.IsContainer = true; containerInfo.ConnectionInfo = connectionInfo; // We can only inherit from a container node, not the root node or connection nodes if (ConnectionTreeNode.GetNodeType(parentTreeNode) == TreeNodeType.Container) { containerInfo.Parent = (ContainerInfo)parentTreeNode.Tag; } else { connectionInfo.Inheritance.DisableInheritance(); } treeNode.Name = name; treeNode.Tag = containerInfo; treeNode.ImageIndex = (int)TreeImageType.Container; treeNode.SelectedImageIndex = (int)TreeImageType.Container; var connectionsLoad = new ConnectionsLoader { ConnectionFileName = fileName, RootTreeNode = treeNode, ConnectionList = Runtime.ConnectionList, ContainerList = Runtime.ContainerList }; connectionsLoad.LoadConnections(true); Runtime.ContainerList.Add(containerInfo); }
public void AddConnection() { try { if (tvConnections.SelectedNode == null) { tvConnections.SelectedNode = tvConnections.Nodes[0]; } TreeNode newTreeNode = ConnectionTreeNode.AddNode(TreeNodeType.Connection); if (newTreeNode == null) { Runtime.MessageCollector.AddMessage(MessageClass.ErrorMsg, "UI.Window.Tree.AddConnection() failed." + Environment.NewLine + "mRemoteNG.Tree.Node.AddNode() returned Nothing.", true); return; } TreeNode containerNode = tvConnections.SelectedNode; if (ConnectionTreeNode.GetNodeType(containerNode) == TreeNodeType.Connection) { containerNode = containerNode.Parent; } ConnectionInfo newConnectionInfo = new ConnectionInfo(); newConnectionInfo.CopyFrom(DefaultConnectionInfo.Instance); if (ConnectionTreeNode.GetNodeType(containerNode) == TreeNodeType.Root) { newConnectionInfo.Inheritance.DisableInheritance(); } else { newConnectionInfo.Parent = (ContainerInfo)containerNode.Tag; } newConnectionInfo.TreeNode = newTreeNode; newTreeNode.Tag = newConnectionInfo; Runtime.ConnectionList.Add(newConnectionInfo); containerNode.Nodes.Add(newTreeNode); tvConnections.SelectedNode = newTreeNode; tvConnections.SelectedNode.BeginEdit(); } catch (Exception ex) { Runtime.MessageCollector.AddExceptionStackTrace("UI.Window.Tree.AddConnection() failed.", ex); } }
public static void Import(string ldapPath, TreeNode parentTreeNode) { try { var treeNode = ConnectionTreeNode.AddNode(TreeNodeType.Container); var containerInfo = new ContainerInfo(); containerInfo.TreeNode = treeNode; containerInfo.ConnectionInfo = new ConnectionInfo(containerInfo); var name = ""; var match = Regex.Match(ldapPath, "ou=([^,]*)", RegexOptions.IgnoreCase); if (match.Success) { name = match.Groups[1].Captures[0].Value; } else { name = Language.strActiveDirectory; } containerInfo.Name = name; // We can only inherit from a container node, not the root node or connection nodes if (ConnectionTreeNode.GetNodeType(parentTreeNode) == TreeNodeType.Container) { containerInfo.Parent = (ContainerInfo)parentTreeNode.Tag; } else { containerInfo.ConnectionInfo.Inheritance.DisableInheritance(); } treeNode.Text = name; treeNode.Name = name; treeNode.Tag = containerInfo; Runtime.ContainerList.Add(containerInfo); ImportComputers(ldapPath, treeNode); parentTreeNode.Nodes.Add(treeNode); } catch (Exception ex) { Runtime.MessageCollector.AddExceptionMessage("Config.Import.ActiveDirectory.Import() failed.", ex, logOnly: true); } }
private static void SetTreeNodeImages(ConnectionInfo ConnectionInfo) { if (ConnectionInfo.IsQuickConnect == false) { if (ConnectionInfo.Protocol != ProtocolType.IntApp) { ConnectionTreeNode.SetNodeImage(ConnectionInfo.TreeNode, TreeImageType.ConnectionOpen); } else { ExternalTool extApp = GetExtAppByName(ConnectionInfo.ExtApp); if (extApp != null) { if (extApp.TryIntegrate && ConnectionInfo.TreeNode != null) { ConnectionTreeNode.SetNodeImage(ConnectionInfo.TreeNode, TreeImageType.ConnectionOpen); } } } } }
private void AddNodeFromXml(XmlNode parentXmlNode, TreeNode parentTreeNode) { try { // Loop through the XML nodes until the leaf is reached. // Add the nodes to the TreeView during the looping process. if (parentXmlNode.HasChildNodes) { foreach (XmlNode xmlNode in parentXmlNode.ChildNodes) { var treeNode = new TreeNode(xmlNode.Attributes?["Name"].Value); parentTreeNode.Nodes.Add(treeNode); var nodeType = ConnectionTreeNode.GetNodeTypeFromString(xmlNode.Attributes?["Type"].Value); if (nodeType == TreeNodeType.Connection) { AddConnectionToList(xmlNode, treeNode); } else if (nodeType == TreeNodeType.Container) { AddContainerToList(xmlNode, treeNode); } AddNodeFromXml(xmlNode, treeNode); } } else { var nameAttribute = parentXmlNode.Attributes?["Name"]; var nodeName = nameAttribute?.Value.Trim(); parentTreeNode.Text = !string.IsNullOrEmpty(nodeName) ? nodeName : parentXmlNode.Name; } } catch (Exception ex) { Runtime.MessageCollector.AddExceptionStackTrace(Language.strAddNodeFromXmlFailed, ex); throw; } }
private void cMenTreeDuplicate_Click(object sender, EventArgs e) { ConnectionTreeNode.CloneNode(tvConnections.SelectedNode); Runtime.SaveConnectionsBG(); }
private void ShowHideTreeContextMenuItems(TreeNode selectedNode) { if (selectedNode == null) { return; } try { cMenTree.Enabled = true; EnableMenuItemsRecursive(cMenTree.Items); if (ConnectionTreeNode.GetNodeType(selectedNode) == TreeNodeType.Connection) { ConnectionInfo connectionInfo = (ConnectionInfo)selectedNode.Tag; if (connectionInfo.OpenConnections.Count == 0) { cMenTreeDisconnect.Enabled = false; } if (!(connectionInfo.Protocol == ProtocolType.SSH1 | connectionInfo.Protocol == ProtocolType.SSH2)) { cMenTreeToolsTransferFile.Enabled = false; } if (!(connectionInfo.Protocol == ProtocolType.RDP | connectionInfo.Protocol == ProtocolType.ICA)) { cMenTreeConnectWithOptionsConnectInFullscreen.Enabled = false; cMenTreeConnectWithOptionsConnectToConsoleSession.Enabled = false; } if (connectionInfo.Protocol == ProtocolType.IntApp) { cMenTreeConnectWithOptionsNoCredentials.Enabled = false; } } else if (ConnectionTreeNode.GetNodeType(selectedNode) == TreeNodeType.PuttySession) { PuttySessionInfo puttySessionInfo = (PuttySessionInfo)selectedNode.Tag; cMenTreeAddConnection.Enabled = false; cMenTreeAddFolder.Enabled = false; if (puttySessionInfo.OpenConnections.Count == 0) { cMenTreeDisconnect.Enabled = false; } if (!(puttySessionInfo.Protocol == ProtocolType.SSH1 | puttySessionInfo.Protocol == ProtocolType.SSH2)) { cMenTreeToolsTransferFile.Enabled = false; } cMenTreeConnectWithOptionsConnectInFullscreen.Enabled = false; cMenTreeConnectWithOptionsConnectToConsoleSession.Enabled = false; cMenTreeToolsSort.Enabled = false; cMenTreeDuplicate.Enabled = false; cMenTreeRename.Enabled = false; cMenTreeDelete.Enabled = false; cMenTreeMoveUp.Enabled = false; cMenTreeMoveDown.Enabled = false; } else if (ConnectionTreeNode.GetNodeType(selectedNode) == TreeNodeType.Container) { cMenTreeConnectWithOptionsConnectInFullscreen.Enabled = false; cMenTreeConnectWithOptionsConnectToConsoleSession.Enabled = false; cMenTreeDisconnect.Enabled = false; int openConnections = 0; foreach (TreeNode node in selectedNode.Nodes) { if (node.Tag is ConnectionInfo) { var connectionInfo = (ConnectionInfo)node.Tag; openConnections = openConnections + connectionInfo.OpenConnections.Count; } } if (openConnections == 0) { cMenTreeDisconnect.Enabled = false; } cMenTreeToolsTransferFile.Enabled = false; cMenTreeToolsExternalApps.Enabled = false; } else if (ConnectionTreeNode.GetNodeType(selectedNode) == TreeNodeType.Root) { cMenTreeConnect.Enabled = false; cMenTreeConnectWithOptions.Enabled = false; cMenTreeConnectWithOptionsConnectInFullscreen.Enabled = false; cMenTreeConnectWithOptionsConnectToConsoleSession.Enabled = false; cMenTreeConnectWithOptionsChoosePanelBeforeConnecting.Enabled = false; cMenTreeDisconnect.Enabled = false; cMenTreeToolsTransferFile.Enabled = false; cMenTreeToolsExternalApps.Enabled = false; cMenTreeDuplicate.Enabled = false; cMenTreeDelete.Enabled = false; cMenTreeMoveUp.Enabled = false; cMenTreeMoveDown.Enabled = false; } else if (ConnectionTreeNode.GetNodeType(selectedNode) == TreeNodeType.PuttyRoot) { cMenTreeAddConnection.Enabled = false; cMenTreeAddFolder.Enabled = false; cMenTreeConnect.Enabled = false; cMenTreeConnectWithOptions.Enabled = false; cMenTreeDisconnect.Enabled = false; cMenTreeToolsTransferFile.Enabled = false; cMenTreeConnectWithOptions.Enabled = false; cMenTreeToolsSort.Enabled = false; cMenTreeToolsExternalApps.Enabled = false; cMenTreeDuplicate.Enabled = false; cMenTreeRename.Enabled = true; cMenTreeDelete.Enabled = false; cMenTreeMoveUp.Enabled = false; cMenTreeMoveDown.Enabled = false; } else { cMenTree.Enabled = false; } } catch (Exception ex) { Runtime.MessageCollector.AddExceptionStackTrace("ShowHideTreeContextMenuItems (UI.Window.ConnectionTreeWindow) failed", ex); } }
public static void AddSessionsToTree() { TreeView treeView = ConnectionTree.TreeView; if (treeView == null) { return; } if (treeView.InvokeRequired) { treeView.Invoke(new AddSessionsToTreeDelegate(AddSessionsToTree)); return; } foreach (Provider provider in Providers) { TreeNode rootTreeNode = provider.RootTreeNode; bool inUpdate = false; List <ConnectionInfo> savedSessions = new List <ConnectionInfo>(provider.GetSessions()); if (!IsProviderEnabled(provider) || savedSessions == null || savedSessions.Count == 0) { if (rootTreeNode != null && treeView.Nodes.Contains(rootTreeNode)) { treeView.BeginUpdate(); treeView.Nodes.Remove(rootTreeNode); treeView.EndUpdate(); } continue; } if (!treeView.Nodes.Contains(rootTreeNode)) { if (!inUpdate) { treeView.BeginUpdate(); inUpdate = true; } treeView.Nodes.Add(rootTreeNode); } List <TreeNode> newTreeNodes = new List <TreeNode>(); foreach (PuttySessionInfo sessionInfo in savedSessions) { TreeNode treeNode = default(TreeNode); bool isNewNode = false; if (rootTreeNode.Nodes.ContainsKey(sessionInfo.Name)) { treeNode = rootTreeNode.Nodes[sessionInfo.Name]; isNewNode = false; } else { treeNode = ConnectionTreeNode.AddNode(TreeNodeType.PuttySession, sessionInfo.Name); if (treeNode == null) { continue; } treeNode.Name = treeNode.Text; treeNode.ImageIndex = (int)TreeImageType.ConnectionClosed; treeNode.SelectedImageIndex = (int)TreeImageType.ConnectionClosed; isNewNode = true; } sessionInfo.RootPuttySessionsInfo = provider.RootInfo; sessionInfo.TreeNode = treeNode; //sessionInfo.IInheritable.TurnOffInheritanceCompletely(); treeNode.Tag = sessionInfo; if (isNewNode) { newTreeNodes.Add(treeNode); } } foreach (TreeNode treeNode in rootTreeNode.Nodes) { if (!savedSessions.Contains((ConnectionInfo)treeNode.Tag)) { if (!inUpdate) { treeView.BeginUpdate(); inUpdate = true; } rootTreeNode.Nodes.Remove(treeNode); } } if (!(newTreeNodes.Count == 0)) { if (!inUpdate) { treeView.BeginUpdate(); inUpdate = true; } rootTreeNode.Nodes.AddRange(newTreeNodes.ToArray()); } if (inUpdate) { ConnectionTree.Sort(rootTreeNode, SortOrder.Ascending); rootTreeNode.Expand(); treeView.EndUpdate(); } } }
private static void mMenFileDuplicate_Click(object sender, EventArgs e) { ConnectionTreeNode.CloneNode(ConnectionTree.SelectedNode); Runtime.SaveConnectionsBG(); }
private static void ImportRootOrContainer(XmlNode xmlNode, TreeNode parentTreeNode) { string xmlNodeType = xmlNode.Attributes["type"].Value; switch (xmlNode.Name) { case "root": if (!(string.Compare(xmlNodeType, "database", ignoreCase: true) == 0)) { throw (new FileFormatException(string.Format("Unrecognized root node type ({0}).", xmlNodeType))); } break; case "container": if (!(string.Compare(xmlNodeType, "folder", ignoreCase: true) == 0)) { throw (new FileFormatException(string.Format("Unrecognized root node type ({0}).", xmlNodeType))); } break; default: // ReSharper disable once LocalizableElement throw (new ArgumentException("Argument must be either a root or a container node.", "xmlNode")); } if (parentTreeNode == null) { throw (new InvalidOperationException("parentInfo.TreeNode must not be null.")); } string name = xmlNode.Attributes["name"].Value; TreeNode treeNode = new TreeNode(name); parentTreeNode.Nodes.Add(treeNode); ContainerInfo containerInfo = new ContainerInfo(); containerInfo.TreeNode = treeNode; containerInfo.Name = name; ConnectionInfo connectionInfo = CreateConnectionInfo(name); connectionInfo.Parent = containerInfo; connectionInfo.IsContainer = true; containerInfo.CopyFrom(connectionInfo); // We can only inherit from a container node, not the root node or connection nodes if (ConnectionTreeNode.GetNodeType(parentTreeNode) == TreeNodeType.Container) { containerInfo.Parent = (ContainerInfo)parentTreeNode.Tag; } else { connectionInfo.Inheritance.DisableInheritance(); } treeNode.Name = name; treeNode.Tag = containerInfo; treeNode.ImageIndex = (int)TreeImageType.Container; treeNode.SelectedImageIndex = (int)TreeImageType.Container; foreach (XmlNode childNode in xmlNode.SelectNodes("./*")) { switch (childNode.Name) { case "container": ImportRootOrContainer(childNode, treeNode); break; case "connection": ImportConnection(childNode, treeNode); break; default: throw (new FileFormatException(string.Format("Unrecognized child node ({0}).", childNode.Name))); } } containerInfo.IsExpanded = bool.Parse(xmlNode.Attributes["expanded"].InnerText); if (containerInfo.IsExpanded) { treeNode.Expand(); } Runtime.ContainerList.Add(containerInfo); }
private void mMenFile_DropDownOpening(Object sender, EventArgs e) { if (ConnectionTreeNode.GetNodeType(ConnectionTree.SelectedNode) == TreeNodeType.Root) { mMenFileNewConnection.Enabled = true; mMenFileNewFolder.Enabled = true; mMenFileDelete.Enabled = false; mMenFileRename.Enabled = true; mMenFileDuplicate.Enabled = false; mMenReconnectAll.Enabled = true; mMenFileDelete.Text = Language.strMenuDelete; mMenFileRename.Text = Language.strMenuRenameFolder; mMenFileDuplicate.Text = Language.strMenuDuplicate; mMenReconnectAll.Text = Language.strMenuReconnectAll; } else if (ConnectionTreeNode.GetNodeType(ConnectionTree.SelectedNode) == TreeNodeType.Container) { mMenFileNewConnection.Enabled = true; mMenFileNewFolder.Enabled = true; mMenFileDelete.Enabled = true; mMenFileRename.Enabled = true; mMenFileDuplicate.Enabled = true; mMenReconnectAll.Enabled = true; mMenFileDelete.Text = Language.strMenuDeleteFolder; mMenFileRename.Text = Language.strMenuRenameFolder; mMenFileDuplicate.Text = Language.strMenuDuplicateFolder; mMenReconnectAll.Text = Language.strMenuReconnectAll; } else if (ConnectionTreeNode.GetNodeType(ConnectionTree.SelectedNode) == TreeNodeType.Connection) { mMenFileNewConnection.Enabled = true; mMenFileNewFolder.Enabled = true; mMenFileDelete.Enabled = true; mMenFileRename.Enabled = true; mMenFileDuplicate.Enabled = true; mMenReconnectAll.Enabled = true; mMenFileDelete.Text = Language.strMenuDeleteConnection; mMenFileRename.Text = Language.strMenuRenameConnection; mMenFileDuplicate.Text = Language.strMenuDuplicateConnection; mMenReconnectAll.Text = Language.strMenuReconnectAll; } else if ((ConnectionTreeNode.GetNodeType(ConnectionTree.SelectedNode) == TreeNodeType.PuttyRoot) || (ConnectionTreeNode.GetNodeType(ConnectionTree.SelectedNode) == TreeNodeType.PuttySession)) { mMenFileNewConnection.Enabled = false; mMenFileNewFolder.Enabled = false; mMenFileDelete.Enabled = false; mMenFileRename.Enabled = false; mMenFileDuplicate.Enabled = false; mMenReconnectAll.Enabled = true; mMenFileDelete.Text = Language.strMenuDelete; mMenFileRename.Text = Language.strMenuRename; mMenFileDuplicate.Text = Language.strMenuDuplicate; mMenReconnectAll.Text = Language.strMenuReconnectAll; } else { mMenFileNewConnection.Enabled = true; mMenFileNewFolder.Enabled = true; mMenFileDelete.Enabled = false; mMenFileRename.Enabled = false; mMenFileDuplicate.Enabled = false; mMenReconnectAll.Enabled = true; mMenFileDelete.Text = Language.strMenuDelete; mMenFileRename.Text = Language.strMenuRename; mMenFileDuplicate.Text = Language.strMenuDuplicate; mMenReconnectAll.Text = Language.strMenuReconnectAll; } }
private void AddNodesFromSql(TreeNode baseNode) { try { _sqlConnection.Open(); _sqlQuery = new SqlCommand("SELECT * FROM tblCons ORDER BY PositionID ASC", _sqlConnection); _sqlDataReader = _sqlQuery.ExecuteReader(CommandBehavior.CloseConnection); if (_sqlDataReader.HasRows == false) { return; } while (_sqlDataReader.Read()) { var tNode = new TreeNode(Convert.ToString(_sqlDataReader["Name"])); var nodeType = ConnectionTreeNode.GetNodeTypeFromString(Convert.ToString(_sqlDataReader["Type"])); if (nodeType == TreeNodeType.Connection) { AddConnectionToList(tNode); } else if (nodeType == TreeNodeType.Container) { AddContainerToList(tNode); } var parentId = Convert.ToString(_sqlDataReader["ParentID"].ToString().Trim()); if (string.IsNullOrEmpty(parentId) || parentId == "0") { baseNode.Nodes.Add(tNode); } else { var pNode = ConnectionTreeNode.GetNodeFromConstantID(Convert.ToString(_sqlDataReader["ParentID"])); if (pNode != null) { pNode.Nodes.Add(tNode); switch (ConnectionTreeNode.GetNodeType(tNode)) { case TreeNodeType.Connection: ((ConnectionInfo)tNode.Tag).Parent = (ContainerInfo)pNode.Tag; break; case TreeNodeType.Container: ((ContainerInfo)tNode.Tag).Parent = (ContainerInfo)pNode.Tag; break; } } else { baseNode.Nodes.Add(tNode); } } } } catch (Exception ex) { Runtime.MessageCollector.AddMessage(MessageClass.ErrorMsg, Language.strAddNodesFromSqlFailed + Environment.NewLine + ex.Message, true); } }