protected override void OnAfterSelect(TreeViewEventArgs e)
{
if (_noSelectCounter > 0)
{
return;
}
RdcTreeNode rdcTreeNode = base.SelectedNode as RdcTreeNode;
if (rdcTreeNode != null)
{
ServerBase serverBase = rdcTreeNode as ServerBase;
if (serverBase != null)
{
if (serverBase.IsClientUndocked || !serverBase.IsClientFullScreen)
{
serverBase.ServerNode.SetNormalView();
}
if (!Helpers.IsControlKeyPressed && Program.Preferences.FocusOnClick && e.Action == TreeViewAction.ByMouse && serverBase.IsConnected)
{
SetDelayedFocusServer(serverBase);
}
}
if (!rdcTreeNode.IsVisible)
{
rdcTreeNode.EnsureVisible();
}
rdcTreeNode.Show();
}
Program.TheForm.SetTitle();
base.OnAfterSelect(e);
}
public static RuleGroup Create(XmlNode xmlNode, RdcTreeNode node, ICollection <string> errors)
{
RuleGroup ruleGroup = new RuleGroup();
ruleGroup.ReadXml(xmlNode, node, errors);
return(ruleGroup);
}
public static void VisitParents(this RdcTreeNode node, Action <RdcTreeNode> callback)
{
for (RdcTreeNode rdcTreeNode = node.Parent as RdcTreeNode; rdcTreeNode != null; rdcTreeNode = (rdcTreeNode.Parent as RdcTreeNode))
{
callback(rdcTreeNode);
}
}
public static Rule Create(XmlNode xmlNode, RdcTreeNode node, ICollection <string> errors)
{
Rule rule = new Rule();
rule.ReadXml(xmlNode, node, errors);
return(rule);
}
public static void VisitNodeAndParents(this RdcTreeNode node, Func <RdcTreeNode, NodeVisitorResult> callback)
{
if (callback(node) == NodeVisitorResult.Continue)
{
node.VisitParents(callback);
}
}
public void ConfirmRemove(RdcTreeNode node, bool askUser)
{
if (node.ConfirmRemove(askUser))
{
RemoveNode(node);
}
}
public virtual void CreateControls(RdcTreeNode settings)
{
LogonCredentialsTabPage logonCredentialsTabPage = (LogonCredentialsTabPage)settings.LogonCredentials.CreateTabPage(this);
LogonCredentialsDialogOptions logonCredentialsDialogOptions = LogonCredentialsDialogOptions.ShowProfiles;
if (settings.LogonCredentials.InheritSettingsType.Mode != InheritanceMode.Disabled)
{
logonCredentialsDialogOptions |= LogonCredentialsDialogOptions.AllowInheritance;
}
logonCredentialsTabPage.CreateControls(logonCredentialsDialogOptions);
AddTabPage(logonCredentialsTabPage);
GatewaySettingsTabPage gatewaySettingsTabPage = (GatewaySettingsTabPage)settings.GatewaySettings.CreateTabPage(this);
logonCredentialsDialogOptions = LogonCredentialsDialogOptions.ShowProfiles;
if (settings.GatewaySettings.InheritSettingsType.Mode != InheritanceMode.Disabled)
{
logonCredentialsDialogOptions |= LogonCredentialsDialogOptions.AllowInheritance;
}
gatewaySettingsTabPage.CreateControls(logonCredentialsDialogOptions);
AddTabPage(gatewaySettingsTabPage);
AddTabPage(settings.ConnectionSettings.CreateTabPage(this));
AddTabPage(settings.RemoteDesktopSettings.CreateTabPage(this));
AddTabPage(settings.LocalResourceSettings.CreateTabPage(this));
AddTabPage(settings.SecuritySettings.CreateTabPage(this));
AddTabPage(settings.DisplaySettings.CreateTabPage(this));
InitButtons();
this.ScaleAndLayout();
settings.InheritSettings();
settings.ResolveCredentials();
}
private void CreateServerPropertiesPage(RdcTreeNode settings)
{
ServerPropertiesTabPage page = (ServerPropertiesTabPage)(base.PropertiesPage = (settings.Properties.CreateTabPage(this) as ServerPropertiesTabPage));
AddTabPage(page);
base.PropertiesPage.ParentGroupChanged += base.PopulateCredentialsProfiles;
}
private void CreateImportServersPage(RdcTreeNode settings)
{
ImportServersPropertiesPage page = (ImportServersPropertiesPage)(base.PropertiesPage = new ImportServersPropertiesPage(this));
AddTabPage(page);
base.PropertiesPage.ParentGroupChanged += base.PopulateCredentialsProfiles;
}
public void AddNode(RdcTreeNode node, GroupBase parent)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
if (!(node is ServerBase) && !(node is GroupBase))
{
throw new ArgumentOutOfRangeException("node", "Node must derive from ServerBase or GroupBase");
}
if (parent == null)
{
throw new ArgumentNullException("parent");
}
if (parent == RootNode)
{
base.Nodes.Add(node);
}
else
{
parent.Nodes.Add(node);
this.SortGroup(parent);
}
OnGroupChanged(parent, ChangeType.TreeChanged);
}
public InheritanceControl(TabbedSettingsDialog dialog, string settingsGroupName)
{
_dialog = dialog;
_settingsGroupName = settingsGroupName;
_sourceNode = DefaultSettingsGroup.Instance;
_enabled = true;
}
public override bool HandleMove(RdcTreeNode childNode)
{
ReconnectServerRef reconnectServerRef = AddReference(childNode as ServerBase);
reconnectServerRef.Start(removeAfterConnection: false);
return(true);
}
public override void ReadXml(XmlNode xmlNode, RdcTreeNode node)
{
XmlNode firstChild = xmlNode.FirstChild;
if (firstChild == null)
{
Value = string.Empty;
}
else
{
Value = firstChild.InnerText;
}
try
{
XmlNode xmlNode2 = xmlNode.Attributes["storeAsClearText"];
if (xmlNode2 != null && bool.Parse(xmlNode2.InnerText))
{
node.Password.IsDecrypted = true;
}
else if (xmlNode.ParentNode.Name != "credentialsProfile")
{
Encryption.DeferDecryption(this, node, xmlNode.GetFullPath());
}
}
catch
{
}
}
public void OnContextMenu(ContextMenuStrip contextMenuStrip, RdcMan.RdcTreeNode node)
{
//if (node != null)
//{
// contextMenuStrip.Items.Insert(0, new DelegateMenuItem("Disconnect", MenuNames.SessionDisconnect, new Action(node.Disconnect)));
//}
}
internal void ReadXml(XmlNode xmlNode, RdcTreeNode node, ICollection <string> errors)
{
InheritanceMode result = InheritSettingsType.Mode;
if (result != InheritanceMode.Disabled)
{
try
{
string value = xmlNode.Attributes["inherit"].Value;
if (!Enum.TryParse(value, out result))
{
errors.Add("Unexpected inheritance mode '{0}' in {1}".InvariantFormat(value, xmlNode.GetFullPath()));
result = InheritanceMode.None;
}
}
catch
{
errors.Add("No inheritance mode specified in {0}".InvariantFormat(xmlNode.GetFullPath()));
result = InheritanceMode.None;
}
InheritSettingsType.Mode = result;
}
switch (result)
{
case InheritanceMode.FromParent:
{
bool anyInherited = false;
InheritSettings(node, ref anyInherited);
break;
}
case InheritanceMode.None:
case InheritanceMode.Disabled:
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
try
{
ISetting setting = (ISetting)SettingProperties[childNode.Name].Property.GetValue(this, null);
try
{
setting.ReadXml(childNode, node);
}
catch
{
errors.Add("Error processing Xml node {0}".InvariantFormat(childNode.GetFullPath()));
}
}
catch
{
errors.Add("Unexpected Xml node {0}".InvariantFormat(childNode.GetFullPath()));
}
}
break;
default:
errors.Add("Unexpected inheritance mode '{0}' in {1}".InvariantFormat(result.ToString(), xmlNode.GetFullPath()));
break;
}
}
public override void WriteXml(XmlTextWriter tw, RdcTreeNode node)
{
foreach (T item in base.Value)
{
T current = item;
tw.WriteElementString("item", current.ToString());
}
}
protected override void OnItemDrag(ItemDragEventArgs e)
{
base.OnItemDrag(e);
RdcTreeNode rdcTreeNode = _draggedNode = (e.Item as RdcTreeNode);
_preDragSelectedNode = base.SelectedNode;
DoDragDrop(_draggedNode, DragDropEffects.Move);
}
public override void CreateControls(RdcTreeNode settingsNode)
{
GroupPropertiesTabPage page = (GroupPropertiesTabPage)(base.PropertiesPage = (settingsNode.Properties.CreateTabPage(this) as GroupPropertiesTabPage));
AddTabPage(page);
base.PropertiesPage.ParentGroupChanged += base.PopulateCredentialsProfiles;
base.CreateControls(settingsNode);
}
protected override void Copy(RdcTreeNode node)
{
ServerBase serverBase = node as ServerBase;
if (serverBase != null)
{
Copy(serverBase.Properties);
}
}
public void ReadXml(XmlNode xmlNode, RdcTreeNode node, ICollection <string> errors)
{
Operator = xmlNode.Attributes["operator"].Value.ParseEnum <RuleGroupOperator>();
Rules = new List <Rule>();
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
Rules.Add(Rule.Create(childNode, node, errors));
}
}
public static void VisitParents(this RdcTreeNode node, Func <RdcTreeNode, NodeVisitorResult> callback)
{
RdcTreeNode rdcTreeNode = node.Parent as RdcTreeNode;
while (rdcTreeNode != null && callback(rdcTreeNode) == NodeVisitorResult.Continue)
{
rdcTreeNode = (rdcTreeNode.Parent as RdcTreeNode);
}
}
public static void AddFavorite(RdcTreeNode node)
{
ServerBase serverBase = node as ServerBase;
if (serverBase != null)
{
FavoritesGroup.Instance.AddReference(serverBase);
}
}
public static void DeferDecryption(IDeferDecryption o, RdcTreeNode node, string errorDetail)
{
PendingDecryption.Add(new DeferDecryptionItem
{
Object = o,
Node = node,
ErrorDetail = errorDetail
});
}
public override void CreateControls(RdcTreeNode settings)
{
TabPage tabPage = settings.Properties.CreateTabPage(this);
base.PropertiesPage = (tabPage as INodePropertiesPage);
AddTabPage(tabPage);
InitButtons();
this.ScaleAndLayout();
}
protected override void WriteSettings(XmlTextWriter tw, RdcTreeNode node)
{
HashSet <ISetting> hashSet = new HashSet <ISetting>();
if (DesktopSizeSameAsClientAreaSize.Value || DesktopSizeFullScreen.Value)
{
hashSet.Add(DesktopSize);
}
base.WriteSettings(tw, node, hashSet);
}
protected override void WriteSettings(XmlTextWriter tw, RdcTreeNode node)
{
HashSet <ISetting> hashSet = new HashSet <ISetting>();
if (string.IsNullOrEmpty(base.Comment.Value))
{
hashSet.Add(base.Comment);
}
base.WriteSettings(tw, node, hashSet);
}
public override void ReadXml(XmlNode xmlNode, RdcTreeNode node)
{
if (int.TryParse(xmlNode.InnerText, out int result))
{
base.Value = (TEnum)(object)result;
}
else
{
base.Value = (TEnum)Enum.Parse(typeof(TEnum), xmlNode.InnerText);
}
}
internal void InheritSettings(RdcTreeNode node, ref bool anyInherited)
{
GroupBase inheritedSettingsNode = InheritSettingsType.GetInheritedSettingsNode(node);
if (inheritedSettingsNode != null)
{
inheritedSettingsNode.InheritSettings();
Copy(inheritedSettingsNode);
anyInherited = true;
}
}
public override void CreateControls(RdcTreeNode settings)
{
FileGroupPropertiesTabPage page = (FileGroupPropertiesTabPage)(base.PropertiesPage = (settings.Properties.CreateTabPage(this) as FileGroupPropertiesTabPage));
AddTabPage(page);
base.PropertiesPage.ParentGroupChanged += base.PopulateCredentialsProfiles;
base.CreateControls(settings);
AddTabPage(settings.EncryptionSettings.CreateTabPage(this));
CreateProfileManagementTabPage();
PopulateCredentialsProfiles(base.AssociatedNode as FileGroup);
PopulateCredentialsManagementTab((base.AssociatedNode as FileGroup).CredentialsProfiles);
}
internal void CopySettings(RdcTreeNode node, Type excludeType)
{
for (int i = 0; i < AllSettingsGroups.Count; i++)
{
SettingsGroup settingsGroup = AllSettingsGroups[i];
if (!(settingsGroup.GetType() == excludeType))
{
AllSettingsGroups[i].InheritSettingsType.Mode = node.AllSettingsGroups[i].InheritSettingsType.Mode;
AllSettingsGroups[i].Copy(node.AllSettingsGroups[i]);
}
}
}
