public WorkspaceViewModel(TraceLab.Core.Workspaces.Workspace workspace, string experimentId)
{
if (workspace == null)
throw new ArgumentNullException("workspace");
if (String.IsNullOrEmpty(experimentId))
throw new ArgumentException("Experiment id cannot be null or empty", "experimentId");
m_workspace = workspace;
m_workspace.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(workspace_PropertyChanged);
m_experimentId = experimentId;
//init observable collections
m_experimentWorkspaceUnits = new ObservableCollection<WorkspaceUnit>();
m_readonlyExperimentWorkspaceUnits = new ReadOnlyObservableCollection<WorkspaceUnit>(m_experimentWorkspaceUnits);
//prefill local units with units of this experiment
foreach (WorkspaceUnit unit in m_workspace.Units)
{
AddUnit(unit);
}
INotifyCollectionChanged workspaceUnitCollection = m_workspace.Units;
workspaceUnitCollection.CollectionChanged += WorkspaceCollectionCollectionChanged;
(new TraceLab.Core.Components.LibraryHelper(m_workspace.TypeDirectories)).PreloadWorkspaceTypes(System.AppDomain.CurrentDomain);
}
/// <summary>
/// Gets the intersection point between the border of scope and line from scope node center to given 'toNode'.
/// Padding allows controling how far inside from the border is the intersection computed.
/// </summary>
/// <param name="scopeNode">The scope node.</param>
/// <param name="toNode">To node.</param>
/// <param name="paddingLeft">The padding left.</param>
/// <param name="paddingTop">The padding top.</param>
/// <param name="paddingRight">The padding right.</param>
/// <param name="paddingBottom">The padding bottom.</param>
/// <param name="topCanvasOffset">The top canvas offset - represents the offset from top border of the scope to start of the inside canvas.
/// Needed because of label above the canvas.</param>
/// <returns>
/// Intersection point between scope's border and line from scope center to given 'toNode'. Returns null point if lines do not intersect.
/// </returns>
public static Point? GetIntersection(TraceLab.Core.Experiments.ScopeNode scopeNode, TraceLab.Core.Experiments.ExperimentNode toNode,
double paddingLeft, double paddingTop, double paddingRight, double paddingBottom, double topCanvasOffset)
{
//calculate optimal x of intersection between scope node center to its
Point scopeCenter = new Point(scopeNode.Data.X, scopeNode.Data.Y);
Point endNodeCenter = new Point(toNode.Data.X, toNode.Data.Y);
//corners including padding
Point topLeftCorner = new Point(scopeCenter.X - scopeNode.DataWithSize.Width / 2 + paddingLeft, scopeCenter.Y - scopeNode.DataWithSize.Height / 2 + paddingTop + topCanvasOffset);
Point topRightCorner = new Point(scopeCenter.X + scopeNode.DataWithSize.Width / 2 - paddingRight, scopeCenter.Y - scopeNode.DataWithSize.Height / 2 + paddingTop + topCanvasOffset);
Point bottomLeftCorner = new Point(scopeCenter.X - scopeNode.DataWithSize.Width / 2 + paddingLeft, scopeCenter.Y + scopeNode.DataWithSize.Height / 2 - paddingBottom);
Point bottomRightCorner = new Point(scopeCenter.X + scopeNode.DataWithSize.Width / 2 - paddingRight, scopeCenter.Y + scopeNode.DataWithSize.Height / 2 - paddingBottom);
Point? intersectionOnMainCanvas;
if (TryFindIntersection(scopeCenter, endNodeCenter, bottomLeftCorner, bottomRightCorner, out intersectionOnMainCanvas)) { } /* top */
else if (TryFindIntersection(scopeCenter, endNodeCenter, bottomRightCorner, topRightCorner, out intersectionOnMainCanvas)) { } /* right */
else if (TryFindIntersection(scopeCenter, endNodeCenter, bottomLeftCorner, topLeftCorner, out intersectionOnMainCanvas)) { } /* left */
else if (TryFindIntersection(scopeCenter, endNodeCenter, topLeftCorner, topRightCorner, out intersectionOnMainCanvas)) { } /* top */
//scope has it's own canvas with its own origin point, which is located in top left corner of the scope
//therefore the computed point must be adjusted relatively to the scope canvas origin
Point? adjustedIntersection = null;
if (intersectionOnMainCanvas != null)
{
adjustedIntersection = AdjustPointToScopeCanvasOrigin(intersectionOnMainCanvas.Value, scopeNode, topCanvasOffset, ref scopeCenter);
}
return adjustedIntersection;
}
/// <summary>
/// Modifies experiment to add reference to new package.
/// </summary>
/// <param name="pPkg">The package being created.</param>
/// <param name="pExperimentFile">The experiment file.</param>
/// <returns>True is there was no error during the operation, false otherwise.</returns>
private static bool AddPkgRefToExperiment(TraceLab.Core.PackageSystem.Package pPkg, string pExperimentFile)
{
bool noError = true;
if (System.IO.File.Exists(pExperimentFile))
{
try
{
XmlDocument xmlExperiment = new XmlDocument();
xmlExperiment.Load(pExperimentFile);
XmlNode nodeReferences = xmlExperiment.SelectSingleNode("//References");
XmlElement newPkgReference = xmlExperiment.CreateElement("PackageReference");
newPkgReference.SetAttribute("ID", pPkg.ID);
newPkgReference.SetAttribute("Name", pPkg.Name);
nodeReferences.AppendChild(newPkgReference);
xmlExperiment.Save(pExperimentFile);
}
catch (Exception)
{
noError = false;
throw new TraceLab.Core.Exceptions.PackageCreationFailureException("Unable to modify experiment - reference to new package could not be added.");
}
}
else
{
noError = false;
}
return noError;
}
public ComponentExceptionDisplayViewModel(TraceLab.Core.ViewModels.ComponentLogInfo logInfo)
{
LogInfo = logInfo;
if (LogInfo.Exception != null)
{
ExceptionType = LogInfo.Exception.GetType().FullName;
StringBuilder shortStack = new StringBuilder();
using (StringReader reader = new StringReader(LogInfo.Exception.StackTrace))
{
string line;
while ((line = reader.ReadLine()) != null)
{
if (line.StartsWith("Server stack trace: "))
{
shortStack.AppendLine("Exception trace:");
continue;
}
if(line.Trim().StartsWith("at System.Runtime.Remoting.Messaging"))
{
break;
}
shortStack.AppendLine(line);
}
}
ShortStackTrace = shortStack.ToString();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RunnableDecisionNode"/> class.
/// </summary>
/// <param name="id">The id of this decision node.</param>
/// <param name="label">The label - useful for debugging.</param>
/// <param name="decisionModule">The decision module that is going to be invoked to select nodes to be executed after decision</param>
/// <param name="library">The reference to the components library.</param>
public RunnableDecisionNode(String id, String label, TraceLab.Core.Decisions.IDecisionModule decisionModule, ComponentsLibrary library, bool waitForAllPredecessors)
: base(id, label, new RunnableNodeCollection(), new RunnableNodeCollection(), library, waitForAllPredecessors)
{
if (decisionModule == null)
throw new ArgumentNullException("decisionModule");
m_candidateNodes = new RunnableNodeCollection();
m_decisionModule = decisionModule;
}
public static void Run(TraceLab.Core.ViewModels.ApplicationViewModel context)
{
var wrapper = new ApplicationViewModelWrapper(context);
var app = new Application();
Window wind = new MainWindow(wrapper);
app.Run(wind);
}
private void SavePositionAndZoom(TraceLab.UI.WPF.ViewModels.IZoomableViewModel oldModel)
{
if (oldModel != null)
{
oldModel.TranslateX = ZoomControl.TranslateX;
oldModel.TranslateY = ZoomControl.TranslateY;
oldModel.Zoom = ZoomControl.Zoom;
}
}
public static void Run(TraceLab.Core.ViewModels.ApplicationViewModel applicationViewModel)
{
GLib.ExceptionManager.UnhandledException += new GLib.UnhandledExceptionHandler(ExceptionManager_UnhandledException);
Application.Init();
ApplicationContext app = new ApplicationContext(applicationViewModel);
app.InitializeWindow();
Application.Run();
}
/// <summary>
/// Initializes a new instance of the <see cref="RunnableNode"/> class.
/// </summary>
/// <param name="id">The id.</param>
/// <param name="label">The label.</param>
/// <param name="nextNodes">The next nodes.</param>
/// <param name="previousNodes">The previous nodes.</param>
/// <param name="library">The library.</param>
/// <param name="waitForAllPredecessor">if set to <c>true</c> the node will wait for all predecessor nodes to be completed.</param>
protected RunnableNode(String id, String label, RunnableNodeCollection nextNodes, RunnableNodeCollection previousNodes, TraceLab.Core.Components.ComponentsLibrary library, bool waitForAllPredecessors)
{
Id = id;
Label = label;
NextNodes = nextNodes;
PreviousNodes = previousNodes;
Library = library;
WaitsForAllPredecessors = waitForAllPredecessors;
}
public BenchmarkWizard(string benchmarkDirectory, ComponentsLibrary library, Workspace workspace,
List<string> workspaceTypeDirectories, string dataRoot, TraceLab.Core.Settings.Settings settings)
{
m_workspace = workspace;
m_componentsLibrary = library;
m_dataRoot = dataRoot;
m_settings = settings;
BenchmarksDirectory = benchmarkDirectory;
}
/// <summary>
/// Initializes a new s_instance of the <see cref="CompositeComponentMetadataDefinition"/> class.
/// </summary>
/// <param name="id">The id.</param>
/// <param name="componentSourceFile">The component source file.</param>
/// <param name="componentName">Name of the component.</param>
/// <param name="label">The label.</param>
/// <param name="version">The version.</param>
/// <param name="description">The description.</param>
/// <param name="author">The author.</param>
public CompositeComponentMetadataDefinition(string id,
TraceLab.Core.Experiments.CompositeComponentGraph componentGraph,
string componentSourceFile, string componentName, string label, string version, string description, string author,
ComponentTags tags, List<DocumentationLink> documentationLinks)
: base(id, componentSourceFile, componentName, label, version, description, author, tags, documentationLinks)
{
ComponentGraph = componentGraph;
IOSpecDefinition = new IOSpecDefinition();
ConfigurationWrapperDefinition = new ConfigWrapperDefinition(false, null);
}
private void SetPositionAndZoom(TraceLab.UI.WPF.ViewModels.IZoomableViewModel newModel)
{
//if (newModel != null)
//{
// double newX = newModel.TranslateX;
// double newY = newModel.TranslateY;
// double newZoom = newModel.Zoom;
// zoomControl.SetPositionAndZoom(newX, newY, newZoom);
//}
}
/// <summary>
/// Initializes a new instance of the <see cref="RunnableLoopNode"/> class.
/// </summary>
/// <param name="id">The id.</param>
/// <param name="loopDecisionModule">The loop decision module.</param>
/// <param name="compositeComponentMetadata">The composite component metadata.</param>
/// <param name="templateGraph">The template graph.</param>
/// <param name="workspaceWrapper">The composite component workspace wrapper.</param>
/// <param name="library">The library.</param>
/// <param name="waitForAllPredecessors">if set to <c>true</c> [wait for all predecessors].</param>
public RunnableLoopNode(String id,
TraceLab.Core.Decisions.ILoopDecisionModule loopDecisionModule,
CompositeComponentBaseMetadata compositeComponentMetadata,
RunnableExperimentBase templateGraph,
NestedWorkspaceWrapper workspaceWrapper,
TraceLab.Core.Components.ComponentsLibrary library,
bool waitForAllPredecessors)
: base(id, compositeComponentMetadata, templateGraph, workspaceWrapper, library, waitForAllPredecessors)
{
m_loopDecisionModule = loopDecisionModule;
}
/// <summary>
/// Initializes a new s_instance of the <see cref="RunnableCompositeComponentNode"/> class.
/// </summary>
/// <param name="id">The id.</param>
/// <param name="compositeComponentMetadata">The composite component metadata.</param>
/// <param name="templateGraph">The template graph.</param>
/// <param name="workspaceWrapper">The composite component workspace wrapper.</param>
public RunnableCompositeComponentNode(String id,
CompositeComponentBaseMetadata compositeComponentMetadata,
RunnableExperimentBase templateGraph,
NestedWorkspaceWrapper workspaceWrapper,
TraceLab.Core.Components.ComponentsLibrary library,
bool waitForAllPredecessors)
: base(id, compositeComponentMetadata.Label, new RunnableNodeCollection(), new RunnableNodeCollection(), library, waitForAllPredecessors)
{
m_compositeComponentMetadata = compositeComponentMetadata;
m_subLevelExperiment = templateGraph;
m_workspace = workspaceWrapper;
}
protected virtual void InitializeComponentGraph(TraceLab.Core.Settings.Settings settings)
{
if (CompositeComponentMetadata.HasDeserializationError == false)
{
CompositeComponentMetadata.InitializeComponentGraph(this, settings);
//subscribe to subworkflow errors
INotifyCollectionChanged subexperimentErrorCollection = CompositeComponentMetadata.ComponentGraph.Errors;
subexperimentErrorCollection.CollectionChanged += SubExperimentErrorCollectionChanged;
}
}
public static void OpenNewExperiment(TraceLab.Core.ViewModels.ApplicationViewModel context, string experimentFilepath)
{
//find any MainWindow
Application.Current.Dispatcher.Invoke(new Action(delegate()
{
//first search through opened MainWindows to see if any window already have the given experimentFilename opened
bool found = TryActivateExistingWindow(experimentFilepath);
if (found == false)
{
OpenExperimentInNewWindow(experimentFilepath);
}
}));
}
/// <summary>
/// Initializes a new s_instance of the <see cref="RunnableExperiment"/> class.
/// </summary>
/// <param name="nodesFactory">The nodes factory that is going to be used to create nodes when nodes are added to template graph.</param>
/// <param name="library">The library.</param>
/// <param name="componentsAppDomain">The components app domain is the app domain which components assemblies are going to be loaded into.</param>
/// <param name="terminateExperimentExecutionResetEvent">The event that allows signalling termination of the experiment</param>
public RunnableExperiment(IRunnableNodeFactory nodesFactory, TraceLab.Core.Components.ComponentsLibrary library,
AppDomain componentsAppDomain, System.Threading.ManualResetEvent terminateExperimentExecutionResetEvent)
{
if (componentsAppDomain == null)
throw new ArgumentNullException("componentsAppDomain");
if (terminateExperimentExecutionResetEvent == null)
throw new ArgumentNullException("terminateExperimentExecutionResetEvent");
m_componentsAppDomain = componentsAppDomain;
m_terminateExperimentExecutionResetEvent = terminateExperimentExecutionResetEvent;
m_nodes = new RunnableNodeCollection();
m_nodesFactory = nodesFactory;
Library = library;
}
public ComponentLibraryViewModel(TraceLab.Core.Components.ComponentsLibrary componentsLibraryInstance, IEnumerable<string> workspaceTypeDirectories)
{
if (componentsLibraryInstance == null)
throw new ArgumentNullException("componentsLibraryInstance");
// We'll use this collection to determine which PropertyChanged notifications to pass on.
foreach (PropertyInfo prop in typeof(ComponentLibraryViewModel).GetProperties())
{
m_validProperties.Add(prop.Name);
}
m_componentsLibraryInstance = componentsLibraryInstance;
m_componentsLibraryInstance.PropertyChanged += m_componentsLibraryInstance_PropertyChanged;
m_componentsLibraryInstance.Rescanning += m_componentsLibraryInstance_Rescanning;
m_componentsLibraryInstance.Rescanned += m_componentsLibraryInstance_Rescanned;
m_workspaceTypeDirectories = workspaceTypeDirectories;
}
/// <summary>
/// Loads a experiment from the specified file.
/// </summary>
/// <param name="filename">The filename.</param>
/// <exception cref="TraceLab.Core.Exceptions.ExperimentLoadException">throws if experiment load fails</exception>
/// <returns>
/// Returns loaded m_experiment. If loading failed it returns null.
/// </returns>
public static Experiment Load(string fileName, TraceLab.Core.Components.ComponentsLibrary library)
{
Experiment experiment = null;
try
{
using (System.Xml.XmlReader reader = System.Xml.XmlReader.Create(fileName))
{
experiment = ExperimentSerializer.DeserializeExperiment(reader, library, fileName);
}
if (experiment != null)
{
experiment.ResetModifiedFlag();
}
}
catch (ArgumentException e)
{
throw new ExperimentLoadException("The experiment file could not be loaded. Filename cannot be empty. ", e);
}
catch (System.Security.SecurityException e)
{
throw new ExperimentLoadException("The experiment file could not be loaded.", e);
}
catch (System.IO.FileNotFoundException e)
{
throw new ExperimentLoadException("The experiment file has not been found.", e);
}
catch (System.IO.DirectoryNotFoundException e)
{
throw new ExperimentLoadException("The directory has not been found.", e);
}
catch (UriFormatException e)
{
throw new ExperimentLoadException("The experiment is corrupted and could not be loaded.", e);
}
catch (System.Xml.XmlException e)
{
throw new ExperimentLoadException("The experiment is corrupted and could not be loaded.", e);
}
return experiment;
}
/// <summary>
/// Deserializes the experiment.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="experimentFilename">The experiment filename - needed so that experiment can set all relative config paths in relation to experiment location.</param>
/// <returns></returns>
internal static Experiment DeserializeExperiment(XmlReader reader, TraceLab.Core.Components.IComponentsLibrary library, string experimentFilename)
{
Experiment loadedFlow = null;
if (reader != null)
{
IXPathNavigable doc = new XPathDocument(reader);
var serializer = TraceLab.Core.Serialization.XmlSerializerFactory.GetSerializer(typeof(PackageSystem.PackageReference), Type.EmptyTypes);
var references = new ObservableCollection<IPackageReference>();
// Get the references:
var nav = doc.CreateNavigator();
var referenceIter = nav.Select("/graph/References/PackageReference");
if (referenceIter != null)
{
while (referenceIter.MoveNext())
{
var reference= (IPackageReference)serializer.Deserialize(referenceIter.Current.ReadSubtree());
references.Add(reference);
}
}
var graphFactory = new ExperimentFactoryReader(library, references, System.IO.Path.GetDirectoryName(experimentFilename));
loadedFlow = QuickGraph.Serialization.SerializationExtensions.DeserializeFromXml<ExperimentNode, ExperimentNodeConnection, Experiment>(doc,
"/graph", "/graph/node", "/graph/edge",
graphFactory.GraphFactory,
graphFactory.NodeFactory,
graphFactory.EdgeFactory
);
loadedFlow.References = references;
//Update the loaded graph and sets its start and end node
loadedFlow.ReloadStartAndEndNode();
loadedFlow.ExperimentInfo.FilePath = experimentFilename;
}
return loadedFlow;
}
/// <summary>
/// Adds item and its content (file or folder) to package.
/// </summary>
/// <param name="pPkg">Package being created.</param>
/// <param name="item">Item to be added.</param>
/// <returns>True is there was no error during the operation, false otherwise.</returns>
public static bool AddItemToPackage(TraceLab.Core.PackageSystem.Package pkg, PackageFileSourceInfo item, bool isExperimentPackage)
{
bool noError = true;
string targetPath = System.IO.Path.Combine(pkg.Location, item.GetPath());
PackageHeirarchyItem dir = item as PackageHeirarchyItem;
if (dir != null)
{
if (item.Parent != null)
{
System.IO.Directory.CreateDirectory(targetPath);
}
foreach (PackageFileSourceInfo child in dir.Children)
{
noError = noError && AddItemToPackage(pkg, child, isExperimentPackage);
}
if (dir.HasComponents)
{
pkg.SetDirectoryHasComponents(dir.GetPath(), true);
}
if (dir.HasTypes)
{
pkg.SetDirectoryHasTypes(dir.GetPath(), true);
}
}
else
{
System.IO.File.Copy(item.SourceFilePath, targetPath);
//Add reference to this created package to all experiments and composite components
if (isExperimentPackage && targetPath.EndsWith(".teml") || targetPath.EndsWith(".tcml"))
{
noError = noError && AddPkgRefToExperiment(pkg, targetPath);
}
System.IO.File.SetAttributes(targetPath, System.IO.File.GetAttributes(targetPath) & ~System.IO.FileAttributes.ReadOnly);
pkg.AddFile(targetPath);
}
return noError;
}
/// <summary>
/// A WPF-aware viewmodel to wrap the main system WorkspaceViewModel.
///
/// Note: This must be constructed on the main UI thread.
/// </summary>
/// <param name="workspaceViewModel">The WorkspaceViewModel to wrap.</param>
public WorkspaceViewModelWrapper(TraceLab.Core.ViewModels.WorkspaceViewModel workspaceViewModel)
{
if (workspaceViewModel == null)
throw new ArgumentNullException("workspaceViewModel");
m_workspaceViewModel = workspaceViewModel;
m_workspaceViewModel.PropertyChanged += new PropertyChangedEventHandler(m_workspaceViewModel_PropertyChanged);
Dispatch = Dispatcher.CurrentDispatcher;
// Pre-fill our units with what's in the workspace view model prior to exposing it
// this is a mild performance tweak.
foreach (WorkspaceUnit unit in m_workspaceViewModel.WorkspaceUnitCollection)
{
AddUnit(unit);
}
m_readOnlyUnits = new ReadOnlyObservableCollection<WpfWorkspaceUnitWrapper>(m_units);
INotifyCollectionChanged workspaceCollection = m_workspaceViewModel.WorkspaceUnitCollection;
workspaceCollection.CollectionChanged += WorkspaceCollectionCollectionChanged;
}
internal static IExperimentRunner CreateExperimentRunner(IExperiment currentExperiment,
TraceLab.Core.Workspaces.Workspace workspace,
TraceLab.Core.Components.ComponentsLibrary library)
{
// Allow all nodes to send info to logs - if any targets exist.
foreach (TraceLab.Core.Experiments.ExperimentNode node in currentExperiment.Vertices)
{
var componentNode = node as TraceLab.Core.Experiments.ComponentNode;
if (componentNode != null)
{
foreach (TraceLab.Core.Settings.LogLevelItem item in componentNode.Data.Metadata.LogLevels)
{
item.IsEnabled = true;
}
}
}
RunnableNodeFactory templateGraphNodesFactory = new RunnableNodeFactory(workspace);
TraceLab.Core.ExperimentExecution.RunnableExperimentBase template = GraphAdapter.Adapt(currentExperiment, templateGraphNodesFactory, library, workspace.TypeDirectories);
var dispatcher = ExperimentRunnerFactory.CreateExperimentRunner(template);
return dispatcher;
}
private static void ReloadApplicationViewModel(TraceLab.Core.Experiments.Experiment experiment)
{
ConsoleInstance.StopListenToLogEvents();
ConsoleInstance.Application = ApplicationViewModel.CreateNewApplicationViewModel(ConsoleInstance.Application, experiment);
ConsoleInstance.StartListenToLogEvents();
}
/// <summary>
/// Gets the origin canvas point of the scope
/// </summary>
/// <param name="scopeNode">The scope node.</param>
/// <param name="topCanvasOffset">The top canvas offset.</param>
/// <param name="scopeCenter">The scope center.</param>
/// <returns></returns>
private static Point GetOriginCanvasPoint(TraceLab.Core.Experiments.ScopeNodeBase scopeNode, double topCanvasOffset, ref Point scopeCenter)
{
Point originCanvasPoint = new Point(scopeCenter.X - scopeNode.DataWithSize.Width / 2, scopeCenter.Y - scopeNode.DataWithSize.Height / 2 + topCanvasOffset);
return originCanvasPoint;
}
/// <summary>
/// Adjusts the point to scope canvas origin of the scope node
/// </summary>
/// <param name="pointToAdjust">The point to adjust.</param>
/// <param name="scopeNode">The scope node.</param>
/// <param name="topCanvasOffset">The top canvas offset - represents the offset from top border of the scope to start of the inside canvas. </param>
/// <param name="scopeCenter">The scope center.</param>
/// <returns></returns>
private static Point AdjustPointToScopeCanvasOrigin(Point pointToAdjust, TraceLab.Core.Experiments.ScopeNodeBase scopeNode, double topCanvasOffset, ref Point scopeCenter)
{
Point originCanvasPoint = GetOriginCanvasPoint(scopeNode, topCanvasOffset, ref scopeCenter);
Point adjustedPoint = AdjustPointToGivenOriginPoint(pointToAdjust, ref originCanvasPoint);
return adjustedPoint;
}
/// <summary>
/// Gets the point of top border center with a given padding to border
/// </summary>
/// <param name="scopeNode">The scope node.</param>
/// <param name="paddingBottom">The padding from top border.</param>
/// <param name="topCanvasOffset">The top canvas offset - scope may have label, thus graph canvas is off by some amount from top.</param>
/// <returns>top border center</returns>
public static Point GetTopBorderCenter(TraceLab.Core.Experiments.ScopeNodeBase scopeNode, double paddingTop, double topCanvasOffset)
{
Point scopeCenter = new Point(scopeNode.Data.X, scopeNode.Data.Y);
Point topBorderCenter = new Point(scopeCenter.X, scopeCenter.Y - scopeNode.DataWithSize.Height / 2 + paddingTop + topCanvasOffset);
Point adjustedPoint = AdjustPointToScopeCanvasOrigin(topBorderCenter, scopeNode, topCanvasOffset, ref scopeCenter);
return adjustedPoint;
}
public RunnableNode CreateNode(string id, Metadata metadata, LoggerNameRoot loggerNameRoot, TraceLab.Core.Components.ComponentsLibrary library, AppDomain componentsAppDomain,
System.Threading.ManualResetEvent terminateExperimentExecutionResetEvent)
{
return CreateNode(id, metadata, terminateExperimentExecutionResetEvent);
}
/// <summary>
/// Initializes the component graph from ComponentMetadataDefinition graph
/// </summary>
/// <param name="node">The node.</param>
/// <param name="settings">The settings.</param>
public override void InitializeComponentGraph(CompositeComponentNode node, TraceLab.Core.Settings.Settings settings)
{
//each composite node gets its own copy of ComponentMetadataDefinition.ComponentGraph
m_compositeComponentGraph = new CompositeComponentGraph(node, ComponentMetadataDefinition.ComponentGraph);
m_compositeComponentGraph.Settings = settings;
}
protected virtual void InitializeComponentGraph(TraceLab.Core.Settings.Settings settings)
{
CompositeComponentMetadata.InitializeComponentGraph(this, settings);
}
