// takes a Graphic instance
public GraphicNode(Graphic grp)
{
// how do you want to represent it
this.Text = grp.FileName;
// and this class 'knows' how to handle its children
Nodes.AddRange(grp.Symbols.Select(s => new SymbolNode(s)).ToArray());
}
public MsgLastTreeNode(TreeNode[] subNodes)
{
Name = @"lastTreeViewItem1";
Nodes.AddRange(subNodes);
Text = CultureService.Instance.GetString(CultureText.node_Last_Text);
SelectedImageKey = ImageKey = @"Refresh_16x16";
}
public void Refresh()
{
BuildNodes();
Nodes.Clear();
Nodes.AddRange(_nodes.ToArray());
}
/// <summary>
/// Create children
/// </summary>
protected override void CreateChildNodes()
{
LoadTable();
var pkg = table.Packages.First();
Nodes.AddRange(pkg.TypeSpecs.Select(x => new TableTypeSpecNode(x)).ToArray());
}
public ExternalFiles(FileData f)
{
ImageKey = "external file";
SelectedImageKey = "external file";
DataOffset = f.readOffset();
f.skip(4); //padding
int Size = f.readInt();
f.skip(4); //padding
Console.WriteLine("DataOffset " + DataOffset);
f.seek(DataOffset);
EmMagic = f.readString(f.pos(), 4);
if (EmMagic.Equals("BNTX")) //Textures
{
BNTX.Add(new BNTX(f));
Console.WriteLine("Found BNTX");
}
if (EmMagic.Equals("FSHA")) //Shader
{
// BFSHA.Add(new BFSHA(f));
Console.WriteLine("Found Shader");
}
Nodes.AddRange(BNTX.ToArray());
Nodes.AddRange(BFSHA.ToArray());
}
public void Load(Stream stream)
{
Text = FileName;
using (var reader = new FileReader(stream))
{
reader.ByteOrder = ByteOrder.BigEndian;
// validate signature
string fileSignature = reader.ReadString(4, Encoding.ASCII);
if (!SIGNATURE.Equals(fileSignature))
{
throw new InvalidOperationException($"Cannot read {fileSignature} file as {SIGNATURE}");
}
unknownHeaderData = reader.ReadBytes(0x2c);
// read sections
Nodes.AddRange(NodeBase.ReadNodes(reader, true));
}
CanSave = true;
ContextMenuStrip = new STContextMenuStrip();
ContextMenuStrip.Items.Add(new ToolStripMenuItem("Save", null, Save, Keys.Control | Keys.S));
}
//Any BFSHA data is optained by Ray's 010 Template from Wii U. Not too much has changed atleast from the first area of the bfsha but more research neeeds to be looked into.
public BFSHA(FileData f)
{
int temp = f.pos();
f.skip(8); //Magic
int Version = f.readInt();
int ByteOrderMark = f.readShort();
int HeaderSize = f.readShort();
int NameOffset = f.readInt();
int PathOffset = f.readInt();
int RelocationTableOffset = f.readInt();
int FileSize = f.readInt();
f.skip(16);
int ShaderModel = f.readInt();
f.skip(20);
int ModelArrayOffset = f.readInt();
f.skip(4); //padding
int ModelIndexArray = f.readInt();
f.skip(28);
StaticOptionCount = f.readShort();
f.seek(ModelArrayOffset + temp);
ShaderMdl.Add(new ShaderModel(f));
Nodes.AddRange(ShaderMdl.ToArray());
}
public virtual void ReadNode(FileReader reader, Header header)
{
using (reader.TemporarySeek(0x20))
{
// sometimes the header has more data
int extraHeaderSize = (int)(header.DataOffset - 0x20);
header.Extra = extraHeaderSize > 0 ? reader.ReadBytes(extraHeaderSize) : new byte[0];
UnknownHeader = header.Extra; // save it so it can be written verbatim
ReadBinaryData(reader, header);
}
if (header.AttributesOffset != Header.NULL_OFFSET)
{
using (reader.TemporarySeek(header.AttributesOffset))
{
var nodes = ReadNodes(reader);
Attributes.AddRange(nodes);
}
}
if (header.ChildrenOffset != Header.NULL_OFFSET)
{
using (reader.TemporarySeek(header.ChildrenOffset))
{
var nodes = ReadNodes(reader);
Children.AddRange(nodes);
Nodes.AddRange(nodes);
}
}
}
public void RefreshNodes()
{
Cursor.Current = Cursors.WaitCursor;
if (String.IsNullOrWhiteSpace(Filter))
{
List <ComTypeTreeNode> nodes = new List <ComTypeTreeNode>();
try
{
foreach (ComTypeLibrary comTypeLibrary in ComTypeManager.Instance.ComTypeLibraries)
{
ComTypeLibraryTreeNode comTypeLibraryTreeNode = new ComTypeLibraryTreeNode(comTypeLibrary);
nodes.Add(comTypeLibraryTreeNode);
RefreshNode(comTypeLibraryTreeNode);
}
}
catch
{
GlobalExceptionHandler.HandleException();
}
Nodes.Clear();
Nodes.AddRange(nodes.ToArray());
}
else
{
RefreshNodesFiltered();
}
Cursor.Current = Cursors.Default;
}
/// <summary>
/// Places the control in normal mode, optionally committing the search result.
/// </summary>
/// <param name="commit"></param>
private void LeaveSearchMode(bool commit)
{
_inSearchMode = false;
BeginUpdate();
ComboTreeNode searchSelectedNode = SelectedNode;
// clear and replace with normal nodes
Nodes.Clear();
Nodes.AddRange(_normalNodes);
if (commit)
{
OnCommitSearch(new CommitSearchEventArgs(searchSelectedNode));
}
else
{
SelectedNode = _normalSelectedNode;
}
EndUpdate();
DropDownControl.ProcessKeys = true;
Cursor = Cursors.Default;
}
/// <summary>
/// Applies the specified search result collection to the control by adding the nodes to the drop-down.
/// </summary>
/// <param name="results"></param>
private void ApplySearchResults(ComboTreeNodeCollection results)
{
if (InvokeRequired)
{
Invoke(new Action <ComboTreeNodeCollection>(ApplySearchResults), results);
}
else
{
if (_inSearchMode)
{
BeginUpdate();
Nodes.Clear();
if (results.Count > 0)
{
Nodes.AddRange(results);
}
else
{
Nodes.Add(new ComboTreeNode("(no results found)")
{
Selectable = false, FontStyle = FontStyle.Italic
});
}
EndUpdate();
}
}
}
// This function adds the resultant nodes to the TreeView.
// The resultant nodes must be put in e.Result by the above function
public virtual void OnAfterFirstExpandComplete(object sender, RunWorkerCompletedEventArgs e)
{
if (e.Error != null)
{
MessageBox.Show(e.Error.Message);
}
else
{
var oResult = e.Result as object[];
if (oResult == null)
{
return;
}
var arrChildren = oResult[0] as List <LazyTreeNode>;
if (arrChildren == null)
{
return;
}
TreeView.BeginUpdate();
Nodes.Clear();
Nodes.AddRange(arrChildren.ToArray());
IsLoaded = true;
TreeView.EndUpdate();
}
}
private void DisplayClasses(IEnumerable <TagDatum> references, bool loadTags = false)
{
var lookup = new Dictionary <TagClass, TreeNode>( );
foreach (var reference in references)
{
var path = reference.Path;
var tagClass = reference.Class;
var @class = ( string )tagClass;
// Don't process empty classes
if (tagClass == TagClass.Empty)
{
continue;
}
if (!lookup.ContainsKey(tagClass))
{
lookup.Add(tagClass, new ScenarioView.DirectoryNode(@class, @class));
}
if (!loadTags)
{
continue;
}
var node = new ScenarioView.GuerillaBlockReferenceNode(path, path, reference);
lookup[tagClass].Nodes.Add(node);
}
BeginUpdate( );
Nodes.Clear( );
Nodes.AddRange(lookup.Values.ToArray( ));
EndUpdate( );
}
private bool InternalCollapse(int count)
{
bool foundNodes = false;
for (int i = 0; i < Children.Count; i++)
{
var node = Children[i];
if (node.InternalCollapse(count))
{
return(true);
}
var newList = node.CheckIfCollapse(count);
if (newList == null)
{
continue;
}
Nodes.AddRange(newList);
Children.RemoveAt(i);
i--;
foundNodes = true;
}
return(foundNodes);
}
public void ReplaceContent(Node content)
{
if ((content is Widget) && (this is Widget))
{
((Widget)content).Size = (this as Widget).Size;
}
Animations.Clear();
var animations = content.Animations.ToList();
content.Animations.Clear();
Animations.AddRange(animations);
if ((content is Viewport3D) && (this is Node3D) && (content.Nodes.Count > 0))
{
// Handle a special case: the 3d scene is wrapped up with a Viewport3D.
var node = content.Nodes[0];
node.Unlink();
Nodes.Clear();
Nodes.Add(node);
}
else
{
var nodes = content.Nodes.ToList();
content.Nodes.Clear();
Nodes.Clear();
Nodes.AddRange(nodes);
}
RenderChainBuilder = content.RenderChainBuilder?.Clone(this);
Presenter = content.Presenter?.Clone();
PostPresenter = content.PostPresenter?.Clone();
Components = content.Components.Clone(this);
}
public TreeNode(string text, int imageIndex, int selectedImageIndex, TreeNode[] children) : this()
{
this.text = text;
this.imageIndex = imageIndex;
this.selectedImageIndex = selectedImageIndex;
Nodes.AddRange(children);
}
/// <summary>
/// Инициализация слоя
/// </summary>
/// <param name="time">время слоя</param>
/// <param name="opts">опции слоя</param>
/// <param name="initCellFunc">функция генерации ячеек</param>
/// <param name="initBoundFunc">функция генерации границ</param>
public virtual void InitLayer(double time, WBOneDemLayerOptions opts, Func <double, double, TCell> initCellFunc, Func <double, double, TBound> initBoundFunc)
{
Opt = opts;
Time = time;
Nodes?.Clear();
int indexOfFirstBound = Opt.LeftNodesCount % 2 == 0
? 1
: 0;
var nds = Enumerable.Range(0, Opt.AllNodesCount)
.Select(ind => {
double x = Opt.X_left + ind * Opt.H;
WBOneDemNode nd = ind % 2 == indexOfFirstBound
? (WBOneDemNode)initCellFunc(Time, x)
: (WBOneDemNode)initBoundFunc(Time, x);
nd.X = x;
return(nd);
});
Nodes.AddRange(nds);
InitLists();
NodeIndexing();
InitBoundCellRefs();
InitDataRefs();
}
public FSHP(FileData f)
{
ImageKey = "polygon";
SelectedImageKey = "polygon";
if (!f.readString(4).Equals("FSHP"))
{
throw new Exception("Error reading Mesh Shape");
}
f.skip(12); // padding
Text = f.readString(f.readOffset() + 2, -1);
f.skip(4); // padding
fvtxOffset = f.readOffset();
f.skip(4); // padding
int lodOffset = f.readOffset();
f.skip(4); // padding
int fsklIndexArrayOffset = f.readOffset();
f.skip(20); // padding
int boundingBoxOffset = f.readOffset();
f.skip(4); // padding
int BoundingRadiusOffset = f.readOffset();
f.skip(12); // padding
int flags = f.readInt();
int index = f.readShort();
fmatIndex = f.readShort();
singleBind = (short)f.readShort();
fvtxindex = f.readShort();
int SkinBoneIndexCount = f.readShort();
int VertexSkinCount = f.readByte();
int lodCount = f.readByte();
int visGroupCount = f.readInt();
int fsklarraycount = f.readShort();
// level of detail models
//IndexGroup fmdlGroup = new IndexGroup(f);
for (int i = 0; i < lodCount; i++)
{
f.seek(lodOffset + (i * 56));
var baseShape = new BaseRenderData.shape()
{
name = Text,
Index = index,
FvtxIndex = fvtxindex,
FmatIndex = fmatIndex,
};
lodModels.Add(new LODModel(f, baseShape));
}
Nodes.AddRange(lodModels.ToArray());
// visibility group
}
public DesignerVewModel()
{
var modules = Enumerable.Range(1, 10)
.Select(i => new DesignerModule($"Item {i}"))
.Select(m => new Node(m, null, m.Title, m.Icon, m.Nodes));
Nodes.AddRange(modules);
}
public void LoadLazyChildren()
{
if (IsEmpty())
{
Nodes.Clear();
treeNodeFactories.ToList().ForEach(f => Nodes.AddRange(f().ToArray()));
}
}
public NetworkViewModel(int taskNumber, NetworkType type,
int numberOfStates, int numberOfInputs, int numberOfOutputs,
ICollection <NodeViewModel> nodes, ICollection <ConnectionViewModel> connections)
: this(taskNumber, type, numberOfStates, numberOfInputs, numberOfOutputs)
{
Nodes.AddRange(nodes);
Connections.AddRange(connections);
}
public TreeNode(string text, TreeNode[] children)
{
this.text = text;
if (children != null)
{
Nodes.AddRange(children);
}
}
/// <summary>Appends a list of values</summary>
/// <param name="values">The values to append</param>
public void Add(IEnumerable <T> values)
{
var initialNodesCount = Nodes.Count;
Nodes.AddRange(values.Select(_ => new Node {
Value = _, ParentIndex = -1, Rank = 0
}));
SetsCount += Nodes.Count - initialNodesCount;
}
public void BeforeExpand()
{
if (IsExpanded)
{
return;
}
Nodes.Clear();
Nodes.AddRange(SubNodes.OrderBy(f => f.Text).ToArray());
}
public void Union(Component other)
{
Nodes.AddRange(other.Nodes);
Mines.AddRange(other.Mines);
foreach (var score in other.Scores)
{
Scores[score.Key] += score.Value;
}
}
public void Refresh()
{
Nodes.Clear();
if (DAT_MELEE != null)
{
Text = "Melee DAT";
Nodes.AddRange(DAT_MELEE.tree.ToArray());
if (vbn != null && vbn.Parent == null)
{
Nodes.Add(vbn);
}
}
else
if (bch != null)
{
Nodes.Add(bch);
}
else
{
if (nud != null)
{
Nodes.Add(nud);
}
if (nut != null)
{
Nodes.Add(nut);
}
if (vbn != null && vbn.Parent == null)
{
Nodes.Add(vbn);
}
if (mta != null)
{
Nodes.Add(mta);
}
if (moi != null)
{
Nodes.Add(moi);
}
if (jtb != null)
{
Nodes.Add(jtb);
}
if (xmb != null)
{
Nodes.Add(
new TreeNode()
{
Tag = xmb,
Text = "model.xmb",
ImageKey = "info",
SelectedImageKey = "info"
});
}
}
}
public MsgPeriodTimeTreeNode(MessageStatisticsItem message, TreeNode[] subNodes)
{
_messge = message;
Text = CultureService.Instance.GetString(CultureText.node_PeriodTime_Text) + @": ";
Text += (message.PeriodTime.HasValue ? message.PeriodTime.ToString() : AppConstants.ValueNotAvailable2) + @" ms";
SelectedImageKey = ImageKey = @"l_clock";
Nodes.AddRange(subNodes);
TimerService.Instance.Tick += new EventHandler(Timer_Tick);
message.DefaultStateComplete += (o, e) => Timer_Tick(null, EventArgs.Empty);
}
private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
TreeNode[] ctl = new TreeNode[subThreadView.Nodes.Count];
subThreadView.Nodes.CopyTo(ctl, 0);
subThreadView.Nodes.Clear();
Nodes.AddRange(ctl);
Visible = true;
ResumeLayout();
AddNodeRangeComplete?.Invoke(this, e);
}
public void Join(Path <T> path)
{
var otherNodes = path.Nodes;
if (_comparer.Equals(otherNodes[0], Nodes[Nodes.LastIndex()]))
{
otherNodes = otherNodes.SubRange(1, otherNodes.LastIndex());
}
Nodes.AddRange(otherNodes);
}
public TreeNode(string text, TreeNode[] children)
{
ImageIndex_Expanded = -1;
ImageIndex_Collapsed = -1;
this.text = text;
if (children != null)
{
Nodes.AddRange(children);
}
}
/// <summary>
/// Bind the caller with the callee and simplify the resulting pointsToGraph
/// by removing the load nodes that has been resolved (captured objects)
/// </summary>
/// <param name="callerPTG"></param>
/// <param name="calleePTG"></param>
/// <param name="vr"></param>
/// <returns></returns>
private void bindCallerWithCalleePTG(PTGraph callerPTG, PTGraph calleePTG, Variable vr)
{
// Compute Edges
Edges Inew = new Edges();
foreach (Edge ie in calleePTG.I)
{
foreach (IPTAnalysisNode nu1 in RelatedExtended(ie.Src))
{
foreach (IPTAnalysisNode nu2 in RelatedExtended(ie.Dst))
{
Inew.AddIEdge(nu1, ie.Field, nu2);
}
}
}
// Compute Edges
Edges Onew = new Edges();
foreach (Edge oe in calleePTG.O)
{
foreach (IPTAnalysisNode nu1 in RelatedExtended(oe.Src))
{
if (!nu1.IsNull)
Onew.AddOEdge(nu1, oe.Field, oe.Dst);
}
}
// Compute Escape
Nodes eNew = new Nodes();
foreach (IPTAnalysisNode n in calleePTG.E)
{
eNew.AddRange(RelatedExtended(n));
}
callerPTG.I.AddEdges(Inew);
callerPTG.O.AddEdges(Onew);
callerPTG.E.AddRange(eNew);
/// Assign vr = related(retValue)
Nodes argNodes = Nodes.Empty;
if (callerThisRef != null)
{
// argNodes.Add(callerPTG.GetAddress(callerThisRef));
argNodes.AddRange(callerPTG.GetLocations(callerThisRef));
}
if (calleePTG.Method.Parameters != null)
{
for (int i = 0; i < calleePTG.Method.Parameters.Count; i++)
{
Parameter p = calleePTG.Method.Parameters[i];
PNode pn = calleePTG.ParameterMap[p];
if (!pn.IsByValue)
{
if (arguments[i] is Variable)
{
Variable vArg = (Variable)arguments[i];
bindRefOrOutParameter(callerPTG, calleePTG, arguments[i] as Variable, p);
}
}
if (arguments[i] is Variable)
{
Variable vArg = (Variable)arguments[i];
// PTAnalysisNode addrArg = callerPTG.GetAddress(vArg);
// argNodes.Add(addrArg);
argNodes.AddRange(callerPTG.GetLocations(vArg));
}
}
}
if (vr != null)
{
if (!vr.Type.IsPrimitive && calleePTG.RetValue != null)
{
callerPTG.AddVariable(vr, callerPTG.MethodLabel);
Nodes relatedValues2 = Nodes.Empty;
// PTAnalysisNode addrRetValue = calleePTG.GetAddress(calleePTG.RetValue);
// foreach (PTAnalysisNode n2 in calleePTG.Values(addrRetValue))
foreach (IPTAnalysisNode n2 in calleePTG.Values(calleePTG.GetLocations(calleePTG.RetValue)))
{
relatedValues2.AddRange(RelatedExtended(n2));
}
callerPTG.Assign(vr, relatedValues2, calleePTG.MethodLabel);
}
else
{
callerPTG.ForgetVariable(vr);
}
}
// Now we can remove the load nodes that don't escape
Set<LNode> lNodes = callerPTG.LoadNodes;
// B = Nodes forward reachable from from Escaping, Parameters, callee Arguments and Global nodes
Nodes B = callerPTG.ReachableFromParametersReturnAndGlobalsAnd(argNodes);
foreach (LNode ln in lNodes)
{
Set<Edge> IToRemove = new Set<Edge>();
Set<Edge> OToRemove = new Set<Edge>();
// If the LoadNode is not reachable or it is captured
if (!B.Contains(ln) || (Related(ln).Count > 0))
// if (!B.Contains(ln) || (ln.IsParameterValueLNode && (Related(ln).Count > 0 || !Related(ln).Contains(ln))))
//if (!B.Contains(ln) /*&& (ln is LAddrFieldNode */
// /*&& ln.Label.Method.Equals(callerPTG.Method)*/)
{
foreach (Edge ie in callerPTG.I.EdgesFromSrc(ln))
IToRemove.Add(ie);
foreach (Edge ie in callerPTG.I.EdgesFromDst(ln))
IToRemove.Add(ie);
foreach (Edge oe in callerPTG.O.EdgesFromDst(ln))
OToRemove.Add(oe);
foreach (Edge oe in callerPTG.O.EdgesFromSrc(ln))
OToRemove.Add(oe);
removedLoadNodes.Add(ln);
}
callerPTG.I.RemoveEdges(IToRemove);
callerPTG.O.RemoveEdges(OToRemove);
}
}
