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);
}
}
