protected override void OnAction(BaseNode node, NodeAction action)
{
switch (action)
{
case NodeAction.New:
FileFolderNode fileFolder = node as FileFolderNode;
if (fileFolder != null)
{
MessageBox.Show(string.Format("New File in group \"{0}\" In Library {1}", fileFolder.Name, fileFolder.GetRoot<LibraryNode>().Name));
}
else
{
MessageBox.Show(string.Format("New Library with default group \"{0}\"", node.GetRootNodeName<GroupsNode>()));
}
break;
case NodeAction.Exclude:
case NodeAction.Remove:
LibraryNode library = node as LibraryNode;
if (library != null)
{
MessageBox.Show(string.Format("Remove Library {0} from Inventory", library.Name));
}
BuildFileNode file = node as BuildFileNode;
if (file != null)
{
MessageBox.Show(string.Format("{0} BuildFile {1} from library {2} from group {3}", action, file.Name, file.GetRoot<LibraryNode>().Name, file.GetRoot<FileFolderNode>().Name));
}
break;
default:
base.OnAction(node, action);
break;
}
}
public override void Add(BaseNode child)
{
base.Add(child);
while(children.Count > 1) {
children.RemoveAt(0);
}
}
public void InitializeConnection(BaseNode _node, DataDirection _direction, VarType _varType, int _num)
{
node = _node;
dataDirection = _direction;
varType = _varType;
num = _num;
}
public void OnProjectChanged(string path, string[] filter)
{
this.treeViewExplorer.BeginUpdate();
this._model = new TreeModel();
BaseNode rootNode = new BaseNode("UDK");
this._model.Nodes.Add(rootNode);
try
{
PopulateTree(path, rootNode, filter);
}
catch (Exception e)
{
ExceptionMessageBox msgBox = new ExceptionMessageBox(e);
msgBox.ShowDialog();
}
this.treeViewExplorer.Model = _model;
this.treeViewExplorer.EndUpdate();
foreach (TreeNodeAdv node in this.treeViewExplorer.Root.Children)
{
node.Expand();
}
}
protected virtual void OnAction(BaseNode node, NodeAction action)
{
BaseContentInventoryNode contentNode = node as BaseContentInventoryNode;
if (contentNode != null)
{
this.OnWrapperActionEvent(contentNode.Content, action);
}
}
public override bool CaptureMovedNode(BaseNode node)
{
this.Children.Add(node);
this.Save();
return true;
}
public override bool CanCapture(BaseNode node)
{
if (node.NodeType != Dict.NodeType.WorkFlow && node.NodeType != Dict.NodeType.WorkFlowSet)
{
return false;
}
return true;
}
public override void Add(BaseNode.BaseNode childNode)
{
var joinChildNode = (JoinNode) childNode;
var parentNode = (JoinNode) ParentNode;
if (parentNode.JoinWithParentBy == JoinType.LeftOuterJoin)
{
joinChildNode.JoinWithParentBy = JoinType.LeftOuterJoin;
}
base.Add(joinChildNode);
}
public void ShowNode(TreeNode treeNode, BaseNode sender)
{
if (_nodes.Last().Node != null && treeNode.Id == _nodes.Last().Node.Id)
return;
int idx = _nodes.IndexOf(sender);
if (sender != _nodes.Last())
{
_nodes.RemoveRange(idx + 1, _nodes.Count - idx - 1);
}
if (treeNode.IsDirectory)
{
try{
var node = NodeView.Create(new CGRect(View.Frame.Width, 0, width, View.Frame.Height), this, treeNode.Path, _balkKleur);
node.Layer.ZPosition = 10;
_nodes.Add(node);
Add(node);
AnimateViews();
} catch (Exception ex){
Insights.Report(ex);
DialogHelper.ShowErrorDialog("Fout", "Er is een fout opgetreden bij het openen van de map.\n" +
"Ververs de huidige map en probeer het a.u.b. nogmaals.");
}
}
else
{
string filePath = string.Empty;
InvokeOnMainThread(() =>
DialogHelper.ShowProgressDialog("Bestand downloaden", "Bezig met het downloaden van een bestand",
() => filePath = DataLayer.Instance.GetFilePathSync(treeNode.Path),
()=> {
try{
var item = WebItemView.Create(new CGRect(View.Frame.Width, 0, width, View.Frame.Height), this, treeNode, filePath, _balkKleur);
item.Layer.ZPosition = 10;
_nodes.Add(item);
Add(item);
AnimateViews();
}
catch (Exception ex){
Insights.Report(ex);
DialogHelper.ShowErrorDialog("Fout", "Er is een fout opgetreden bij het openen van het bestand." +
"\nVervers a.u.b. de map en probeer het opnieuw.");
}
})
);
}
}
public override void CaptureIO(BaseNode node)
{
if (node.NodeType == Dict.NodeType.WorkFlow)
{
var wf = node as WorkFlowNode;
var oldFile = wf.FullName;
var fullName = System.IO.Path.Combine(this.Path, System.IO.Path.GetFileName(wf.FullName));
System.IO.File.Move(oldFile, fullName);
}
else if (node.NodeType == Dict.NodeType.WorkFlowSet)
{
var folder = node as FolderNode;
var oldFolder = folder.Path;
var path = System.IO.Path.Combine(this.Path, folder.Name);
System.IO.Directory.Move(oldFolder, path);
}
}
protected override void OnAction(BaseNode node, NodeAction action)
{
switch (action)
{
case NodeAction.New:
MessageBox.Show(string.Format("New Library Category with default group \"{0}\"", node.GetRootNodeName<GroupsNode>()));
break;
case NodeAction.Remove:
LibraryCategoryNode libcat = node as LibraryCategoryNode;
if (libcat != null)
{
MessageBox.Show(string.Format("Remove Library Category {0} from Inventory", libcat.Name));
}
break;
default:
base.OnAction(node, action);
break;
}
}
protected override void OnAction(BaseNode node, NodeAction action)
{
switch (action)
{
case NodeAction.New:
MessageBox.Show(string.Format("New Feature with default group \"{0}\"", node.GetRootNodeName<GroupsNode>()));
break;
case NodeAction.Remove:
FeatureNode feature = node as FeatureNode;
if (feature != null)
{
MessageBox.Show(string.Format("Remove Feature {0} from Inventory", feature.Name));
}
break;
default:
base.OnAction(node, action);
break;
}
}
private List<Object3D> TestConvNode(BaseNode node, float[,] transformation)
{
List<Object3D> objects = new List<Object3D>();
if (node is TransformNode) {
objects.AddRange(WrapTransform((TransformNode)node, transformation));
return objects;
}
if (node is NavigationInfoNode) {
return objects;
}
if (node is DirectionalLightNode) {
return objects;
}
if (node is ShapeNode) {
objects.Add(TestConvShape((ShapeNode)node));
return objects;
}
return objects;
}
protected override void OnAction(BaseNode node, NodeAction action)
{
switch (action)
{
case NodeAction.Manage:
using (PKStudio.Dialogs.ManageProjectWizard.ManageProjectWizard mManageProjectComponentsWizard = new Dialogs.ManageProjectWizard.ManageProjectWizard())
{
ProjectNode PN = node.GetRoot<ProjectNode>();
SolutionNode SN = node.GetRoot<SolutionNode>();
if ((PN != null) && (SN != null))
{
mManageProjectComponentsWizard.SetProject(SN.TypedContent, PN.TypedContent);
mManageProjectComponentsWizard.ShowDialog(this);
}
}
break;
case NodeAction.New:
SolutionNode solution = node as SolutionNode;
if (solution != null)
{
//MessageBox.Show(string.Format("Add Project in Solution {0}", solution.Name));
using (PKStudio.Dialogs.ManageProjectWizard.NewProjectWizard mNewProjectWizard = new Dialogs.ManageProjectWizard.NewProjectWizard(solution.TypedContent))
{
mNewProjectWizard.ShowDialog(this);
}
}
break;
case NodeAction.Remove:
ProjectNode project = node as ProjectNode;
if (project != null)
{
MessageBox.Show(string.Format("Remove Project {0} from Solution", project.Name));
}
break;
default:
base.OnAction(node, action);
break;
}
}
public override void Init(Reactor reactor)
{
base.Init(reactor);
if (reactable != null) {
#region Edited by PanDenat
reactor.AddComponentsIfMissing(reactable);
#endregion
var root = (React.Root)React.JsonSerializer.Decode(reactable.json);
root.PreProcess(gameObject, reactor);
importedChild = root.children[0];
#region Log if null
if (importedChild == null) {
Debug.LogWarning("Imported root: " + root + " \n\n"
+ "Imported reactable: " + reactable + "\n\n"
+ "Imported reactable behaviours: " + reactable.behaviourTypes + "\n\n"
+ "Reactor: " + reactor);
Debug.Log(reactable.json);
}
#endregion
} else Debug.LogError("[Import Reactable Node] no reactable to import!\n Reactor.reactable = " + reactor.reactable);
}
//process output and input of vars and lists
public void PassArgument(BaseNode from, BaseNode to, VarType fromType, VarType outType)
{
switch (fromType) {
case VarType.FloatVar:
IOutputVar<float> fromInterface = from as IOutputVar<float>;
IInputVar<float> toInterface = to as IInputVar<float>;
if(fromInterface != null && toInterface != null){
toInterface.inputVar = fromInterface.outputVar;
}
break;
case VarType.IdWeightVar:
IOutputVar<IdWeight> fromIdWeight = from as IOutputVar<IdWeight>;
IInputVar<IdWeight> toIdWeight = to as IInputVar<IdWeight>;
if(fromIdWeight != null && toIdWeight != null){
toIdWeight.inputVar = fromIdWeight.outputVar;
}
break;
default:
break;
}
}
private IEnumerator<NodeResult> NodeTask(BaseNode endChild = null)
{
foreach (var child in ActiveChildren()) {
if (child == endChild) break;
var task = child.GetNodeTask();
while (task.MoveNext()) {
var t = task.Current;
if (t == NodeResult.Continue) {
yield return t;
var newTask = NodeTask(child);
while (newTask.MoveNext()) {
if (newTask.Current == NodeResult.Success) continue;
yield return newTask.Current;
}
} else if (t == NodeResult.Failure) {
yield return t;
yield break;
} else if (t == NodeResult.Success) {
break;
}
}
}
yield return NodeResult.Success;
}
public override void Insert(int index, BaseNode child)
{
Add (child);
}
/// <summary>
/// 初期化
/// </summary>
/// <param name="node">rootNode</param>
public void Initialize(BaseNode node)
{
_rootNode = node;
}
public Pair(XmlNode xmlNode, BaseNode baseNode)
{
this.xmlNode = xmlNode;
this.baseNode = baseNode;
}
public SetSelectedNodeArgs(BaseNode Node)
{
this.Node = Node;
this.Result = true;
}
public IEnumerable <Instruction> ConvertFromString(string value, ILContext context, BaseNode node)
{
var module = context.Body.Method.Module;
if (!string.IsNullOrEmpty(value))
{
int x, y;
var thickness = value.Split(',');
foreach (var thick in thickness)
{
if (null != NodeILExtensions.GetDPValueSubFix(thick))
{
return(null);
}
}
if (int.TryParse(thickness[0], NumberStyles.Number, CultureInfo.InvariantCulture, out x) &&
int.TryParse(thickness[1], NumberStyles.Number, CultureInfo.InvariantCulture, out y))
{
return(GenerateIL(module, x, y));
}
}
throw new XamlParseException($"Cannot convert \"{value}\" into Position2D", node);
}
public IEnumerable <Instruction> ConvertFromString(string value, ILContext context, BaseNode node)
{
var module = context.Body.Method.Module;
var thickness = value.Split(',');
foreach (var thick in thickness)
{
if (null != NodeILExtensions.GetDPValueSubFix(thick))
{
return(null);
}
}
if (3 == thickness.Length)
{
double x, y, z;
if (double.TryParse(thickness[0], NumberStyles.Number, CultureInfo.InvariantCulture, out x) &&
double.TryParse(thickness[1], NumberStyles.Number, CultureInfo.InvariantCulture, out y) &&
double.TryParse(thickness[2], NumberStyles.Number, CultureInfo.InvariantCulture, out z))
{
return(GenerateIL(module, x, y, z));
}
}
else if (2 == thickness.Length)
{
double x, y;
if (double.TryParse(thickness[0], NumberStyles.Number, CultureInfo.InvariantCulture, out x) &&
double.TryParse(thickness[1], NumberStyles.Number, CultureInfo.InvariantCulture, out y))
{
return(GenerateIL(module, x, y, 0));
}
}
else if (1 == thickness.Length)
{
if (value.Contains("."))
{
string[] parts = value.Split('.');
if (parts.Length == 2 && (parts[0].Trim() == "ParentOrigin" || parts[0].Trim() == "PivotPoint"))
{
string position = parts[parts.Length - 1].Trim();
return(ConvertToPoint(position, context, node));
}
}
else
{
return(ConvertToPoint(value, context, node));
}
}
throw new XamlParseException($"Cannot convert \"{value}\" into Position", node);
}
public void NewNode(BaseNode node)
{
m_currentNode = node;
m_nodeEvaluator.Evaluate(node, true);
}
public IEnumerable <Instruction> ConvertFromString(string value, ILContext context, BaseNode node)
{
var module = context.Body.Method.Module;
do
{
if (string.IsNullOrEmpty(value))
{
break;
}
value = value.Trim();
var parts = value.Split('.');
if (parts.Length == 1 || (parts.Length == 2 && parts [0] == "LayoutOptions"))
{
var options = parts [parts.Length - 1];
var fieldReference = module.ImportFieldReference(("System.Maui.Core", "System.Maui", "LayoutOptions"),
fieldName: options,
isStatic: true);
if (fieldReference != null)
{
yield return(Instruction.Create(OpCodes.Ldsfld, fieldReference));
yield break;
}
}
} while (false);
throw new XamlParseException(String.Format("Cannot convert \"{0}\" into {1}", value, typeof(LayoutOptions)), node);
}
public void LoadNode(BaseNode node)
{
m_currentNode = node;
m_nodeEvaluator.Evaluate(m_currentNode, false);
}
public void NewPage(int pageNumber)
{
m_sceneNodes = m_currentScene.GetNodes(pageNumber);
m_currentNode = m_sceneNodes[0];
}
public void JumpToNode(BaseNode node)
{
m_currentNode = node;
m_nodeEvaluator.Evaluate(m_currentNode, true);
}
private void addBlockNodes(XmlNodeList list, BaseNode lastNode, BaseNode parentNode)
{
foreach (XmlNode node in list)
{
BaseNode newNode = null;
if (node.Name.Equals("End"))
{
newNode = endNode;
}
else if (node.Name.Equals("Start"))
{
newNode = startNode;
}
else if (node.Name.Equals("Assign"))
{
newNode = new AssignNode();
}
else if (node.Name.Equals("Declare"))
{
newNode = new DeclareNode();
}
else if (node.Name.Equals("Input"))
{
newNode = new InputNode();
}
else if (node.Name.Equals("Output"))
{
newNode = new OutputNode();
}
else if (node.Name.Equals("If"))
{
newNode = new IfNode();
setAttributes(node, newNode);
addBlockNodes(node.FirstChild.ChildNodes, ((DecisionNode)newNode).TrueNode, newNode);
}
else if (node.Name.Equals("IfElse"))
{
newNode = new IfElseNode();
setAttributes(node, newNode);
addBlockNodes(node.FirstChild.ChildNodes, ((IfElseNode)newNode).TrueNode, newNode);
addBlockNodes(node.LastChild.ChildNodes, ((IfElseNode)newNode).FalseNode, newNode);
}
else if (node.Name.Equals("While"))
{
newNode = new WhileNode();
setAttributes(node, newNode);
addBlockNodes(node.FirstChild.ChildNodes, ((DecisionNode)newNode).TrueNode, newNode);
}
else if (node.Name.Equals("DoWhile"))
{
newNode = new DoNode();
setAttributes(node, newNode);
addBlockNodes(node.FirstChild.ChildNodes, ((DecisionNode)newNode).TrueNode, newNode);
}
else if (node.Name.Equals("For"))
{
newNode = new ForNode();
setAttributes(node, newNode);
addBlockNodes(node.FirstChild.ChildNodes, ((DecisionNode)newNode).TrueNode, newNode);
}
else
{
showErrorMessage("Error not valid file");
}
if (!(node.Name.Equals("Start") || node.Name.Equals("End")))
{
BaseNode oldNode = lastNode.OutConnector.EndNode;
lastNode.OutConnector.EndNode = newNode;
newNode.OutConnector.EndNode = oldNode;
newNode.addToModel();
newNode.ParentNode = parentNode;
}
lastNode = newNode;
blockNodes.Add(new Pair(node, newNode));
setAttributes(node, newNode);
}
}
private static void setAttributes(XmlNode node, BaseNode newNode)
{
string statment = node.Attributes["Statment"]?.InnerText;
statment = escapesToRegular(node.Attributes["Statment"]?.InnerText);
string location = node.Attributes["Location"]?.InnerText;
string[] true_end_location = node.Attributes["True_End_Location"]?.InnerText.Split(',');
string[] false_end_location = node.Attributes["False_End_Location"]?.InnerText.Split(',');
string[] mid_location = node.Attributes["Mid_Location"]?.InnerText.Split(',');
newNode.Statement = statment;
if (location != null)
{
string[] points = location.Split(',');
newNode.NodeLocation = new System.Drawing.PointF((float)Double.Parse(points[0]), (float)Double.Parse(points[1]));
}
if (newNode is IfElseNode)
{
IfElseNode ifElseNode = (IfElseNode)newNode;
ifElseNode.BackNode.NodeLocation = new System.Drawing.PointF((float)Double.Parse(true_end_location[0]), (float)Double.Parse(true_end_location[1]));
ifElseNode.BackfalseNode.NodeLocation = new System.Drawing.PointF((float)Double.Parse(false_end_location[0]), (float)Double.Parse(false_end_location[1]));
ifElseNode.MiddleNode.NodeLocation = new System.Drawing.PointF((float)Double.Parse(mid_location[0]), (float)Double.Parse(mid_location[1]));
}
else if (newNode is IfNode)
{
IfNode ifNode = (IfNode)newNode;
ifNode.BackNode.NodeLocation = new System.Drawing.PointF((float)Double.Parse(true_end_location[0]), (float)Double.Parse(true_end_location[1]));
ifNode.MiddleNode.NodeLocation = new System.Drawing.PointF((float)Double.Parse(mid_location[0]), (float)Double.Parse(mid_location[1]));
}
else if (newNode is DecisionNode)
{
DecisionNode decisionNode = (DecisionNode)newNode;
decisionNode.BackNode.NodeLocation = new System.Drawing.PointF((float)Double.Parse(true_end_location[0]), (float)Double.Parse(true_end_location[1]));
if (newNode is ForNode)
{
ForNode forNode = newNode as ForNode;
forNode.Var = node.Attributes["Variable"].InnerText;
forNode.Direction = node.Attributes["Direction"].InnerText;
forNode.StartVal = node.Attributes["StartVal"].InnerText;
forNode.EndVal = node.Attributes["EndVal"].InnerText;
forNode.StepBy = node.Attributes["StepBy"].InnerText;
}
}
else if (newNode is DeclareNode)
{
string variable_name = node.Attributes["Variable_Name"].InnerText;
string variable_type = node.Attributes["Variable_Type"].InnerText;
string single = node.Attributes["Single_Variable"].InnerText;
string size = node.Attributes["Size"].InnerText;
DeclareNode declareNode = (DeclareNode)newNode;
declareNode._Var.VarName = variable_name;
declareNode._Var.Size = Int32.Parse(size);
declareNode._Var.Single = Boolean.Parse(single);
switch (variable_type)
{
case "INTEGER":
declareNode._Var.VarType = DeclareNode.Variable.Data_Type.INTEGER;
break;
case "REAL":
declareNode._Var.VarType = DeclareNode.Variable.Data_Type.REAL;
break;
case "BOOLEAN":
declareNode._Var.VarType = DeclareNode.Variable.Data_Type.BOOLEAN;
break;
case "STRING":
declareNode._Var.VarType = DeclareNode.Variable.Data_Type.STRING;
break;
}
}
}
public override void Add(BaseNode child, BaseNode after)
{
Add (child);
}
// Adds a node to its list public void AddNode(BaseNode node) => childNodes.Add(node);
public IEnumerable <Instruction> ConvertFromString(string value, ILContext context, BaseNode node)
{
var module = context.Body.Method.Module;
if (string.IsNullOrWhiteSpace(value))
{
yield return(Create(Ldnull));
yield break;
}
yield return(Create(Ldstr, value));
yield return(Create(Ldc_I4_0)); //UriKind.RelativeOrAbsolute
yield return(Create(Newobj, module.ImportCtorReference(("System", "System", "Uri"), parameterTypes: new[] {
void OnTriggerEnter(Collider other)
{
BaseNode.ExecuteNode(node);
}
private IEnumerable <Instruction> ConvertToPoint(string value, ILContext context, BaseNode node)
{
var module = context.Body.Method.Module;
switch (value)
{
case "Top":
return(GenerateIL(module, 0.0));
case "Bottom":
return(GenerateIL(module, 1.0));
case "Left":
return(GenerateIL(module, 0.0));
case "Right":
return(GenerateIL(module, 1.0));
case "Middle":
return(GenerateIL(module, 0.5));
case "TopLeft":
return(GenerateIL(module, 0.0, 0.0, 0.5));
case "TopCenter":
return(GenerateIL(module, 0.5, 0.0, 0.5));
case "TopRight":
return(GenerateIL(module, 1.0, 0.0, 0.5));
case "CenterLeft":
return(GenerateIL(module, 0.0, 0.5, 0.5));
case "Center":
return(GenerateIL(module, 0.5, 0.5, 0.5));
case "CenterRight":
return(GenerateIL(module, 1.0, 0.5, 0.5));
case "BottomLeft":
return(GenerateIL(module, 0.0, 1.0, 0.5));
case "BottomCenter":
return(GenerateIL(module, 0.5, 1.0, 0.5));
case "BottomRight":
return(GenerateIL(module, 1.0, 1.0, 0.5));
}
throw new XamlParseException($"Cannot convert \"{value}\" into Position", node);
}
private bool OnSetSelectedNode(object sender, BaseNode component)
{
SetSelectedNodeArgs args = new SetSelectedNodeArgs(component);
if (this.SetSelectedNodeEvent != null)
{
this.SetSelectedNodeEvent(sender, args);
}
return args.Result;
}
private void NodesChanged_Handler(BaseNode sender)
{
classes.ForEach(c => c.UpdateOffsets());
}
public ThenComponent(BaseNode node)
{
_node = node;
}
///<summary>
///Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other.
///</summary>
///<returns>
///Value Condition Less than zerox is less than y.Zerox equals y.Greater than zerox is greater than y.
///</returns>
///<param name="y">The second object to compare.</param>
///<param name="x">The first object to compare.</param>
public override int Compare(BaseNode.BaseNode x, BaseNode.BaseNode y)
{
const int hash = 100000000;
int xHash = x.EntityType.GetHashCode();
xHash += ((JoinNode) x).JoinWithParentBy == JoinType.InnerJoin ? 0 : hash;
int yHash = y.EntityType.GetHashCode();
yHash += ((JoinNode) y).JoinWithParentBy == JoinType.InnerJoin ? 0 : hash;
return xHash - yHash;
}
private void PopulateTree(string dir, BaseNode root, string[] filter)
{
DirectoryInfo directory = new DirectoryInfo(dir);
foreach (DirectoryInfo d in directory.GetDirectories())
{
FolderNode node = new FolderNode(d.Name);
node.Folder = d;
PopulateTree(d.FullName, node, filter);
root.Nodes.Add(node);
}
foreach (FileInfo f in directory.GetFiles())
{
if (filter.Contains(f.Extension))
{
FileNode node = new FileNode(f.Name);
node.File = f;
root.Nodes.Add(node);
}
}
}
protected virtual void OnAction(BaseNode node, NodeAction action)
{
if (this.NodeActionEvent != null)
{
this.NodeActionEvent(node, new NodeEventArgs(action));
}
}
public IEnumerable <Instruction> ProvideValue(VariableDefinitionReference vardefref, ModuleDefinition module, BaseNode node, ILContext context)
{
INode valueNode = null;
if (!((IElementNode)node).Properties.TryGetValue(new XmlName("", "Value"), out valueNode) && ((IElementNode)node).CollectionItems.Count == 1)
{
valueNode = ((IElementNode)node).CollectionItems[0];
}
if (valueNode == null)
{
throw new XamlParseException("Missing Value for Setter", (IXmlLineInfo)node);
}
//if it's an elementNode, there's probably no need to convert it
if (valueNode is IElementNode)
{
yield break;
}
var value = ((string)((ValueNode)valueNode).Value);
var bpNode = ((ValueNode)((IElementNode)node).Properties[new XmlName("", "Property")]);
var bpRef = (new BindablePropertyConverter()).GetBindablePropertyFieldReference((string)bpNode.Value, module, bpNode);
TypeReference _;
var setValueRef = module.ImportReference(module.ImportReference(typeof(Setter)).GetProperty(p => p.Name == "Value", out _).SetMethod);
//push the setter
yield return(Instruction.Create(OpCodes.Ldloc, vardefref.VariableDefinition));
//push the value
foreach (var instruction in ((ValueNode)valueNode).PushConvertedValue(context, bpRef, valueNode.PushServiceProvider(context, bpRef: bpRef), boxValueTypes: true, unboxValueTypes: false))
{
yield return(instruction);
}
//set the value
yield return(Instruction.Create(OpCodes.Callvirt, setValueRef));
}
void OnGUI()
{
Event e = Event.current;
mousePos = e.mousePosition;
if (e.button == 1 && !makeTransitionMode)
{
if (e.type == EventType.MouseDown)
{
bool clickedOnWindow = false;
int selectIndex = -1;
for (int i = 0; i < windows.Count; ++i)
{
if (windows[i].windowRect.Contains(mousePos))
{
selectIndex = i;
clickedOnWindow = true;
break;
}
}
if (!clickedOnWindow)
{
GenericMenu menu = new GenericMenu();
menu.AddItem(new GUIContent("Add Conversation Node"), false, ContextCallback, "conversationNode");
//menu.AddItem(new GUIContent("Add Input Node"), false, ContextCallback, "inputNode");
//menu.AddItem(new GUIContent("Add Output Node"), false, ContextCallback, "outputNode");
//menu.AddItem(new GUIContent("Add Calculation Node"), false, ContextCallback, "calcNode");
//menu.AddItem(new GUIContent("Add Comparison Node"), false, ContextCallback, "compNode");
menu.ShowAsContext();
e.Use();
}
else
{
/*
* GenericMenu menu = new GenericMenu();
* menu.AddItem(new GUIContent("Make Transition"), false, ContextCallback, "makeTransition");
* menu.AddSeparator("");
* menu.AddItem(new GUIContent("Delete Node"), false, ContextCallback, "deleteNode");
*
* menu.ShowAsContext();
*/
e.Use();
}
}
}
/*
* else if(e.button == 0 && e.type == EventType.MouseDown && makeTransitionMode) {
*
* bool clickedOnWindow = false;
* int selectIndex = -1;
*
* for(int i=0; i<windows.Count; i++) {
*
* if(windows[i].windowRect.Contains(mousePos)) {
*
* selectIndex = i;
* clickedOnWindow = true;
* break;
*
* }
*
* }
*
* if(clickedOnWindow && !windows[selectIndex].Equals(selectednode)) {
*
* windows[selectIndex].SetInput((BaseInputNode) selectednode, mousePos);
* makeTransitionMode = false;
* selectednode = null;
*
* }
*
* if (!clickedOnWindow) {
* makeTransitionMode = false;
* selectednode = null;
* }
*
* e.Use ();
*
* }
*
* else if(e.button == 0 && e.type == EventType.MouseDown && !makeTransitionMode) {
*
* bool clickedOnWindow = false;
* int selectIndex = -1;
*
* for(int i=0; i<windows.Count; i++) {
*
* if(windows[i].windowRect.Contains(mousePos)) {
*
* selectIndex = i;
* clickedOnWindow = true;
* break;
*
* }
*
* }
*
* if(clickedOnWindow) {
*
* BaseInputNode nodeToChange = windows[selectIndex].ClickedOnInput(mousePos);
*
* if(nodeToChange != null) {
*
* selectednode = nodeToChange;
* makeTransitionMode = true;
*
* }
*
* }
*
* }
*
* if(makeTransitionMode && selectednode != null) {
*
* Rect mouseRect = new Rect(e.mousePosition.x, e.mousePosition.y, 10, 10);
*
* DrawNodeCurve(selectednode.windowRect, mouseRect);
*
* Repaint();
*
* }*/
//GUI.BeginGroup (scrollPosition);
foreach (BaseNode n in windows)
{
if (n != null)
{
n.DrawCurves();
}
}
BeginWindows();
for (int i = 0; i < windows.Count; ++i)
{
BaseNode win = windows [i];
if (win)
{
windows [i].windowRect = GUI.Window(i, windows [i].windowRect, DrawNodeWindow, windows [i].windowTitle);
}
}
EndWindows();
//GUI.EndGroup ();
}
public override Attachment CreateStartCondition(BaseNode owner)
{
return(Attachment.Create(typeof(PluginBehaviac.Events.StartCondition), owner as Node));
}
IEnumerator GenerateScreenshots()
{
var t = Resources.Load <Texture>("DocumentationGraph");//.FirstOrDefault(g => { Debug.Log(g); return g is MixtureGraph;}) as MixtureGraph;
MixtureGraph docGraph = AssetDatabase.LoadAllAssetsAtPath(AssetDatabase.GetAssetPath(t)).FirstOrDefault(g => g is MixtureGraph) as MixtureGraph;
// Setup doc graph properties:
docGraph.scale = Vector3.one;
docGraph.position = new Vector3(0, toolbarHeight, 0);
docGraph.nodes.RemoveAll(n => !(n is OutputNode));
// yield return null;
var window = EditorWindow.CreateWindow <MixtureGraphWindow>();
window.Show();
window.Focus();
window.minSize = new Vector2(1024, 1024);
window.maxSize = new Vector2(1024, 1024);
var nodeViews = new List <BaseNodeView>();
foreach (var node in NodeProvider.GetNodeMenuEntries())
{
if (node.Key.Contains("Experimental"))
{
continue;
}
// Skip non-mixture nodes:
if (!node.Value.FullName.Contains("Mixture"))
{
continue;
}
// We'll suport loops after
if (node.Value == typeof(ForeachStart) || node.Value == typeof(ForStart))
{
continue;
}
window.InitializeGraph(docGraph);
var graphView = window.view;
var newNode = BaseNode.CreateFromType(node.Value, new Vector2(0, toolbarHeight));
var nodeView = graphView.AddNode(newNode);
nodeViews.Add(nodeView);
graphView.Add(nodeView);
SetupNodeIfNeeded(nodeView);
graphView.MarkDirtyRepaint();
graphView.UpdateViewTransform(new Vector3(0, 0, 0), Vector3.one * graphView.scale);
graphView.Focus();
yield return(new WaitForEndOfFrame());
if (window == null)
{
yield break;
}
TakeAndSaveNodeScreenshot(window, nodeView);
GenerateNodeMarkdownDoc(nodeView);
graphView.RemoveNodeView(nodeView);
graphView.graph.RemoveNode(nodeView.nodeTarget);
graphView.MarkDirtyRepaint();
yield return(new WaitForEndOfFrame());
}
nodeViews.Sort((n1, n2) => n1.nodeTarget.name.CompareTo(n2.nodeTarget.name));
GenerateNodeIndexFiles(nodeViews);
foreach (var node in docGraph.nodes.ToList())
{
if (!(node is OutputNode))
{
docGraph.RemoveNode(node);
}
}
window.Close();
}
public IEnumerable <Instruction> ConvertFromString(string value, ILContext context, BaseNode node)
{
var module = context.Body.Method.Module;
Color ret = ConvertFromInvariantString(value);
if (null == ret)
{
throw new XamlParseException($"Cannot convert \"{value}\" into {typeof(Color)}", node);
}
return(GenerateIL(module, ret.r, ret.g, ret.b, ret.a));
}
private void InitRenderingScene()
{
if (!d3DImage.IsFrontBufferAvailable)
return;
factory = new SceneGraphFactory();
wpfRenderer = factory.CreateRenderTargetA8R8G8B8Asset();
/////////////////////////////////////////////////////////////
cameraAsset = factory.CreateCamera();
cameraAsset.Perspective(34.0 , (double)RESOLUTION_X / (double)RESOLUTION_Y, Z_NEAR, 0.0);
targetRenderer = factory.CreateRenderTargetAsset();
clearTargetBuffer = factory.CreateClearBuffer();
targetRenderer.SetRoot(clearTargetBuffer);
clearLayerBuffer = factory.CreateClearBuffer();
wpfRenderer.SetRoot(clearLayerBuffer);
TextureLayerNode targetTextureLayer = factory.CreateTextureLayer(targetRenderer);
targetTextureLayer.MakeParent(clearLayerBuffer);
effectAssetMesh = factory.CreateEffect("Position.DirectX9.obj.fx");
effectAssetMesh.SetValue("Time", 1);
ObjMeshAsset objMeshAsset = factory.CreateObjMesh("bigguy_g.obj");
drawMockNode = factory.CreateDrawMock();
drawMockNode.SetMesh(objMeshAsset);
drawmockTransformNodeFirst = factory.CreateTransform();
drawmockTransformNodeSecond = factory.CreateTransform();
drawmockTransformNodeFirst.MakeParent(clearTargetBuffer);
drawmockTransformNodeSecond.MakeParent(drawmockTransformNodeFirst);
drawMockNode.MakeParent(drawmockTransformNodeSecond);
///////////////////////////////////////////////
cudaRenderer = factory.CreateCudaRaytraceRenderAsset();
TextureLayerNode cudaTextureLayer = factory.CreateTextureLayer(cudaRenderer);
cudaRenderer.SetRoot(drawMockNode);
cudaTextureLayer.MakeParent(clearLayerBuffer);
cudaRenderer.SetTextureTarget(4, factory.CreateTextureAsset(targetRenderer));
////////////////////////////////////
effectAssetLayer = factory.CreateEffect("TextureLayerWpf.DirectX9.fx");
// set the back buffer using the new scene pointer
sceneIntPtr = (IntPtr)wpfRenderer.GetDirect3D9Surface(0);
d3DImage.Lock();
d3DImage.SetBackBuffer(D3DResourceType.IDirect3DSurface9, sceneIntPtr);
d3DImage.Unlock();
// leverage the Rendering event of WPF's composition target to
// update the custom D3D scene
CompositionTarget.Rendering += OnRendering;
}
public static ICypherFluentQuery MatchQuerry(this ICypherFluentQuery cypher, string varialbeName, BaseNode node)
{
if (node is Person)
{
return(cypher.MatchQuerry(varialbeName, (Person)node));
}
if (node is Commit)
{
return(cypher.MatchQuerry(varialbeName, (Commit)node));
}
if (node is File)
{
return(cypher.MatchQuerry(varialbeName, (File)node));
}
if (node is AstElement)
{
return(cypher.MatchQuerry(varialbeName, (AstElement)node));
}
if (node is AstElementDeleted)
{
return(cypher.MatchQuerry(varialbeName, (AstElementDeleted)node));
}
string matchClause = "(" + varialbeName + ":" + node.GetType().Name + ")";
if (node.Id > 0)
{
return(cypher.Match(matchClause).Where(varialbeName + ".Id=" + node.Id));
}
throw new NotImplementedException("Needs a specialices MatchQuery for " + node.GetType().Name);
}
public void appendChild(BaseNode node) {
children.AppendValue(node);
node.Parent = this;
}
protected override bool CanBeAdoptedBy(BaseNode parent)
{
return(base.CanBeAdoptedBy(parent) && (parent is Behavior) && (parent.IsFSM || (parent.Children.Count == 0)) && (parent.FSMNodes.Count == 0));
}
public static TypeReference GetTypeReference(string xmlType, ModuleDefinition module, BaseNode node)
{
var split = xmlType.Split(':');
if (split.Length > 2)
{
throw new XamlParseException($"Type \"{xmlType}\" is invalid", node as IXmlLineInfo);
}
string prefix, name;
if (split.Length == 2)
{
prefix = split[0];
name = split[1];
}
else
{
prefix = "";
name = split[0];
}
var namespaceuri = node.NamespaceResolver.LookupNamespace(prefix) ?? "";
return(GetTypeReference(new XmlType(namespaceuri, name, null), module, node as IXmlLineInfo));
}
/// <summary> /// Gets the surface at the given point in the world /// </summary> /// <param name="model"></param> /// <param name="baseNode"></param> /// <param name="start"></param> /// <param name="end"></param> /// <returns></returns> public static Face SurfaceAtPoint(Model model, BaseNode baseNode, in Vector3 start, in Vector3 end)
public static void AddQueryableItems(SchemaTree tree, BaseNode node, ContextMenuStrip menu, string memberStem, IEnumerable<string> columnNames)
{
EventHandler onClick = null;
EventHandler handler2 = null;
EventHandler handler3 = null;
EventHandler handler4 = null;
string compQueryBase;
bool isVBDefault = UserOptions.Instance.IsVBDefault;
QueryLanguage exprLanguage = isVBDefault ? QueryLanguage.VBExpression : QueryLanguage.Expression;
string take100Query = memberStem + ".Take (100)";
menu.Items.Add(take100Query, null, (sender, e) => tree.OnNewQuery(new NewQueryArgs(take100Query, new QueryLanguage?(exprLanguage), !memberStem.Contains("..."))));
string takeQuery = memberStem + ".Take (" + (UserOptions.Instance.ResultsInGrids ? "1000" : "...") + ")";
menu.Items.Add(takeQuery, null, (sender, e) => tree.OnNewQuery(new NewQueryArgs(takeQuery, new QueryLanguage?(exprLanguage), UserOptions.Instance.ResultsInGrids && !memberStem.Contains("..."))));
if (UserOptions.Instance.ResultsInGrids)
{
string takeBigQuery = memberStem + ".Take (50000)";
menu.Items.Add(takeBigQuery, null, (sender, e) => tree.OnNewQuery(new NewQueryArgs(takeBigQuery, new QueryLanguage?(exprLanguage), !memberStem.Contains("..."))));
}
string countQuery = memberStem + ".Count()";
menu.Items.Add(countQuery, null, (sender, e) => tree.OnNewQuery(new NewQueryArgs(countQuery, new QueryLanguage?(exprLanguage), !memberStem.Contains("..."))));
string iterationVar = memberStem.Substring(0, 1).ToLowerInvariant();
if (!isVBDefault)
{
string whereQuery = memberStem + ".Where (" + iterationVar + " => ";
menu.Items.Add(whereQuery + "...)", null, delegate (object sender, EventArgs e) {
NewQueryArgs args = new NewQueryArgs(whereQuery + iterationVar + (memberStem.Contains("...") ? "" : ".…)"), new QueryLanguage?(exprLanguage)) {
ListMembers = true
};
tree.OnNewQuery(args);
});
}
if (isVBDefault)
{
compQueryBase = "From " + iterationVar + " In " + memberStem + " _\nWhere ... _\nSelect ";
}
else
{
compQueryBase = "from " + iterationVar + " in " + memberStem + "\nwhere ... \nselect ";
}
string simpleCompQuery = compQueryBase + iterationVar;
menu.Items.Add(simpleCompQuery.Replace("\n", " "), null, delegate (object sender, EventArgs e) {
NewQueryArgs args = new NewQueryArgs(simpleCompQuery, new QueryLanguage?(exprLanguage)) {
ListMembers = true
};
tree.OnNewQuery(args);
});
simpleCompQuery = simpleCompQuery.Replace("here ...", "here " + (memberStem.Contains("...") ? "" : (iterationVar + ".…")));
string str = compQueryBase + "new { <all columns> }";
if (!(!columnNames.Any<string>() || isVBDefault))
{
menu.Items.Add(str.Replace("\n", " "), null, delegate (object sender, EventArgs e) {
StringBuilder builder = new StringBuilder(compQueryBase.Replace("here ...", "here " + (memberStem.Contains("...") ? "" : (iterationVar + ".…"))) + "new\n{\n");
foreach (string str in columnNames)
{
if (!string.IsNullOrEmpty(str))
{
bool flag;
string s = (flag = str.Contains("(")) ? Regex.Match(str, @"^\w+", RegexOptions.CultureInvariant).Value : str;
string str3 = (!char.IsLower(s, 0) || !CSharpQueryCompiler.IsKeyword(s)) ? "" : "@";
builder.Append("\t");
if (flag)
{
builder.Append(str3 + s + " = " + iterationVar + "." + str + ",\n");
}
else
{
builder.Append(iterationVar + "." + str3 + str + ",\n");
}
}
}
builder.Remove(builder.Length - 2, 2);
builder.Append("\n}");
NewQueryArgs args = new NewQueryArgs(builder.ToString(), new QueryLanguage?(exprLanguage)) {
ListMembers = true
};
tree.OnNewQuery(args);
});
}
if (!UserOptions.Instance.ResultsInGrids)
{
menu.Items.Add("-");
if (onClick == null)
{
onClick = delegate (object sender, EventArgs e) {
NewQueryArgs args = new NewQueryArgs(memberStem + ".Take(100)", new QueryLanguage?(exprLanguage), !memberStem.Contains("...")) {
IntoGrids = true
};
tree.OnNewQuery(args);
};
}
menu.Items.Add("Explore top 100 rows in grid", null, onClick);
if (handler2 == null)
{
handler2 = delegate (object sender, EventArgs e) {
NewQueryArgs args = new NewQueryArgs(memberStem + ".Take(1000)", new QueryLanguage?(exprLanguage), !memberStem.Contains("...")) {
IntoGrids = true
};
tree.OnNewQuery(args);
};
}
menu.Items.Add("Explore top 1000 rows in grid", null, handler2);
if (handler3 == null)
{
handler3 = delegate (object sender, EventArgs e) {
NewQueryArgs args = new NewQueryArgs(memberStem + ".Take(50000)", new QueryLanguage?(exprLanguage), !memberStem.Contains("...")) {
IntoGrids = true
};
tree.OnNewQuery(args);
};
}
menu.Items.Add("Explore top 50,000 rows in grid", null, handler3);
if (handler4 == null)
{
handler4 = delegate (object sender, EventArgs e) {
NewQueryArgs args = new NewQueryArgs(simpleCompQuery, new QueryLanguage?(exprLanguage)) {
IntoGrids = true,
ListMembers = true
};
tree.OnNewQuery(args);
};
}
menu.Items.Add("Execute LINQ query into data grid", null, handler4);
}
}
public void SetModel(ITreeModel model, bool expandRoot)
{
if (_treeView.Model == null)
{
expandRoot = true;
}
string selectedTreePath = null;
Dictionary <string, bool> collapsing = new Dictionary <string, bool>();
if (this.SelectedNode != null)
{
selectedTreePath = this.SelectedNode.TreePath;
}
if (expandRoot == false)
{
foreach (TreeNodeAdv node in _treeView.AllNodes)
{
BaseNode tag = node.Tag as BaseNode;
if (tag != null)
{
try
{
if (node.IsLeaf == false)
{
collapsing.Add(tag.TreePath, node.IsExpanded);
}
}
catch
{
}
}
}
}
_treeView.Model = model;
if (expandRoot)
{
ExpandRootNode();
}
else
{
TreeNodeAdv selectedNode = null;
_treeView.SuspendLayout();
foreach (TreeNodeAdv node in _treeView.AllNodes)
{
BaseNode tag = node.Tag as BaseNode;
if (tag != null)
{
if (selectedTreePath != null)
{
if (selectedTreePath == tag.TreePath)
{
selectedNode = node;
}
}
bool isExpanded;
if (collapsing.TryGetValue(tag.TreePath, out isExpanded))
{
node.IsExpanded = isExpanded;
}
}
}
if (selectedNode != null)
{
_treeView.SelectedNode = selectedNode;
}
else
{
ExpandRootNode();
}
_treeView.ResumeLayout();
}
}
//process output and input lists of vars and lists (List<T> and List<List<T>>)
// the function unboxes the interface of output variables in the output node(outNode) and the interface of input variables
// in the input node (inNode). OutType and inType indicate the type of the interface. OutNum and inNum indicates the place
// of output and input T and List<T> in case of output or input variables interface is of kind List<T> or List<List<T>>
// respectively.
public void PassArgument(BaseNode outNode, BaseNode inNode, VarType outType, VarType inType, int outNum, int inNum)
{
switch (outType) {
case VarType.IdWeightList:
IOutputList<IdWeight> outIdWeightList = outNode as IOutputList<IdWeight>;
IInputList<IdWeight> inIdWeightList = inNode as IInputList<IdWeight>;
IInputMultyList<IdWeight> inIdWeightMultyList = inNode as IInputMultyList<IdWeight>;
// 1 list out - 1 list in
if(inType == VarType.IdWeightList){
if(outIdWeightList != null && inIdWeightList != null){
inIdWeightList.inputList = outIdWeightList.outputList;
}
}
// 1 list out - n lists in
if(inType == VarType.IdWeightNestedList){
if(outIdWeightList != null && inIdWeightMultyList != null){
inIdWeightMultyList.inputLists[inNum] = outIdWeightList.outputList;
}
}
break;
case VarType.IdWeightNestedList:
IOutputMultyList<IdWeight> outIdWeightMultyList = inNode as IOutputMultyList<IdWeight>;
inIdWeightList = inNode as IInputList<IdWeight>;
inIdWeightMultyList = inNode as IInputMultyList<IdWeight>;
// n list out - 1 list in
if(inType == VarType.IdWeightList){
if(outIdWeightMultyList != null && inIdWeightList != null){
inIdWeightList.inputList = outIdWeightMultyList.outputLists[outNum];
}
}
// n list out - n lists in
if(inType == VarType.IdWeightNestedList){
if(outIdWeightMultyList != null && inIdWeightMultyList != null){
inIdWeightMultyList.inputLists[inNum] = outIdWeightMultyList.outputLists[outNum];
}
}
break;
default:
break;
}
}
public SetSelectedNodeArgs(BaseNode Node)
{
this.Node = Node;
this.Result = true;
}
private void _SearchFiles(List<FileInfo> files, BaseNode node, string text)
{
FileNode fileNode = node as FileNode;
FileInfo f = fileNode != null ? fileNode.File as FileInfo : null;
if (f != null && f.FullName.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0)
{
files.Add(f);
}
foreach (BaseNode child in node.Nodes)
{
_SearchFiles(files, child, text);
}
}
public IEnumerable <Instruction> ConvertFromString(string value, ILContext context, BaseNode node)
{
var module = context.Body.Method.Module;
if (IsNullOrEmpty(value))
{
throw new XamlParseException($"Cannot convert \"{value}\" into {typeof(Binding)}", node);
}
var bindingCtor = module.ImportReferenceCached(typeof(Binding)).ResolveCached().Methods.FirstOrDefault(md => md.IsConstructor && md.Parameters.Count == 6);
var bindingCtorRef = module.ImportReference(bindingCtor);
yield return(Instruction.Create(OpCodes.Ldstr, value));
yield return(Instruction.Create(OpCodes.Ldc_I4, (int)BindingMode.Default));
yield return(Instruction.Create(OpCodes.Ldnull));
yield return(Instruction.Create(OpCodes.Ldnull));
yield return(Instruction.Create(OpCodes.Ldnull));
yield return(Instruction.Create(OpCodes.Ldnull));
yield return(Instruction.Create(OpCodes.Newobj, bindingCtorRef));
}
void TEST_ADD_CODE( ByteCodes btcodes , BaseNode[] nodes )
{
for( int i=0;i<nodes.Length;i++){
FunctionNode sn = nodes[ i ] as FunctionNode;
if( sn != this && nodes[ i ].enabled ){
Debug.Log( "node:" + nodes[ i ].name );
nodes[ i ].ToByteCode( btcodes );
}
// else{
// Debug.Log( "the Node is Me !" );
// }
}
btcodes.Add( Opcode.STOP );
}
private async Task <bool> InsertNode(BaseNode <T> node, int rowIterator, int columnIterator)
{
var bubbleButton = new Button()
{
Style = BubbleStyle(),
FontSize = InternalFontSize,
Text = node.Data.Description,
TextColor = InternalTextColor,
HeightRequest = 100,
WidthRequest = 100,
BorderColor = InternalBorderColor,
BorderWidth = InternalBorderWidth,
BorderRadius = InternalBorderRadius,
BackgroundColor = InternalBackgroundColor,
Image = InternalImageSource,
ContentLayout = InternalContentLayout,
Command = new Command(() =>
{
if (!SelectionModeEnabled)
{
CurrentSearchFilterNode = node;
}
else
{
((BubbleTree <T>)BindingContext).SelectedItem = node.Data;
OnPropertyChanged(nameof(BubbleTree <T> .SelectedItem));
Navigation.PopAsync();
}
})
};
if (node is RootNode <T> )
{
bubbleButton.FontSize = RootFontSize;
bubbleButton.TextColor = RootTextColor;
bubbleButton.BorderColor = RootBorderColor;
bubbleButton.BorderWidth = RootBorderWidth;
bubbleButton.BorderRadius = RootBorderRadius;
bubbleButton.BackgroundColor = RootBackgroundColor;
bubbleButton.Image = RootImageSource;
bubbleButton.ContentLayout = RootContentLayout;
}
else if (node is LeafNode <T> )
{
bubbleButton.FontSize = LeafFontSize;
bubbleButton.TextColor = LeafTextColor;
bubbleButton.BorderColor = LeafBorderColor;
bubbleButton.BorderWidth = LeafBorderWidth;
bubbleButton.BorderRadius = LeafBorderRadius;
bubbleButton.BackgroundColor = LeafBackgroundColor;
bubbleButton.Image = LeafImageSource;
bubbleButton.ContentLayout = LeafContentLayout;
bubbleButton.Command = new Command(() =>
{
((BubbleTree <T>)BindingContext).SelectedItem = node.Data;
OnPropertyChanged(nameof(BubbleTree <T> .SelectedItem));
Navigation.PopAsync();
});
}
BubbleContainer.Children.Add(new Bubble <BaseNode <T>, T>(node, bubbleButton), columnIterator, rowIterator);
return(true);
}
