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 TreeNodeImpl(TreeViewImpl treeViewImpl, TreeNodeData data)
{
Debug.Assert(data.TreeNode == null);
TreeView = treeViewImpl;
nodeList = new SharpTreeNodeChildrenList(this);
Data = data;
Data.TreeNode = this;
}
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;
}
