private List <IMyExecutable> GetTasks(MyWorkingNode node)
{
List <IMyExecutable> tasks = new List <IMyExecutable>();
foreach (string taskName in node.GetInfo().KnownTasks.Keys)
{
MyTask task = node.GetTaskByPropertyName(taskName);
tasks.Add(task);
}
MyNodeGroup nodeGroup = node as MyNodeGroup;
if (nodeGroup != null)
{
foreach (MyNode childNode in nodeGroup.Children)
{
MyWorkingNode childWorkingNode = childNode as MyWorkingNode;
if (childWorkingNode != null)
{
tasks.AddRange(GetTasks(childWorkingNode));
}
}
}
return(tasks);
}
public void RefreshView()
{
isUpdating = true;
listView.Items.Clear();
if (m_target != null)
{
foreach (PropertyInfo taskPropInfo in m_target.GetInfo().TaskOrder)
{
MyTask task = m_target.GetTaskByPropertyName(taskPropInfo.Name);
if (task != null)
{
ListViewItem item = new ListViewItem(new string[] { task.Name, task.OneShot ? "Init" : "" });
item.Checked = task.Enabled;
item.Tag = task;
listView.Items.Add(item);
}
}
}
isUpdating = false;
if (lastSelectedTaskIndex != -1 && listView.Items.Count > lastSelectedTaskIndex)
{
listView.Items[lastSelectedTaskIndex].Selected = true;
listView.Invalidate();
}
else
{
m_mainForm.TaskPropertyView.Target = null;
}
RefreshDashboardButton();
}
/// <summary>
/// Return task of given type from given node
/// </summary>
/// <param name="node">Node</param>
/// <param name="type">Type of task</param>
/// <returns>Task</returns>
protected MyTask GetTaskByType(MyWorkingNode node, Type type)
{
foreach (PropertyInfo taskPropInfo in node.GetInfo().TaskOrder)
{
MyTask task = node.GetTaskByPropertyName(taskPropInfo.Name);
if (task.GetType().ToString() == type.ToString())
{
return(task);
}
}
return(null);
}
private MyExecutionBlock CreateNodeExecutionPlan(MyWorkingNode node, bool initPhase)
{
List<IMyExecutable> defaultPlanContent = new List<IMyExecutable>();
if (!initPhase && PlanSignalTasks)
{
defaultPlanContent.Add(new MyIncomingSignalTask(node));
}
foreach (string taskName in node.GetInfo().KnownTasks.Keys)
{
MyTask task = node.GetTaskByPropertyName(taskName);
if (task != null && initPhase && task.OneShot || !initPhase && !task.OneShot)
{
defaultPlanContent.Add(task);
}
}
if (node is MyNodeGroup)
{
IEnumerable<MyNode> children = (node as MyNodeGroup).Children.OrderBy(x => x.TopologicalOrder);
foreach (MyNode childNode in children)
{
if (childNode is MyWorkingNode)
{
defaultPlanContent.Add(CreateNodeExecutionPlan(childNode as MyWorkingNode, initPhase));
}
}
}
if (!initPhase && PlanSignalTasks)
{
defaultPlanContent.Add(new MyOutgoingSignalTask(node));
}
MyExecutionBlock defaultPlan = new MyExecutionBlock(defaultPlanContent.ToArray());
defaultPlan.Name = node.Name;
MyExecutionBlock resultPlan = defaultPlan;
if (node is IMyCustomExecutionPlanner)
{
if (initPhase)
{
resultPlan = (node as IMyCustomExecutionPlanner).CreateCustomInitPhasePlan(defaultPlan);
}
else
{
resultPlan = (node as IMyCustomExecutionPlanner).CreateCustomExecutionPlan(defaultPlan);
}
resultPlan.Name = defaultPlan.Name;
}
if (node is MyNodeGroup)
{
resultPlan.Name += " (group)";
}
return resultPlan;
}
public MyExecutionBlock CreateNodeExecutionPlan(MyWorkingNode node, bool initPhase)
{
List<IMyExecutable> defaultPlanContent = new List<IMyExecutable>();
if (!initPhase && PlanSignalTasks)
{
defaultPlanContent.Add(new MyIncomingSignalTask(node));
}
foreach (string taskName in node.GetInfo().KnownTasks.Keys)
{
MyTask task = node.GetTaskByPropertyName(taskName);
if (task != null && !task.DesignTime && (initPhase && task.OneShot || !initPhase && !task.OneShot))
{
defaultPlanContent.Add(task);
}
}
MyNodeGroup nodeGroup = node as MyNodeGroup;
if (nodeGroup != null)
{
IEnumerable<MyNode> children = nodeGroup.Children.OrderBy(x => x.TopologicalOrder);
foreach (MyNode childNode in children)
{
MyWorkingNode childWorkingNode = childNode as MyWorkingNode;
if (childWorkingNode != null)
{
defaultPlanContent.Add(CreateNodeExecutionPlan(childWorkingNode, initPhase));
}
}
}
if (!initPhase && PlanSignalTasks)
{
defaultPlanContent.Add(new MyOutgoingSignalTask(node));
}
MyExecutionBlock defaultPlan = new MyExecutionBlock(defaultPlanContent.ToArray());
defaultPlan.Name = node.Name;
MyExecutionBlock resultPlan = defaultPlan;
IMyCustomExecutionPlanner executionPlannerNode = node as IMyCustomExecutionPlanner;
if (executionPlannerNode != null)
{
if (initPhase)
{
resultPlan = executionPlannerNode.CreateCustomInitPhasePlan(defaultPlan);
}
else
{
resultPlan = executionPlannerNode.CreateCustomExecutionPlan(defaultPlan);
}
resultPlan.Name = defaultPlan.Name;
}
if (resultPlan.Name == null)
resultPlan.Name = node.GetType().Name;
if (node is MyNodeGroup)
{
resultPlan.Name += " (group)";
}
// TODO(HonzaS): Rethink this. It's only used in profiling results.
node.ExecutionBlock = resultPlan;
return resultPlan;
}
private List<IMyExecutable> GetTasks(MyWorkingNode node)
{
List<IMyExecutable> tasks = new List<IMyExecutable>();
foreach (string taskName in node.GetInfo().KnownTasks.Keys)
{
MyTask task = node.GetTaskByPropertyName(taskName);
tasks.Add(task);
}
MyNodeGroup nodeGroup = node as MyNodeGroup;
if (nodeGroup != null)
{
foreach (MyNode childNode in nodeGroup.Children)
{
MyWorkingNode childWorkingNode = childNode as MyWorkingNode;
if (childWorkingNode != null)
{
tasks.AddRange(GetTasks(childWorkingNode));
}
}
}
return tasks;
}
private MyExecutionBlock CreateNodeExecutionPlan(MyWorkingNode node, bool initPhase)
{
List <IMyExecutable> defaultPlanContent = new List <IMyExecutable>();
if (!initPhase && PlanSignalTasks)
{
defaultPlanContent.Add(new MyIncomingSignalTask(node));
}
foreach (string taskName in node.GetInfo().KnownTasks.Keys)
{
MyTask task = node.GetTaskByPropertyName(taskName);
if (task != null && initPhase && task.OneShot || !initPhase && !task.OneShot)
{
defaultPlanContent.Add(task);
}
}
if (node is MyNodeGroup)
{
IEnumerable <MyNode> children = (node as MyNodeGroup).Children.OrderBy(x => x.TopologicalOrder);
foreach (MyNode childNode in children)
{
if (childNode is MyWorkingNode)
{
defaultPlanContent.Add(CreateNodeExecutionPlan(childNode as MyWorkingNode, initPhase));
}
}
}
if (!initPhase && PlanSignalTasks)
{
defaultPlanContent.Add(new MyOutgoingSignalTask(node));
}
MyExecutionBlock defaultPlan = new MyExecutionBlock(defaultPlanContent.ToArray());
defaultPlan.Name = node.Name;
MyExecutionBlock resultPlan = defaultPlan;
if (node is IMyCustomExecutionPlanner)
{
if (initPhase)
{
resultPlan = (node as IMyCustomExecutionPlanner).CreateCustomInitPhasePlan(defaultPlan);
}
else
{
resultPlan = (node as IMyCustomExecutionPlanner).CreateCustomExecutionPlan(defaultPlan);
}
resultPlan.Name = defaultPlan.Name;
}
if (node is MyNodeGroup)
{
resultPlan.Name += " (group)";
}
return(resultPlan);
}
public MyExecutionBlock CreateNodeExecutionPlan(MyWorkingNode node, bool initPhase)
{
List <IMyExecutable> defaultPlanContent = new List <IMyExecutable>();
if (!initPhase && PlanSignalTasks)
{
defaultPlanContent.Add(new MyIncomingSignalTask(node));
}
foreach (var taskPropertyInfo in node.GetInfo().OrderedTasks)
{
MyTask task = node.GetTaskByPropertyName(taskPropertyInfo.Name);
if ((task != null) && !task.DesignTime && (initPhase && task.OneShot || !initPhase && !task.OneShot))
{
defaultPlanContent.Add(task);
}
}
MyNodeGroup nodeGroup = node as MyNodeGroup;
if (nodeGroup != null)
{
foreach (MyNode childNode in nodeGroup.Children.OrderBy(x => x.TopologicalOrder))
{
MyWorkingNode childWorkingNode = childNode as MyWorkingNode;
if (childWorkingNode != null)
{
defaultPlanContent.Add(CreateNodeExecutionPlan(childWorkingNode, initPhase));
}
}
}
if (!initPhase && PlanSignalTasks)
{
defaultPlanContent.Add(new MyOutgoingSignalTask(node));
}
var defaultPlan = new MyExecutionBlock(defaultPlanContent.ToArray())
{
Name = node.Name
};
MyExecutionBlock resultPlan = defaultPlan;
IMyCustomExecutionPlanner executionPlannerNode = node as IMyCustomExecutionPlanner;
if (executionPlannerNode != null)
{
resultPlan = initPhase
? executionPlannerNode.CreateCustomInitPhasePlan(defaultPlan)
: executionPlannerNode.CreateCustomExecutionPlan(defaultPlan);
resultPlan.Name = defaultPlan.Name;
}
if (resultPlan.Name == null)
{
resultPlan.Name = node.GetType().Name;
}
if (node is MyNodeGroup)
{
resultPlan.Name += " (group)";
}
// TODO(HonzaS): Rethink this. It's only used in profiling results.
node.ExecutionBlock = resultPlan;
return(resultPlan);
}
/// <summary>
/// Return task of given type from given node
/// </summary>
/// <param name="node">Node</param>
/// <param name="type">Type of task</param>
/// <returns>Task</returns>
protected MyTask GetTaskByType(MyWorkingNode node, Type type)
{
foreach (PropertyInfo taskPropInfo in node.GetInfo().TaskOrder)
{
MyTask task = node.GetTaskByPropertyName(taskPropInfo.Name);
if (task.GetType().ToString() == type.ToString())
return task;
}
return null;
}
