private void FolderContextMenu_OpenWithExplorer_Click(object sender, EventArgs e) { TreeNode Node = (TreeNode)FolderContextMenu.Tag; TreeNodeData NodeData = (TreeNodeData)Node.Tag; Process.Start("explorer.exe", String.Format("\"{0}\"", NodeData.Folder.Directory.FullName)); }
public void LoadChildren(ITransactionController transactionController, TreeNodeData<ActionKey> node) { ClaimHeaderDto headerDto = ((ClaimModel)transactionController.Model).HeaderDto; List<DtoBase> invToLoad = headerDto.ClaimVehicleInvolvements.Where(x => x.ClaimInsuredObject.ClaimIOVehicles == null).ToList<DtoBase>(); this.LoadInvolvements(transactionController, node, headerDto.ClaimVehicleInvolvements, invToLoad, Xiap.Metadata.Data.Enums.StaticValues.InternalIOType.Vehicle); }
public void FollowNode(TreeNodeData node, bool newTab, bool?useCodeRef) { var tokNode = node as IMDTokenNode; var @ref = tokNode?.Reference; var entityNode = node as EntityNode; var srcRef = entityNode?.SourceRef; bool code = useCodeRef ?? srcRef != null; if (code) { if (srcRef == null) { return; } documentTabService.FollowReference(srcRef.Value.Method, newTab, true, a => { if (!a.HasMovedCaret && a.Success && srcRef != null) { a.HasMovedCaret = GoTo(a.Tab, srcRef.Value.Method, srcRef.Value.ILOffset, srcRef.Value.Reference); } }); } else { if (@ref == null) { return; } documentTabService.FollowReference(@ref, newTab); } }
public static void CancelSelfAndChildren(TreeNodeData node) { foreach (var c in node.DescendantsAndSelf()) { var id = c as IAsyncCancellable; if (id != null) id.Cancel(); } }
protected bool IsEnumerableProperty(TreeNodeData currentNodeData, PropertyInfo property) { GinArgumentCommandAttribute attr = (GinArgumentCommandAttribute)property.GetCustomAttributes(typeof(GinArgumentCommandAttribute), false).FirstOrDefault(); bool isEnumerable = attr != null && attr.IsEnumerable; return(isEnumerable); }
private bool IsNotAcceptableType(TreeNodeData currentNodeData, Command newCommand) { bool accepted = false; if (currentNodeData.AcceptedTypes != null && currentNodeData.AcceptedTypes.Count() > 0) { foreach (var type in currentNodeData.AcceptedTypes) { accepted |= type.IsInstanceOfType(newCommand); } } else { accepted |= true; } if (currentNodeData.NotAcceptedTypes != null && currentNodeData.NotAcceptedTypes.Count() > 0) { foreach (var type in currentNodeData.NotAcceptedTypes) { accepted &= !type.IsInstanceOfType(newCommand); } } else { accepted &= true; } return(!accepted); }
private bool InsertCommandIntoPropertyNode(TreeNodeData currentNodeData, PropertyInfo property, Command newCommand) { if (IsEmptyProperty(currentNodeData, property)) { return(ReplaceCommandIntoProperty(currentNodeData, newCommand)); } if (IsEnumerableProperty(currentNodeData, property)) { CommandTreeNode node = currentNodeData.Node; if (currentNodeData.Property == null || currentNodeData.Property != property) { IEnumerable <CommandTreeNode> childs = currentNodeData.Node.Childs; node = childs.Where(c => c.Data.Property == property).FirstOrDefault(); } AppendCommandAfter(node, newCommand, null); return(true); } else { AppendNodeType appendType = AskUserToDo(); switch (appendType) { case AppendNodeType.Append: CommandTreeNode sequenceTreeNode = IntermediateWithSequence(currentNodeData); AppendCommandAfter(sequenceTreeNode, newCommand, null); return(true); case AppendNodeType.Replace: return(ReplaceCommandIntoProperty(currentNodeData, newCommand)); } } return(false); }
/// <summary> /// Constructor /// </summary> /// <param name="text">Text to classify</param> /// <param name="treeView">Treeview</param> /// <param name="node">Node to classify</param> /// <param name="isToolTip">true if the content will be shown in a tooltip</param> /// <param name="colorize">true if it should be colorized</param> /// <param name="colors">Default colors or null. It doesn't have to be sorted and elements can overlap. The colors /// must be <see cref="IClassificationType"/>s or <see cref="TextColor"/>s</param> public TreeViewNodeClassifierContext(string text, ITreeView treeView, TreeNodeData node, bool isToolTip, bool colorize, IReadOnlyCollection <SpanData <object> > colors = null) : base(text, string.Empty, colorize, colors) { TreeView = treeView ?? throw new ArgumentNullException(nameof(treeView)); Node = node ?? throw new ArgumentNullException(nameof(node)); IsToolTip = isToolTip; }
public static void ValidateOutputs(this TreeNodeData treeData) { foreach (var data in treeData) { data.ValideteOutputs(treeData); } }
private static TreeNodeData GetLogTreeNodeData(KeyValuePair <string, JToken> token) { var nodeData = new TreeNodeData(token.Key); nodeData.Value = token.Value.ToString(); return(nodeData); }
public TreeNodeImpl(TreeViewImpl treeViewImpl, TreeNodeData data) { Debug.Assert(data.TreeNode == null); TreeView = treeViewImpl; nodeList = new SharpTreeNodeChildrenList(this); Data = data; Data.TreeNode = this; }
private void RefreshPopControl(int rowindex) { cmbAxisChar.Items.Clear(); TreeNodeData data = m_DataSource[rowindex]; int size = data.DataSource.ColumnCount; int i; for (i = 0; i < size; ++i) { cmbAxisChar.Items.Add(data.DataSource.GetColumnsList()[i]); } cmbAxisX.Items.Clear(); cmbAxisX.Items.Add((ctcMainChart.Diagram as DevExpress.XtraCharts.XYDiagram).AxisX.ToString()); var axesx = (ctcMainChart.Diagram as DevExpress.XtraCharts.XYDiagram).SecondaryAxesX; size = axesx.Count; for (i = 0; i < size; ++i) { cmbAxisX.Items.Add(axesx[i].Name); } cmbAxisY.Items.Clear(); cmbAxisY.Items.Add((ctcMainChart.Diagram as DevExpress.XtraCharts.XYDiagram).AxisY.ToString()); var axesy = (ctcMainChart.Diagram as DevExpress.XtraCharts.XYDiagram).SecondaryAxesY; size = axesy.Count; for (i = 0; i < size; ++i) { cmbAxisY.Items.Add(axesy[i].Name); } }
public static IGraph Convert(TreeNodeData treeNode) { IGraph outputGraph = new Graph(); CxViewerAction.CxVSWebService.CxWSResultPath[] paths = PerspectiveHelper.GetResultPathsForQuery(treeNode.ScanId, treeNode.Id); treeNode.QueryResult.Paths = ConvertAllNodesToPathes(paths, treeNode.Id, treeNode.QueryResult); outputGraph.Severity = treeNode.Severity; outputGraph.Paths = new List <GraphPath>(); for (int i = 0; i < paths.Length; i++) { ReportQueryItemResult path = new ReportQueryItemResult() { Column = paths[i].Nodes[0].Column, FileName = paths[i].Nodes[0].FileName, Line = paths[i].Nodes[0].Line, NodeId = paths[i].Nodes[0].PathNodeId, PathId = paths[i].PathId, Query = treeNode.QueryResult }; path.Paths = ConvertNodesToPathes(paths[i].Nodes, treeNode.QueryResult, path); outputGraph.AddNewPath(Convert(path, i)); } return(outputGraph); }
public int Compare(TreeNodeData x, TreeNodeData y) { if (x == y) { return(0); } var a = x as ResourceElementNode; var b = y as ResourceElementNode; if (a == null) { return(-1); } if (b == null) { return(1); } int c = StringComparer.OrdinalIgnoreCase.Compare(a.ResourceElement.Name, b.ResourceElement.Name); if (c != 0) { return(c); } int cx = (int)a.ResourceElement.ResourceData.Code.FixUserType(); int cy = (int)b.ResourceElement.ResourceData.Code.FixUserType(); return(cx.CompareTo(cy)); }
internal override void Update(TreeNodeData tnd, bool allowUnsafeChanges, MainForm mf) { this.mf = mf; this.allowUnsafeChanges = allowUnsafeChanges; currentWindow = ((WindowData)tnd).Window; UpdateControls(); }
/// <summary> /// TreeNode构造函数 /// </summary> /// <param name="node"></param> public TreeNodeData(TreeNode node) { this.Text = node.Text; this.ImageIndex = node.ImageIndex; this.SelectedImageIndex = node.SelectedImageIndex; this.Checked = node.Checked; this.Expanded = node.IsExpanded; this.Nodes = new TreeNodeData[node.Nodes.Count]; if ((!(node.Tag == null)) && node.Tag.GetType().IsSerializable) { this.Tag = node.Tag; } else { this.Tag = null; } if (node.Nodes.Count == 0) { return; } for (int i = 0; i <= node.Nodes.Count - 1; i++) { Nodes[i] = new TreeNodeData(node.Nodes[i]); } }
public int Compare(TreeNodeData x, TreeNodeData y) { if (x == y) { return(0); } var a = x as ResourceNode; var b = y as ResourceNode; if (a == null) { return(-1); } if (b == null) { return(1); } int c = StringComparer.OrdinalIgnoreCase.Compare(a.Resource.Name, b.Resource.Name); if (c != 0) { return(c); } return(a.Resource.MDToken.Raw.CompareTo(b.Resource.MDToken.Raw)); }
private void SetSelectedOnChildren(TreeNode ParentNode, SelectionType Type) { TreeNodeData ParentNodeData = (TreeNodeData)ParentNode.Tag; int NewNumSelectedFiles = 0; switch (Type) { case SelectionType.All: NewNumSelectedFiles = ParentNodeData.NumFiles; break; case SelectionType.Empty: NewNumSelectedFiles = ParentNodeData.NumEmptySelectedFiles; break; case SelectionType.SafeToDelete: NewNumSelectedFiles = ParentNodeData.NumDefaultSelectedFiles; break; case SelectionType.None: NewNumSelectedFiles = 0; break; } if (NewNumSelectedFiles != ParentNodeData.NumSelectedFiles) { foreach (TreeNode ChildNode in ParentNode.Nodes) { SetSelectedOnChildren(ChildNode, Type); } ParentNodeData.NumSelectedFiles = NewNumSelectedFiles; UpdateImage(ParentNode); } }
private void FindSelection(TreeNode Node, List <FileInfo> FilesToSync, List <FileInfo> FilesToDelete, List <DirectoryInfo> DirectoriesToDelete) { TreeNodeData NodeData = (TreeNodeData)Node.Tag; if (NodeData.File != null) { if (NodeData.NumSelectedFiles > 0) { if (NodeData.Action == TreeNodeAction.Delete) { FilesToDelete.Add(NodeData.File); } else { FilesToSync.Add(NodeData.File); } } } else { foreach (TreeNode ChildNode in Node.Nodes) { FindSelection(ChildNode, FilesToSync, FilesToDelete, DirectoriesToDelete); } if (NodeData.Folder != null && NodeData.Folder.bEmptyAfterClean && NodeData.NumSelectedFiles == NodeData.NumFiles) { DirectoriesToDelete.Add(NodeData.Folder.Directory); } } }
private void populateExamplesTree(string examplesDefinitionFile, string componentName) { if (!File.Exists(examplesDefinitionFile)) { //dispay error message return; } examplesTree.Nodes.Clear(); TreeNode parentNode = examplesTree.Nodes.Add(componentName); TreeNodeData treeNodeData = new TreeNodeData(); treeNodeData.Path = ""; parentNode.Tag = treeNodeData; XElement data = XElement.Load(examplesDefinitionFile); IEnumerable <XElement> folders = from c in data.Elements("Folders") select c; parseFoldersTree(folders, parentNode); //do same with examples IEnumerable <XElement> examples = from c in data.Elements("Examples") select c; parseExamplesTree(examples, parentNode); parentNode.ExpandAll(); if (examplesTree.Nodes.Count > 0) { examplesTree.Nodes[0].EnsureVisible(); } }
public Graph(TreeNodeData treeNode) { IGraph graph = GraphHelper.Convert(treeNode); _paths = graph.Paths; _severity = graph.Severity; _maxRelations = graph.MaxRelations; }
public DeletedEventUpdater(ModuleDocumentNode modNode, EventDef originalEvent) { ownerNode = modNode.Context.DocumentTreeView.FindNode(originalEvent); if (ownerNode == null) throw new InvalidOperationException(); parentNode = ownerNode.TreeNode.Parent.Data; ownerType = originalEvent.DeclaringType; @event = originalEvent; }
public DeletedMethodUpdater(ModuleDocumentNode modNode, MethodDef originalMethod) { ownerNode = modNode.Context.DocumentTreeView.FindNode(originalMethod); if (ownerNode == null) throw new InvalidOperationException(); parentNode = ownerNode.TreeNode.Parent.Data; ownerType = originalMethod.DeclaringType; method = originalMethod; }
public DeletedPropertyUpdater(ModuleDocumentNode modNode, PropertyDef originalProperty) { ownerNode = modNode.Context.DocumentTreeView.FindNode(originalProperty); if (ownerNode == null) throw new InvalidOperationException(); parentNode = ownerNode.TreeNode.Parent.Data; ownerType = originalProperty.DeclaringType; property = originalProperty; }
public override IEnumerable <TreeNodeData> CreateChildren() { if (newChild != null) { yield return(newChild); } newChild = null; }
void IConfigDialogView.RemoveRootNode(TreeNodeData n) { var tn = treeView.Nodes.OfType <TreeNode>().FirstOrDefault(x => x.Tag == n); if (tn != null) { tn.Remove(); } }
private void AddTreeNode(ProductParameter model) { TreeNodeData n = new TreeNodeData() { id = model.id, Name = model.product_name, DisplayName = model.product_name }; ModelTrees.Add(n); }
public int Compare(TreeNodeData x, TreeNodeData y) { if (x == y) return 0; var a = x as MessageNode; var b = y as MessageNode; if (a == null) return -1; if (b == null) return 1; return 0; }
public TreeNodeData CreateNodeData() { var dataArray = _dataArray.Select(d => d.GenerateData()).ToArray(); var taskData = dataArray.Select(d => d as TaskNodeData).Where(d => d != null).ToArray(); var varData = dataArray.Select(d => d as FuncNodeData).Where(d => d != null).ToArray(); var data = new TreeNodeData(taskData, varData); return(data); }
/// <summary> /// Adds a new node /// </summary> /// <param name="node">New node</param> protected void AddNode(TreeNodeData node) { if (node == null) throw new ArgumentNullException(nameof(node)); lock (lockObj) { nodesToAdd.Add(node); if (nodesToAdd.Count == 1) ExecInUIThread(AddNodes_UI); } }
public DeletedTypeUpdater(ModuleDocumentNode modNode, TypeDef originalType) { ownerNode = modNode.Context.DocumentTreeView.FindNode(originalType); if (ownerNode == null) throw new InvalidOperationException(); parentNode = ownerNode.TreeNode.Parent.Data; ownerModule = originalType.Module; ownerType = originalType.DeclaringType; type = originalType; }
private TreeNode BuildTreeViewStructure(FolderToClean Folder, string FolderPath, bool bParentFolderSelected, int Depth) { bool bSelectFolder = bParentFolderSelected || IsSafeToDeleteFolder(FolderPath); TreeNodeData FolderNodeData = new TreeNodeData(); FolderNodeData.Folder = Folder; TreeNode FolderNode = new TreeNode(); FolderNode.Text = Folder.Name; FolderNode.Tag = FolderNodeData; foreach (FolderToClean SubFolder in Folder.SubFolders.OrderBy(x => x.Name)) { TreeNode ChildNode = BuildTreeViewStructure(SubFolder, FolderPath + SubFolder.Name.ToLowerInvariant() + "/", bSelectFolder, Depth + 1); FolderNode.Nodes.Add(ChildNode); TreeNodeData ChildNodeData = (TreeNodeData)ChildNode.Tag; FolderNodeData.NumFiles += ChildNodeData.NumFiles; FolderNodeData.NumSelectedFiles += ChildNodeData.NumSelectedFiles; } foreach (FileInfo File in Folder.FilesToClean.OrderBy(x => x.Name)) { string Name = File.Name.ToLowerInvariant(); bool bSelectFile = bSelectFolder || IsSafeToDeleteFile(FolderPath, File.Name.ToLowerInvariant()); TreeNodeData FileNodeData = new TreeNodeData(); FileNodeData.File = File; FileNodeData.NumFiles = 1; FileNodeData.NumSelectedFiles = bSelectFile? 1 : 0; TreeNode FileNode = new TreeNode(); FileNode.Text = File.Name; FileNode.Tag = FileNodeData; FolderNode.Nodes.Add(FileNode); UpdateImage(FileNode); FolderNodeData.NumFiles++; FolderNodeData.NumSelectedFiles += FileNodeData.NumSelectedFiles; } if (FolderNodeData.NumSelectedFiles > 0 && !FolderNodeData.Folder.bEmptyAfterDelete && Depth < 2) { FolderNode.Expand(); } else { FolderNode.Collapse(); } UpdateImage(FolderNode); return(FolderNode); }
private void TreeView_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e) { if (e.X >= e.Node.Bounds.Left - 32 && e.X < e.Node.Bounds.Left - 16) { TreeNode Node = e.Node; TreeNodeData NodeData = (TreeNodeData)Node.Tag; SetSelected(Node, NodeData.NumSelectedFiles == 0); } }
void IConfigDialogView.AddRootNode(TreeNodeData n) { EnsureLoaded(); var item = new TreeItem(null, n, evts); dataSource.Items.Add(item); treeView.ReloadData(); treeView.ExpandItem(item, expandChildren: false); }
public static bool ValideteOutputs(this NodeData nodeData, TreeNodeData treeData) { var enumerator = treeData.GetEnumerator(); var connectionsToRemove = new List <int>(); for (int i = 0; i < nodeData.Connections.Length; i++) { var connection = nodeData.Connections[i]; if (connection.InName == InputDescription.ExecutionInName) { continue; } NodeData inNode = null; enumerator.Reset(); while (enumerator.MoveNext()) { if (enumerator.Current.Index == connection.InNode) { inNode = enumerator.Current; break; } } if (inNode == null) { connectionsToRemove.Add(i); } else { var inputs = inNode.GetInputs(); var connectedInput = inputs.FirstOrDefault(input => input.IdName == connection.InName); if (connectedInput.IsValid) { if (connectedInput.PortType.FullName != connection.OutTypeName) { connectionsToRemove.Add(i); } } else { connectionsToRemove.Add(i); } } } bool changed = connectionsToRemove.Count > 0; if (changed) { nodeData.RemoveConnectionsWithIndices(connectionsToRemove.ToArray()); } return(changed); }
public override void Execute(TreeNodeData context) { var sb = new StringBuilder(); sb.AppendLine("TreeNodeData guid: " + context.Guid); sb.AppendLine("TreeNodeData type: " + context.GetType()); MsgBox.Instance.Show(sb.ToString()); }
public void SetDrop(System.IO.FileInfo[] fileInfos, TreeNodeData data) { _dropdownMgr.Clear(); foreach (var fileInfo in fileInfos) { _dropdownMgr.Add(fileInfo.Name); } _dropdownMgr.SetData(data); }
private void UpdateImage(TreeNode Node) { TreeNodeData NodeData = (TreeNodeData)Node.Tag; int ImageIndex = (NodeData.Folder != null)? 0 : 3; ImageIndex += (NodeData.NumSelectedFiles == 0)? 0 : (NodeData.NumSelectedFiles < NodeData.NumFiles || (NodeData.Folder != null && !NodeData.Folder.bEmptyAfterDelete))? 1 : 2; Node.ImageIndex = ImageIndex; Node.SelectedImageIndex = ImageIndex; }
// This fills the list of textures, depending on the selected texture set private void FillImagesList() { //mxd. Show root items if (selectedset == null) { FillCategoriesList(); return; } // Get the selected texture set IFilledTextureSet set = ((TreeNodeData)selectedset.Tag).Set; // Start adding browser.BeginAdding(false); //mxd. Add "Browse up" item if (selectedset.Parent != null) { TreeNodeData data = (TreeNodeData)selectedset.Parent.Tag; browser.AddFolder(ImageBrowserItemType.FOLDER_UP, data.FolderName); } else { browser.AddFolder(ImageBrowserItemType.FOLDER_UP, "All Texture Sets"); } //mxd. Add folders foreach (TreeNode child in selectedset.Nodes) { TreeNodeData data = (TreeNodeData)child.Tag; browser.AddFolder(ImageBrowserItemType.FOLDER, data.FolderName); } // Add textures if (browseflats) { // Add all available flats foreach (ImageData img in set.Flats) { browser.AddItem(img); } } else { // Add all available textures foreach (ImageData img in set.Textures) { browser.AddItem(img); } } browser.MakeTexturesUnique(); // biwa // Done adding browser.EndAdding(); }
/// <summary> /// Constructor /// </summary> /// <param name="targetNode">Target node that will be the parent of the new nodes</param> protected AsyncNodeProvider(TreeNodeData targetNode) { lockObj = new object(); this.targetNode = targetNode; dispatcher = Dispatcher.CurrentDispatcher; uiThreadActions = new List<Action>(); cancellationTokenSource = new CancellationTokenSource(); cancellationToken = cancellationTokenSource.Token; thread = new Thread(ThreadMethodImpl); thread.IsBackground = true; }
/// <summary> /// Constructor /// </summary> /// <param name="text">Text to classify</param> /// <param name="treeView">Treeview</param> /// <param name="node">Node to classify</param> /// <param name="isToolTip">true if the content will be shown in a tooltip</param> /// <param name="colorize">true if it should be colorized</param> /// <param name="colors">Default colors or null. It doesn't have to be sorted and elements can overlap. The colors /// must be <see cref="IClassificationType"/>s or <see cref="TextColor"/>s</param> public TreeViewNodeClassifierContext(string text, ITreeView treeView, TreeNodeData node, bool isToolTip, bool colorize, IReadOnlyCollection<SpanData<object>> colors = null) : base(text, string.Empty, colorize, colors) { if (treeView == null) throw new ArgumentNullException(nameof(treeView)); if (node == null) throw new ArgumentNullException(nameof(node)); TreeView = treeView; Node = node; IsToolTip = isToolTip; }
static IDsDocument GetDocument(TreeNodeData node) { var fileNode = node as DsDocumentNode; if (fileNode == null) return null; var peImage = fileNode.Document.PEImage; if (peImage == null) peImage = (fileNode.Document.ModuleDef as ModuleDefMD)?.MetaData?.PEImage; return peImage != null && peImage.IsMemoryMappedIO ? fileNode.Document : null; }
public void AddData(object target) { var targetform = target as MPPO.Protocol.Interface.IMdiDataForm<DataRow>; if (targetform == null) return; TreeNodeData aNode = new TreeNodeData(); aNode.Name = targetform.Caption; aNode.DataSource = targetform.GetDataTable(); aNode.SetDrawBoard(ctcMainChart); m_DataSource.Add(aNode); }
public void LoadChildren(XIAP.Frontend.Infrastructure.ITransactionController transactionController, TreeNodeData<ActionKey> node) { var headerDto = (ClaimHeaderDto)node.DataObject; List<DtoBase> toLoad = new List<DtoBase>(); List<DtoBase> invToLoad = headerDto.ClaimVehicleInvolvements.Where(x => x.ClaimInsuredObject.ClaimIOVehicles == null).ToList<DtoBase>(); if (headerDto.ClaimInvolvementLinks != null) { headerDto.ClaimVehicleInvolvements.ForEach(CI => { var involvementLinkFrom = headerDto.ClaimInvolvementLinks.Where(CIL => ((ClaimInvolvementLinkData)CIL.Data).ClaimInvolvementFromDataId == CI.Data.DataId); involvementLinkFrom.ForEach(y => { var involvement = headerDto.ClaimInvolvements.Where(z => z.Data.DataId == ((ClaimInvolvementLinkData)y.Data).ClaimInvolvementToDataId); invToLoad.AddRange(involvement); }); var involvementLinkTo = headerDto.ClaimInvolvementLinks.Where(CIL => ((ClaimInvolvementLinkData)CIL.Data).ClaimInvolvementToDataId == CI.Data.DataId); involvementLinkTo.ForEach(y => { var involvement = headerDto.ClaimInvolvements.Where(z => z.Data.DataId == ((ClaimInvolvementLinkData)y.Data).ClaimInvolvementFromDataId); invToLoad.AddRange(involvement); }); }); } int invToLoadCount = invToLoad.Distinct().Count(); int count = 0; if (invToLoad.Distinct().Any()) { transactionController.LoadLiteData( Guid.Empty, RetrievalType.WithChildHierarchy, invToLoad.Distinct(), NavigationType.None, null, r => { if (++count == invToLoadCount) { node.IsLoaded = true; } }, true, BusinessDataVariant.Full); } else { node.IsLoaded = true; } }
public List<TreeNodeData> CreateJsonTree(List<TreeView> data, string FactoryDesc) { List<TreeNodeData> treeList = new List<TreeNodeData>(); if (data.Count == 0) { treeList.Add(new TreeNodeData() { id = -100, text = FactoryDesc, textCss = "customnode", objecttype = "companyNode" }); } TreeNodeData parentTreeNode = new TreeNodeData(); CreateTreeNodes(data, ref treeList, ref parentTreeNode, false); return treeList; }
internal void AddPossibleResult(TreeNodeData data, string text) { if (!text.StartsWith(prefix)) return; if (regex != null && !regex.IsMatch(text)) return; if (!categoryNodes.ContainsKey(text)) { categoryNodes[text] = new TreeNode(text, 6, 6); } TreeNode tn = new TreeNode(data.Name, data.Icon, data.Icon); tn.Tag = data; categoryNodes[text].Nodes.Add(tn); }
/// <summary> /// </summary> /// <param name="treeview"></param> public TreeViewData(TreeView treeview) { Nodes = new TreeNodeData[treeview.Nodes.Count]; if (treeview.Nodes.Count == 0) { return; } for (int i = 0; i <= treeview.Nodes.Count - 1; i++) { Nodes[i] = new TreeNodeData(treeview.Nodes[i]); } }
protected void LoadInvolvements(ITransactionController transactionController, TreeNodeData<ActionKey> node, List<ClaimInvolvementDto> claimInvolvements, List<DtoBase> invToLoad, StaticValues.InternalIOType type) { ClaimHeaderDto headerDto = ((ClaimModel)transactionController.Model).HeaderDto; if (headerDto.ClaimInvolvementLinks != null) { claimInvolvements.ForEach(CI => { var involvementLinkFrom = headerDto.ClaimInvolvementLinks.Where(CIL => ((ClaimInvolvementLinkData)CIL.Data).ClaimInvolvementFromDataId == CI.Data.DataId); involvementLinkFrom.ForEach(y => { var involvement = headerDto.ClaimInvolvements.Where(z => z.Data.DataId == ((ClaimInvolvementLinkData)y.Data).ClaimInvolvementToDataId); invToLoad.AddRange(involvement); }); var involvementLinkTo = headerDto.ClaimInvolvementLinks.Where(CIL => ((ClaimInvolvementLinkData)CIL.Data).ClaimInvolvementToDataId == CI.Data.DataId); involvementLinkTo.ForEach(y => { var involvement = headerDto.ClaimInvolvements.Where(z => z.Data.DataId == ((ClaimInvolvementLinkData)y.Data).ClaimInvolvementFromDataId); invToLoad.AddRange(involvement); }); }); } int invToLoadCount = invToLoad.Distinct().Count(); int count = 0; if (invToLoad.Distinct().Any()) { transactionController.LoadLiteData( Guid.Empty, RetrievalType.WithChildHierarchy, invToLoad.Distinct(), NavigationType.None, null, r => { if (++count == invToLoadCount) { var model = (ClaimModel)transactionController.Model; model.CreateAllInsuredObjectCollection(type); node.IsLoaded = true; } }, true, BusinessDataVariant.Full); } else { node.IsLoaded = true; } }
public bool CanFollowNode(TreeNodeData node, bool useCodeRef) { var tokNode = node as IMDTokenNode; var @ref = tokNode?.Reference; var entityNode = node as EntityNode; var srcRef = entityNode?.SourceRef; if (useCodeRef) return srcRef != null; return @ref != null; }
internal virtual void Update(TreeNodeData tnd, bool allowUnsafeChanges, MainForm mf) { }
public override IEnumerable<TreeNodeData> CreateChildren() { if (newChild != null) yield return newChild; newChild = null; }
internal override void Update(TreeNodeData tnd, bool allowUnsafeChanges, MainForm mf) { currentThread = ((ThreadData)tnd).Thread; UpdateControls(); }
private TreeNode BuildTreeViewStructure(FolderToClean Folder, string FolderPath, bool bParentFolderSelected, int Depth) { bool bSelectFolder = bParentFolderSelected || IsSafeToDeleteFolder(FolderPath) || Folder.bEmptyLeaf; TreeNodeData FolderNodeData = new TreeNodeData(); FolderNodeData.Folder = Folder; TreeNode FolderNode = new TreeNode(); FolderNode.Text = Folder.Name; FolderNode.Tag = FolderNodeData; foreach(FolderToClean SubFolder in Folder.SubFolders.OrderBy(x => x.Name)) { TreeNode ChildNode = BuildTreeViewStructure(SubFolder, FolderPath + SubFolder.Name.ToLowerInvariant() + "/", bSelectFolder, Depth + 1); FolderNode.Nodes.Add(ChildNode); TreeNodeData ChildNodeData = (TreeNodeData)ChildNode.Tag; FolderNodeData.NumFiles += ChildNodeData.NumFiles; FolderNodeData.NumSelectedFiles += ChildNodeData.NumSelectedFiles; FolderNodeData.NumEmptySelectedFiles += ChildNodeData.NumEmptySelectedFiles; FolderNodeData.NumDefaultSelectedFiles += ChildNodeData.NumDefaultSelectedFiles; } foreach(FileInfo File in Folder.FilesToClean.OrderBy(x => x.Name)) { string Name = File.Name.ToLowerInvariant(); bool bSelectFile = bSelectFolder || IsSafeToDeleteFile(FolderPath, File.Name.ToLowerInvariant()); TreeNodeData FileNodeData = new TreeNodeData(); FileNodeData.File = File; FileNodeData.NumFiles = 1; FileNodeData.NumSelectedFiles = bSelectFile? 1 : 0; FileNodeData.NumEmptySelectedFiles = 0; FileNodeData.NumDefaultSelectedFiles = FileNodeData.NumSelectedFiles; TreeNode FileNode = new TreeNode(); FileNode.Text = File.Name; FileNode.Tag = FileNodeData; FolderNode.Nodes.Add(FileNode); UpdateImage(FileNode); FolderNodeData.NumFiles++; FolderNodeData.NumSelectedFiles += FileNodeData.NumSelectedFiles; FolderNodeData.NumEmptySelectedFiles += FileNodeData.NumEmptySelectedFiles; FolderNodeData.NumDefaultSelectedFiles += FileNodeData.NumDefaultSelectedFiles; } if(FolderNodeData.Folder.bEmptyLeaf) { FolderNodeData.NumFiles++; FolderNodeData.NumSelectedFiles++; FolderNodeData.NumEmptySelectedFiles++; FolderNodeData.NumDefaultSelectedFiles++; } if(FolderNodeData.NumSelectedFiles > 0 && !FolderNodeData.Folder.bEmptyAfterDelete && Depth < 2) { FolderNode.Expand(); } else { FolderNode.Collapse(); } UpdateImage(FolderNode); return FolderNode; }
public void LoadChildren(ITransactionController transactionController, TreeNodeData<ActionKey> node) { node.IsLoaded = true; }
/// <summary> /// Starts the drag and drop operation /// </summary> /// <param name="dragSource">Drag source</param> /// <param name="nodes">Nodes</param> public sealed override void StartDrag(DependencyObject dragSource, TreeNodeData[] nodes) { bool b = CanDrag(nodes); Debug.Assert(b); if (!b) return; DragDrop.DoDragDrop(dragSource, Copy(nodes), DragDropEffects.All); }
static string GetHeader(TreeNodeData[] nodes) { if (nodes.Length == 1) return string.Format(dnSpy_AsmEditor_Resources.RemoveCommand, UIUtilities.EscapeMenuItemHeader(nodes[0].ToString())); return string.Format(dnSpy_AsmEditor_Resources.RemoveAssembliesCommand, nodes.Length); }
public void FollowNode(TreeNodeData node, bool newTab, bool? useCodeRef) { var tokNode = node as IMDTokenNode; var @ref = tokNode?.Reference; var entityNode = node as EntityNode; var srcRef = entityNode?.SourceRef; bool code = useCodeRef ?? srcRef != null; if (code) { if (srcRef == null) return; documentTabService.FollowReference(srcRef.Value.Method, newTab, true, a => { if (!a.HasMovedCaret && a.Success && srcRef != null) a.HasMovedCaret = GoTo(a.Tab, srcRef.Value.Method, srcRef.Value.ILOffset, srcRef.Value.Reference); }); } else { if (@ref == null) return; documentTabService.FollowReference(@ref, newTab); } }
/// <summary> /// Copies nodes /// </summary> /// <param name="nodes">Nodes</param> /// <returns></returns> public sealed override IDataObject Copy(TreeNodeData[] nodes) { var dataObject = new DataObject(); if (!Context.CanDragAndDrop) return dataObject; var rootNode = Context.DocumentTreeView.TreeView.Root; var dict = new Dictionary<TreeNodeData, int>(); for (int i = 0; i < rootNode.Children.Count; i++) dict.Add(rootNode.Children[i].Data, i); var data = nodes.Where(a => dict.ContainsKey(a)).Select(a => dict[a]).ToArray(); if (data.Length != 0) dataObject.SetData(DocumentTreeViewConstants.DATAFORMAT_COPIED_ROOT_NODES, data); return dataObject; }
static IDsDocument GetCurrentExecutableAssembly(TreeNodeData node, bool mustBeNetExe) { var fileNode = (node as DocumentTreeNodeData).GetDocumentNode(); if (fileNode == null) return null; var file = fileNode.Document; var peImage = file.PEImage; if (peImage == null) return null; if ((peImage.ImageNTHeaders.FileHeader.Characteristics & Characteristics.Dll) != 0) return null; if (mustBeNetExe) { var mod = file.ModuleDef; if (mod == null) return null; if (mod.Assembly == null || mod.Assembly.ManifestModule != mod) return null; if (mod.ManagedEntryPoint == null && mod.NativeEntryPoint == 0) return null; } return file; }