public override void Draw(TreeNodeAdv node, DrawContext context)
{
if (node.CanExpand)
{
Rectangle r = context.Bounds;
int dy = (int)Math.Round((float)(r.Height - ImageSize) / 2);
if (_useVisualStyles)
{
VisualStyleRenderer renderer;
if (node.IsExpanded)
renderer = _openedRenderer;
else
renderer = _closedRenderer;
renderer.DrawBackground(context.Graphics, new Rectangle(r.X, r.Y + dy, ImageSize, ImageSize));
}
else
{
Image img;
if (node.IsExpanded)
img = this.Minus;
else
img = this.Plus;
context.Graphics.DrawImageUnscaled(img, new Point(r.X, r.Y + dy));
}
}
}
public override void Draw(TreeNodeAdv node, DrawContext context)
{
if (context.CurrentEditorOwner == this && node == Parent.CurrentNode)
return;
var label = GetLabel(node);
var textBounds = GetBounds(node, context);
var focusRect = new Rectangle(textBounds.X, context.Bounds.Y,
textBounds.Width - 1, context.Bounds.Height - 1);
Brush backgroundBrush;
Color textColor;
Font font;
CreateBrushes(node, context, label, out backgroundBrush, out textColor, out font, ref label);
//if (backgroundBrush != null)
// context.Graphics.FillRectangle(backgroundBrush, focusRect);
var focusPen = new Pen(SystemColors.Highlight);
focusPen.Color = context.DrawSelection == DrawSelectionMode.None ?
SystemColors.ControlText : SystemColors.InactiveCaption;
//focusPen.Color = SystemColors.Highlight;
//context.Graphics.DrawRectangle(focusPen, focusRect);
if (UseCompatibleTextRendering)
TextRenderer.DrawText(context.Graphics, label, font, textBounds, textColor, _formatFlags);
else
context.Graphics.DrawString(label, font, GetBrush(textColor), textBounds, _format);
}
public DrawEventArgs(TreeNodeAdv node, EditableControl control, DrawContext context, string text)
: base(node)
{
_control = control;
_context = context;
_text = text;
}
public override void Draw(TreeNodeAdv node, DrawContext context)
{
Rectangle r = context.Bounds;
int dy = (int)Math.Round((float)(r.Height - ImageSize) / 2);
CheckState state = GetCheckState(node);
if (Application.RenderWithVisualStyles)
{
VisualStyleRenderer renderer;
if (state == CheckState.Indeterminate)
renderer = new VisualStyleRenderer(VisualStyleElement.Button.CheckBox.MixedNormal);
else if (state == CheckState.Checked)
renderer = new VisualStyleRenderer(VisualStyleElement.Button.CheckBox.CheckedNormal);
else
renderer = new VisualStyleRenderer(VisualStyleElement.Button.CheckBox.UncheckedNormal);
renderer.DrawBackground(context.Graphics, new Rectangle(r.X, r.Y + dy, ImageSize, ImageSize));
}
else
{
Image img;
if (state == CheckState.Indeterminate)
img = _unknown;
else if (state == CheckState.Checked)
img = _check;
else
img = _uncheck;
context.Graphics.DrawImage(img, new Point(r.X, r.Y + dy));
//ControlPaint.DrawCheckBox(context.Graphics, r, state2);
}
}
private void btnOK_Click(object sender, EventArgs e)
{
var node = new TreeNodeAdv(cmbExistsDB.Text.Trim());
mainForm.treeView.Nodes.Add(node);
Close();
}
internal bool HideEditor(bool applyChanges)
{
if (CurrentEditor != null)
{
if (applyChanges)
{
if (!ApplyChanges())
return false;
}
//Check once more if editor was closed in ApplyChanges
if (CurrentEditor != null)
{
CurrentEditor.Validating -= EditorValidating;
CurrentEditorOwner.DoDisposeEditor(CurrentEditor);
CurrentEditor.Parent = null;
CurrentEditor.Dispose();
CurrentEditor = null;
CurrentEditorOwner = null;
_editingNode = null;
}
}
return true;
}
public override void Draw(TreeNodeAdv node, DrawContext context)
{
if (node.CanExpand)
{
Rectangle r = context.Bounds;
int dy = (int)Math.Round((float)(r.Height - ImageSize) / 2);
if (Application.RenderWithVisualStyles)
{
VisualStyleRenderer renderer;
if (node.IsExpanded)
renderer = new VisualStyleRenderer(VisualStyleElement.TreeView.Glyph.Opened);
else
renderer = new VisualStyleRenderer(VisualStyleElement.TreeView.Glyph.Closed);
renderer.DrawBackground(context.Graphics, new Rectangle(r.X, r.Y + dy, ImageSize, ImageSize));
}
else
{
Image img;
if (node.IsExpanded)
img = _minus;
else
img = _plus;
context.Graphics.DrawImageUnscaled(img, new Point(r.X, r.Y + dy));
}
}
}
protected virtual CheckState GetCheckState(TreeNodeAdv node)
{
object obj=GetValue(node);
if(obj is CheckState) return (CheckState)obj;
else if(obj is bool) return (bool)obj?CheckState.Checked:CheckState.Unchecked;
else return CheckState.Unchecked;
}
public override void Draw(TreeNodeAdv node, DrawContext context)
{
Rectangle bounds = GetBounds(node, context);
CheckState state = GetCheckState(node);
if (Application.RenderWithVisualStyles)
{
VisualStyleRenderer renderer;
if (state == CheckState.Indeterminate)
renderer = new VisualStyleRenderer(VisualStyleElement.Button.CheckBox.MixedNormal);
else if (state == CheckState.Checked)
renderer = new VisualStyleRenderer(VisualStyleElement.Button.CheckBox.CheckedNormal);
else
renderer = new VisualStyleRenderer(VisualStyleElement.Button.CheckBox.UncheckedNormal);
renderer.DrawBackground(context.Graphics, new Rectangle(bounds.X, bounds.Y, ImageSize, ImageSize));
}
else
{
Image img;
if (state == CheckState.Indeterminate)
img = _unknown;
else if (state == CheckState.Checked)
img = _check;
else
img = _uncheck;
context.Graphics.DrawImage(img, bounds.Location);
}
}
public override Size MeasureSize(TreeNodeAdv node, DrawContext context)
{
if (GetValue(node).ToString() == "")
return new Size(0, 0);
else
return new Size(_normal.Width,_normal.Height);
}
public virtual string GetToolTip(TreeNodeAdv node)
{
if (ToolTipProvider != null)
return ToolTipProvider.GetToolTip(node, this);
else
return string.Empty;
}
public object GetValue(TreeNodeAdv node)
{
PropertyInfo pi = GetPropertyInfo(node);
if (pi != null && pi.CanRead)
return pi.GetValue(node.Tag, null);
else
return null;
}
public override Size MeasureSize(TreeNodeAdv node, DrawContext context, int rightBoundLastControl)
{
Image image=GetIcon(node);
if(image!=null)
return image.Size;
else
return Size.Empty;
}
public override Size MeasureSize(TreeNodeAdv node)
{
Image image = GetIcon(node);
if (image != null)
return image.Size;
else
return Size.Empty;
}
public TreeViewRowDrawEventArgs(Graphics graphics, Rectangle clipRectangle, TreeNodeAdv node, DrawContext context, int row, Rectangle rowRect)
: base(graphics, clipRectangle)
{
_node = node;
_context = context;
_row = row;
_rowRect = rowRect;
}
private PropertyInfo GetPropertyInfo(TreeNodeAdv node)
{
if (node.Tag != null && !string.IsNullOrEmpty(DataPropertyName))
{
Type type = node.Tag.GetType();
return type.GetProperty(DataPropertyName);
}
return null;
}
public override Size MeasureSize(TreeNodeAdv node, DrawContext context)
{
Image image = GetIcon(node);
if (image != null)
return image.Size;
return Size.Empty;
}
public override void Draw(TreeNodeAdv node, DrawContext context)
{
Image image = GetIcon(node);
if (image != null)
{
Rectangle r = GetBounds(node, context);
context.Graphics.DrawImage(image, r.Location);
}
}
protected override void DoApplyChanges(TreeNodeAdv node, Control editor)
{
string oldLabel = GetLabel(node);
if (oldLabel != _label)
{
SetLabel(node, _label);
OnLabelChanged();
}
}
public void DoDragDropSelectedNodes(DragDropEffects allowedEffects)
{
if (SelectedNodes.Count > 0)
{
TreeNodeAdv[] nodes = new TreeNodeAdv[SelectedNodes.Count];
SelectedNodes.CopyTo(nodes, 0);
DoDragDrop(nodes, allowedEffects);
}
}
public override void Draw(TreeNodeAdv node, DrawContext context)
{
Image image = GetIcon(node);
if (image != null)
{
Point point = new Point(context.Bounds.X,
context.Bounds.Y + (context.Bounds.Height - image.Height) / 2);
context.Graphics.DrawImage(image, point);
}
}
private void ChangeBackgroundSelectedGroup(TreeNodeAdv grp, BrushInfo brush)
{
if (grp != null)
{
grp.Background = brush;
if (grp.Expanded)
foreach (TreeNodeAdv n in grp.Nodes)
n.Background = brush;
}
}
protected override void DoApplyChanges(TreeNodeAdv node, Control editor)
{
var label = (editor as TextBox).Text;
string oldLabel = GetLabel(node);
if (oldLabel != label)
{
SetLabel(node, label);
OnLabelChanged(node.Tag, oldLabel, label);
}
}
protected override Control CreateEditor(TreeNodeAdv node)
{
ComboBox comboBox = new ComboBox();
if (DropDownItems != null)
comboBox.Items.AddRange(DropDownItems.ToArray());
comboBox.SelectedItem = GetValue(node);
comboBox.DropDownStyle = ComboBoxStyle.DropDownList;
comboBox.DropDownClosed += new EventHandler(EditorDropDownClosed);
return comboBox;
}
public override void Draw(TreeNodeAdv node, DrawContext context)
{
Image image=GetIcon(node);
if(image!=null)
{
Rectangle r=GetBounds(node, context);
if(image.Width>0&&image.Height>0)
{
switch(_scaleMode)
{
case ImageScaleMode.Fit:
context.Graphics.DrawImage(image, r);
break;
case ImageScaleMode.ScaleDown:
{
float factor=Math.Min((float)r.Width/(float)image.Width, (float)r.Height/(float)image.Height);
if(factor<1)
context.Graphics.DrawImage(image, r.X, r.Y, image.Width*factor, image.Height*factor);
else
context.Graphics.DrawImage(image, r.X, r.Y, image.Width, image.Height);
} break;
case ImageScaleMode.ScaleUp:
{
float factor=Math.Max((float)r.Width/(float)image.Width, (float)r.Height/(float)image.Height);
if(factor>1)
context.Graphics.DrawImage(image, r.X, r.Y, image.Width*factor, image.Height*factor);
else
context.Graphics.DrawImage(image, r.X, r.Y, image.Width, image.Height);
} break;
case ImageScaleMode.AlwaysScale:
{
float fx=(float)r.Width/(float)image.Width;
float fy=(float)r.Height/(float)image.Height;
if(Math.Min(fx, fy)<1)
{ //scale down
float factor=Math.Min(fx, fy);
context.Graphics.DrawImage(image, r.X, r.Y, image.Width*factor, image.Height*factor);
}
else if(Math.Max(fx, fy)>1)
{
float factor=Math.Max(fx, fy);
context.Graphics.DrawImage(image, r.X, r.Y, image.Width*factor, image.Height*factor);
}
else
context.Graphics.DrawImage(image, r.X, r.Y, image.Width, image.Height);
} break;
case ImageScaleMode.Clip:
default:
context.Graphics.DrawImage(image, r.X, r.Y, image.Width, image.Height);
break;
}
}
}
}
protected override Control CreateEditor(TreeNodeAdv node)
{
TextBox textBox = CreateTextBox();
textBox.TextAlign = TextAlign;
textBox.Text = GetLabel(node);
textBox.BorderStyle = BorderStyle.FixedSingle;
textBox.TextChanged += new EventHandler(textBox_TextChanged);
_label = textBox.Text;
SetEditControlProperties(textBox, node);
return textBox;
}
protected override Control CreateEditor(TreeNodeAdv node)
{
Control c;
object value = GetValue(node);
if (IsCheckedListBoxRequired(node))
c = CreateCheckedListBox(node);
else
c = CreateCombo(node);
OnCreatingEditor(new EditEventArgs(node, c));
return c;
}
private void SelectAllFromStart(TreeNodeAdv node)
{
Tree.ClearSelectionInternal();
int a = node.Row;
int b = Tree.SelectionStart.Row;
for (int i = Math.Min(a, b); i <= Math.Max(a, b); i++)
{
if (Tree.SelectionMode == TreeSelectionMode.Multi || Tree.RowMap[i].Parent == node.Parent)
Tree.RowMap[i].IsSelected = true;
}
}
public override void Draw(TreeNodeAdv node, DrawContext context)
{
Image image = GetIcon(node);
if (image != null)
{
Rectangle r = GetBounds(node, context);
// ml: center icon vertically.
r.Y += (context.Bounds.Height - r.Height) / 2;
context.Graphics.DrawImage(image, r.Location);
}
}
public virtual object GetValue(TreeNodeAdv node)
{
if (this.VirtualMode)
{
NodeControlValueEventArgs args = new NodeControlValueEventArgs(node);
OnValueNeeded(args);
return args.Value;
}
return this.GetMemberAdapter(node).Value;
}
public void SetLabel(TreeNodeAdv node, string value)
{
SetValue(node, value);
}
public override void SetValue(TreeNodeAdv node, object value)
{
(node.Tag as ITabularNamedObject).SetName((string)value, UI.TreeModel?.Culture);
}
public override string GetToolTip(TreeNodeAdv node)
{
var err = (node.Tag as IErrorMessageObject)?.ErrorMessage;
return(err ?? string.Empty);
}
public override Size MeasureSize(TreeNodeAdv node, DrawContext context)
{
return(GetLabelSize(node, context));
}
public static void Execute(TreeNodeAdv treeNode)
{
Node node = treeNode.Tag as Node;
Device.IODevice dev = node.Tag as Device.IODevice;
if (dev != null)
{
bool isDevHidden = true;
//Показываем каналы.
foreach (Device.IODevice.IOChannel ch in dev.Channels)
{
if (ch.IsEmpty())
{
isDevHidden = false;
}
}
node.IsHidden = isDevHidden;
if (treeNode.Children.Count < 1)
{
return;
}
else
{
List <TreeNodeAdv> childs = treeNode.Children.ToList();
foreach (TreeNodeAdv child in childs)
{
Execute(child);
}
return;
}
}
Device.IODevice.IOChannel chn =
node.Tag as Device.IODevice.IOChannel;
if (chn != null)
{
if (chn.IsEmpty())
{
node.IsHidden = false;
}
else
{
node.IsHidden = true;
}
if (treeNode.Children.Count < 1)
{
return;
}
else
{
List <TreeNodeAdv> childs = treeNode.Children.ToList();
foreach (TreeNodeAdv child in childs)
{
Execute(child);
}
return;
}
}
if (treeNode.Children.Count < 1)
{
node.IsHidden = false;
}
else
{
List <TreeNodeAdv> childs = treeNode.Children.ToList();
foreach (TreeNodeAdv child in childs)
{
Execute(child);
}
return;
}
}
public void DeserializeTreeView(TreeViewAdv treeView, string fileName)
{
XmlTextReader reader = null;
try
{
// disabling re-drawing of treeview till all nodes are added
treeView.BeginUpdate();
reader =
new XmlTextReader(fileName);
TreeNodeAdv parentNode = null;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name == XmlNodeTag)
{
var newNode = new TreeNodeAdv();
bool isEmptyElement = reader.IsEmptyElement;
// loading node attributes
int attributeCount = reader.AttributeCount;
if (attributeCount > 0)
{
for (int i = 0; i < attributeCount; i++)
{
reader.MoveToAttribute(i);
SetAttributeValue(newNode, reader.Name, reader.Value);
}
}
// add new node to Parent Node or TreeView
if (parentNode != null)
{
parentNode.Nodes.Add(newNode);
}
else
{
treeView.Nodes.Add(newNode);
}
// making current node 'ParentNode' if its not empty
if (!isEmptyElement)
{
parentNode = newNode;
}
}
}
// moving up to in TreeView if end tag is encountered
else if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.Name == XmlNodeTag)
{
if (parentNode != null)
{
parentNode = parentNode.Parent;
}
}
}
else if (reader.NodeType == XmlNodeType.XmlDeclaration)
{
//Ignore Xml Declaration
}
else if (reader.NodeType == XmlNodeType.None)
{
return;
}
else if (reader.NodeType == XmlNodeType.Text)
{
if (parentNode != null)
{
parentNode.Nodes.Add(reader.Value);
}
}
}
}
finally
{
// enabling redrawing of treeview after all nodes are added
treeView.EndUpdate();
if (reader != null)
{
reader.Close();
}
}
}
public NodeEventArgs(TreeNodeAdv node)
{
_node = node;
}
protected void OnCheckStateChanged(TreeNodeAdv node)
{
TreePath path = this.Parent.GetPath(node);
OnCheckStateChanged(new TreePathEventArgs(path));
}
protected override void DoApplyChanges(TreeNodeAdv node, Control editor)
{
SetValue(node, (editor as NumericTextBox).DecimalValue);
}
/// <summary>
/// Contains logic for determining if a drag/drop operation is legal. Additionally, specify doDrop = true to actually perform the drop (if it is legal).
/// </summary>
/// <param name="sourceNodes"></param>
/// <param name="targetNode"></param>
/// <param name="position"></param>
/// <param name="doDrop"></param>
/// <returns></returns>
public virtual bool CanDrop(TreeNodeAdv[] sourceNodes, TreeNodeAdv targetNode, NodePosition position)
{
if ((FilterActive && FilterMode == FilterMode.Flat) || sourceNodes == null || sourceNodes.Length == 0)
{
return(false);
}
DragInfo = TreeDragInformation.FromNodes(sourceNodes, targetNode, position);
// Must not drop nodes on themselves or any of their children:
if (sourceNodes.Contains(targetNode))
{
return(false);
}
if (sourceNodes.Any(n => targetNode.HasAncestor(n)))
{
return(false);
}
// Drag operations that require the source and destination table to be the same:
if (DragInfo.SameTable)
{
// Dragging foldered objects into or out of folders:
if (sourceNodes.All(n => n.Tag is IFolderObject))
{
if (targetNode.Tag is IFolder)
{
return(SetDropMode(DropMode.Folder));
}
}
// Dragging into a hierarchy:
if (DragInfo.TargetHierarchy != null)
{
// Dragging levels within a hierarchy or between hierarchies:
if (sourceNodes.All(n => n.Tag is Level))
{
return(SetDropMode(DragInfo.SameHierarchy ? DropMode.ReorderLevels : DropMode.MoveLevels));
}
// Dragging columns into a hierarchy:
if (sourceNodes.All(n => n.Tag is Column))
{
// Prevent drop if the hierarchy already contains the dragged column(s) as a level:
if (DragInfo.TargetHierarchy.Levels.Any(l => sourceNodes.Select(n => n.Tag as Column).Contains(l.Column)))
{
return(false);
}
return(SetDropMode(DropMode.AddColumns));
}
}
}
else
{
// Dragging measures and calculated columns between tables is also allowed:
if (sourceNodes.All(n => n.Tag is CalculatedColumn || n.Tag is Measure))
{
if (targetNode.Tag is Table && position == NodePosition.Inside)
{
return(SetDropMode(DropMode.MoveObject));
}
}
}
// Dragging into a calculation group:
if (DragInfo.TargetCalculationGroup != null)
{
// Dragging calculation items within a calculation group or between calculation groups:
if (sourceNodes.All(n => n.Tag is CalculationItem ci))
{
return(SetDropMode(DragInfo.SameCalculationGroup ? DropMode.ReorderCalcItems : DropMode.MoveCalcItems));
}
}
// All other cases not allowed:
return(false);
}
protected override void DoApplyChanges(TreeNodeAdv node)
{
SetValue(node, _selectedItem);
}
protected override void DoApplyChanges(TreeNodeAdv node, Control editor)
{
SetValue(node, (editor as NumericUpDown).Value);
}
public EditEventArgs(TreeNodeAdv node, Control control)
: base(node)
{
_control = control;
}
protected virtual Image GetIcon(TreeNodeAdv node)
{
return(GetValue(node) as Image);
}
public string GetToolTip(TreeNodeAdv node, NodeControl nodeControl)
{
return("Drag&Drop nodes to move them");
}
public override Size MeasureSize(TreeNodeAdv node, DrawContext context)
{
return(new Size(ImageSize, ImageSize));
}
protected override Image GetIcon(TreeNodeAdv node)
{
if (node.Tag is Node subnode && subnode.Tag is OutlookTask)
{
return(task);
}
protected Size GetLabelSize(TreeNodeAdv node, DrawContext context)
{
return(GetLabelSize(node, context, GetLabel(node)));
}
public string GetToolTip(TreeNodeAdv node, NodeControl nodeControl)
{
// TODO
return(string.Empty);
}
public override Size MeasureSize(TreeNodeAdv node, DrawContext context)
{
return(new Size(Width, Width));
}
public override Size MeasureSize(TreeNodeAdv node)
{
return(new Size(Width, Width));
}
public override Size MeasureSize(TreeNodeAdv node, DrawContext context)
{
return(ResourceHelper.LoadingIcon.FrameSize);
}
private void LoadSettings()
{
// General
_font = Settings.Instance.Font;
buttonFont.Font = _font;
textUpdateInterval.Value = Settings.Instance.RefreshInterval;
textIconMenuProcesses.Value = Settings.Instance.IconMenuProcessCount;
textMaxSamples.Value = Settings.Instance.MaxSamples;
textStep.Value = Settings.Instance.PlotterStep;
textSearchEngine.Text = Settings.Instance.SearchEngine;
comboSizeUnits.SelectedItem =
Utils.SizeUnitNames[Settings.Instance.UnitSpecifier];
checkWarnDangerous.Checked = Settings.Instance.WarnDangerous;
checkShowProcessDomains.Checked = Settings.Instance.ShowAccountDomains;
checkHideWhenMinimized.Checked = Settings.Instance.HideWhenMinimized;
checkHideWhenClosed.Checked = Settings.Instance.HideWhenClosed;
checkAllowOnlyOneInstance.Checked = Settings.Instance.AllowOnlyOneInstance;
checkVerifySignatures.Checked = Settings.Instance.VerifySignatures;
checkHideHandlesWithNoName.Checked = Settings.Instance.HideHandlesWithNoName;
checkEnableKPH.Enabled = OSVersion.Architecture == OSArch.I386;
checkEnableKPH.Checked = Settings.Instance.EnableKPH;
checkEnableExperimentalFeatures.Checked = Settings.Instance.EnableExperimentalFeatures;
checkStartHidden.Checked = Settings.Instance.StartHidden;
checkScrollDownProcessTree.Checked = Settings.Instance.ScrollDownProcessTree;
checkFloatChildWindows.Checked = Settings.Instance.FloatChildWindows;
checkHidePhConnections.Checked = Settings.Instance.HideProcessHackerNetworkConnections;
if (OSVersion.HasUac)
{
comboElevationLevel.SelectedIndex = Settings.Instance.ElevationLevel;
}
else
{
comboElevationLevel.SelectedIndex = 0;
}
textImposterNames.Text = Settings.Instance.ImposterNames;
switch (Settings.Instance.ToolStripDisplayStyle)
{
case 0:
comboToolbarStyle.SelectedIndex = 0;
break;
case 1:
comboToolbarStyle.SelectedIndex = 1;
break;
case 2:
comboToolbarStyle.SelectedIndex = 2;
break;
default:
comboToolbarStyle.SelectedIndex = 1;
break;
}
// Highlighting
textHighlightingDuration.Value = Settings.Instance.HighlightingDuration;
colorNewProcesses.Color = Settings.Instance.ColorNew;
colorRemovedProcesses.Color = Settings.Instance.ColorRemoved;
foreach (ListViewItem item in listHighlightingColors.Items)
{
Color c = (Color)Settings.Instance[item.Name];
bool use = (bool)Settings.Instance["Use" + item.Name];
item.BackColor = c;
item.ForeColor = TreeNodeAdv.GetForeColor(item.BackColor);
item.Checked = use;
}
// Plotting
checkPlotterAntialias.Checked = Settings.Instance.PlotterAntialias;
colorCPUKT.Color = Settings.Instance.PlotterCPUKernelColor;
colorCPUUT.Color = Settings.Instance.PlotterCPUUserColor;
colorMemoryPB.Color = Settings.Instance.PlotterMemoryPrivateColor;
colorMemoryWS.Color = Settings.Instance.PlotterMemoryWSColor;
colorIORO.Color = Settings.Instance.PlotterIOROColor;
colorIOW.Color = Settings.Instance.PlotterIOWColor;
// Replace Task Manager
// See if we can write to the key.
try
{
var key = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(
"Software\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options",
true
);
try
{
if (!Array.Exists <string>(key.GetSubKeyNames(), s => s.Equals("taskmgr.exe", StringComparison.OrdinalIgnoreCase)))
{
key.CreateSubKey("taskmgr.exe");
}
Microsoft.Win32.Registry.LocalMachine.OpenSubKey(
"Software\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\taskmgr.exe",
true
).Close();
}
finally
{
key.Close();
}
}
catch
{
checkReplaceTaskManager.Enabled = false;
}
try
{
using (var key = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(
"Software\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\taskmgr.exe",
false
))
{
if ((_oldTaskMgrDebugger = (string)key.GetValue("Debugger", "")).Trim('"').Equals(
ProcessHandle.Current.GetMainModule().FileName, StringComparison.OrdinalIgnoreCase))
{
checkReplaceTaskManager.Checked = true;
}
else
{
checkReplaceTaskManager.Checked = false;
}
}
}
catch
{
checkReplaceTaskManager.Enabled = false;
}
// Symbols
try
{
_oldDbghelp = textDbghelpPath.Text = Settings.Instance.DbgHelpPath;
textSearchPath.Text = Settings.Instance.DbgHelpSearchPath;
checkUndecorate.Checked = Settings.Instance.DbgHelpUndecorate;
}
catch
{ }
checkUpdateAutomatically.Checked = Settings.Instance.AppUpdateAutomatic;
switch ((AppUpdateLevel)Settings.Instance.AppUpdateLevel)
{
case AppUpdateLevel.Stable:
default:
optUpdateStable.Checked = true;
break;
case AppUpdateLevel.Beta:
optUpdateBeta.Checked = true;
break;
case AppUpdateLevel.Alpha:
optUpdateAlpha.Checked = true;
break;
}
}
/// <summary>
/// Обновление дерева на основе текущих устройств проекта.
/// </summary>
///
/// <param name="deviceManager">Менеджер устройств проекта.</param>
/// <param name="checkedDev">Выбранные устройства.</param>
private void Refresh(Device.DeviceManager deviceManager,
string checkedDev)
{
devicesTreeViewAdv.BeginUpdate();
devicesTreeViewAdv.Model = null;
devicesTreeViewAdv.Refresh();
TreeModel treeModel = new TreeModel();
Node root = new Node("Устройства проекта");
treeModel.Nodes.Add(root);
foreach (Device.DeviceType devType in Enum.GetValues(typeof(Device.DeviceType)))
{
Node r = new Node(devType.ToString());
r.Tag = devType;
root.Nodes.Add(r);
}
int[] countDev = new int[Enum.GetValues(typeof(Device.DeviceType)).Length];
//Заполняем узлы дерева устройствами.
foreach (Device.IODevice dev in deviceManager.Devices)
{
Node parent = null;
Node devNode = null;
foreach (Node node in root.Nodes)
{
if ((Device.DeviceType)node.Tag == dev.DeviceType)
{
parent = node;
break;
}
}
//Не найден тип устройства.
if (parent == null)
{
break;
}
// Если есть символы переноса строки
string result = "";
if (dev.Description.Contains('\n'))
{
string[] devDescr = dev.Description.Split('\n');
foreach (string str in devDescr)
{
result += str + " ";
}
}
else
{
result = dev.Description;
}
if (dev.ObjectName != "")
{
string objectName = dev.ObjectName + dev.ObjectNumber;
Node devParent = null;
foreach (Node node in parent.Nodes)
{
if ((node.Tag is String) &&
(string)node.Tag == objectName)
{
devParent = node;
break;
}
}
if (devParent == null)
{
devParent = new Node(objectName);
devParent.Tag = objectName;
parent.Nodes.Add(devParent);
}
devNode = new Node(dev.DeviceType + dev.DeviceNumber.ToString() + "\t " + result);
devNode.Tag = dev;
devParent.Nodes.Add(devNode);
}
else
{
devNode = new Node(dev.name + "\t " + result);
devNode.Tag = dev;
parent.Nodes.Add(devNode);
}
//Check.
checkedDev = ' ' + checkedDev + ' ';
if (checkedDev != " " && checkedDev.Contains(' ' + dev.Name + ' '))
{
devNode.CheckState = CheckState.Checked;
}
else
{
devNode.CheckState = CheckState.Unchecked;
}
bool isDevVisible = false;
if (prevShowChannels)
{
Node newNodeCh = null;
//Показываем каналы.
foreach (Device.IODevice.IOChannel ch in dev.Channels)
{
if (!ch.IsEmpty())
{
newNodeCh = new Node(ch.Name + " " + ch.Comment +
$" (A{ch.FullModule}:" + ch.PhysicalClamp + ")");
newNodeCh.Tag = ch;
devNode.Nodes.Add(newNodeCh);
if (noAssigmentBtn.Checked)
{
newNodeCh.IsHidden = true;
}
else
{
isDevVisible = true;
}
}
else
{
newNodeCh = new Node(ch.Name + " " + ch.Comment);
newNodeCh.Tag = ch;
devNode.Nodes.Add(newNodeCh);
isDevVisible = true;
}
}
}
//Пропускаем устройства ненужных типов.
if (devTypesLastSelected != null &&
!devTypesLastSelected.Contains(dev.DeviceType))
{
devNode.IsHidden = true;
}
else
{
if (devSubTypesLastSelected != null &&
!devSubTypesLastSelected.Contains(dev.DeviceSubType))
{
devNode.IsHidden = true;
}
else
{
if (prevShowChannels && !isDevVisible)
{
devNode.IsHidden = true;
}
else
{
countDev[(int)dev.DeviceType]++;
}
}
}
}
//Обновляем названия строк (добавляем количество устройств).
int idx = 0;
int total = 0;
foreach (Device.DeviceType devType in Enum.GetValues(typeof(Device.DeviceType)))
{
foreach (Node node in root.Nodes)
{
if ((Device.DeviceType)node.Tag == devType)
{
total += countDev[idx];
node.Text = devType.ToString() + " (" + countDev[idx++] + ") ";
break;
}
}
}
root.Text = "Устройства проекта (" + total + ")";
// Сортировка узлов
List <Node> rootNodes = treeModel.Nodes.ToList();
// [0] - узловой с названием проекта
List <Node> nodeNodes = rootNodes[0].Nodes.ToList();
// Сортируем узлы внутри каждого устройства Device
foreach (Node node in nodeNodes)
{
TreeSort(node.Nodes.ToList(), node);
}
devicesTreeViewAdv.Model = treeModel;
List <TreeNodeAdv> nodes = devicesTreeViewAdv.AllNodes.ToList();
TreeNodeAdv treeNode = nodes[0];
OnHideOperationTree.Execute(treeNode);
devicesTreeViewAdv.ExpandAll();
devicesTreeViewAdv.Refresh();
devicesTreeViewAdv.EndUpdate();
}
/// <summary>
///
/// </summary>
private void SetupFileSystem()
{
RequestedBuildPaths.Clear();
Model.Nodes.Clear();
BuildFileSystem = new VirtualFileSystem();
BuildFileSystem.ChildrenRefreshInterval = 5 * 1000;
BuildFileSystem.AutoRefreshChildren = false;
BuildFileSystem.OnRequestChildren += (FileSystem, Path) =>
{
if (Program.NetClient != null)
{
RequestedBuildPaths.Add(Path);
Program.NetClient.RequestBuilds(Path);
}
};
BuildFileSystem.OnNodeUpdated += (FileSystem, Node) =>
{
Node ModelNode = GetNodeByPath(Node.Path);
if (ModelNode != null)
{
UpdateNode(ModelNode as DownloadFileSystemTreeNode, Node);
}
MainTreeView.Refresh();
};
BuildFileSystem.OnNodeAdded += (FileSystem, Node) =>
{
// Ignore internal parts of the heirarchy.
if (Node.Path.Contains("$") && !ShowInternal)
{
return;
}
Collection <Node> NodeCollection = Model.Root.Nodes;
if (Node.Parent != null && Node.Parent.Name != "")
{
NodeCollection = GetNodeByPath(Node.Parent.Path).Nodes;
}
DownloadFileSystemTreeNode TrNode = new DownloadFileSystemTreeNode();
TrNode.IsBuildContainer = false;
DateTime SortTime = DateTime.UtcNow;
if (Node.Metadata != null)
{
NetMessage_GetBuildsResponse.BuildInfo BuildInfo = (NetMessage_GetBuildsResponse.BuildInfo)Node.Metadata;
SortTime = Node.CreateTime;
}
// Insert based on create time.
bool Inserted = false;
for (int i = 0; i < NodeCollection.Count; i++)
{
DownloadFileSystemTreeNode SubNode = NodeCollection[i] as DownloadFileSystemTreeNode;
if (SubNode != null && (SubNode.CreateTime.Ticks - SortTime.Ticks) < -10000000) // At least a second off.
{
NodeCollection.Insert(i, TrNode);
Inserted = true;
break;
}
}
if (!Inserted)
{
NodeCollection.Add(TrNode);
}
UpdateNode(TrNode, Node);
// If parent node is expanded, then request all children of this node.
TreeNodeAdv ParentViewNode = null;
if (TrNode.Parent != null)
{
DownloadFileSystemTreeNode ParentNode = TrNode.Parent as DownloadFileSystemTreeNode;
if (ParentNode != null)
{
ParentViewNode = GetViewNodeByPath(ParentNode.FullPath);
}
else
{
ParentViewNode = MainTreeView.Root;
}
}
if (ParentViewNode == null || ParentViewNode.IsExpanded)
{
if (!TrNode.IsBuild)
{
BuildFileSystem.GetChildrenNames(Node.Path);
}
}
MainTreeView.FullUpdate();
SelectNextPath();
OnDateUpdated?.Invoke(this, null);
};
BuildFileSystem.OnNodeRemoved += (FileSystem, Node) =>
{
// Ignore internal parts of the heirarchy.
if (Node.Path.Contains("$") && !ShowInternal)
{
return;
}
Node ModelNode = GetNodeByPath(Node.Path);
if (ModelNode != null && ModelNode.Parent != null)
{
ModelNode.Parent.Nodes.Remove(ModelNode);
}
};
BuildFileSystem.Init();
}
void rolesTreeView_ItemDrag(object sender, ItemDragEventArgs e)
{
TreeNodeAdv[] nodes = new TreeNodeAdv[rolesTreeView.SelectedNodes.Count];
rolesTreeView.SelectedNodes.CopyTo(nodes, 0);
DoDragDrop(nodes, DragDropEffects.Move);
}
public override Size MeasureSize(TreeNodeAdv node, DrawContext context)
{
return(_gif.FrameSize);
}
public Type GetPropertyType(TreeNodeAdv node)
{
return(GetMemberAdapter(node).MemberType);
}
protected virtual bool DrawIconMustBeFired(TreeNodeAdv node)
{
return(DrawIcon != null || (node.Tree != null && node.Tree.DrawControlMustBeFired()));
}
public override void Draw(TreeNodeAdv node, DrawContext context)
{
Image image = GetIcon(node);
if (image != null)
{
Rectangle r = GetBounds(node, context);
if (image.Width > 0 && image.Height > 0)
{
float factor = 1.0f;
switch (_scaleMode)
{
case ImageScaleMode.Fit:
factor = -1.0f;
break;
case ImageScaleMode.ScaleDown:
factor = Math.Min((float)r.Width / (float)image.Width, (float)r.Height / (float)image.Height);
factor = Math.Min(factor, 1.0f);
break;
case ImageScaleMode.ScaleUp:
factor = Math.Min((float)r.Width / (float)image.Width, (float)r.Height / (float)image.Height);
factor = Math.Max(factor, 1.0f);
break;
case ImageScaleMode.AlwaysScale:
float fx = (float)r.Width / (float)image.Width;
float fy = (float)r.Height / (float)image.Height;
if (Math.Min(fx, fy) < 1)
{
factor = Math.Min(fx, fy);
}
else if (Math.Max(fx, fy) > 1)
{
factor = Math.Max(fx, fy);
}
else
{
factor = 1.0f;
}
break;
default:
case ImageScaleMode.Clip:
factor = 1.0f;
break;
}
if (DrawIconMustBeFired(node))
{
DrawIconEventArgs iconDrawArgs = new DrawIconEventArgs(node, this, context);
OnDrawIcon(iconDrawArgs);
if (iconDrawArgs.IconColorMatrix != null)
{
ImageAttributes attrib = new ImageAttributes();
attrib.SetColorMatrix(iconDrawArgs.IconColorMatrix);
Rectangle destRect;
if (factor < 0.0f)
{
destRect = r;
}
else
{
destRect = new Rectangle(r.X, r.Y, (int)(image.Width * factor), (int)(image.Height * factor));
}
context.Graphics.DrawImage(image, destRect, 0, 0, image.Width, image.Height, GraphicsUnit.Pixel, attrib);
}
else
{
if (factor < 0.0f)
{
context.Graphics.DrawImage(image, r);
}
else if (factor == 1.0f)
{
context.Graphics.DrawImage(image, r.X, r.Y, image.Width, image.Height);
}
else
{
context.Graphics.DrawImage(image, r.X, r.Y, image.Width * factor, image.Height * factor);
}
}
}
else
{
if (factor < 0.0f)
{
context.Graphics.DrawImage(image, r);
}
else if (factor == 1.0f)
{
context.Graphics.DrawImage(image, r.X, r.Y, image.Width, image.Height);
}
else
{
context.Graphics.DrawImage(image, r.X, r.Y, image.Width * factor, image.Height * factor);
}
}
}
}
}
