protected void OnLoadLayout(object sender, FileEventArgs e)
{
string layoutFilename = Path.Combine(Path.GetDirectoryName(e.Filename), Path.GetFileNameWithoutExtension(e.Filename) + "-layout.xml");
if (File.Exists(layoutFilename))
{
// Use the layout file to determine the canvas files.
ServiceManager.Get <IFlowSharpEditService>().ClearSavePoints();
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
IFlowSharpPropertyGridService pgService = ServiceManager.Get <IFlowSharpPropertyGridService>();
canvasService.Controllers.ForEach(c => pgService.Terminate(c));
canvasService.ClearControllers();
loading = true;
ServiceManager.Get <IDockingFormService>().LoadLayout(layoutFilename);
loading = false;
// Update all services with new controllers.
canvasService.Controllers.ForEach(c => InformServicesOfNewCanvas(c));
EnableCanvasPaint();
SelectFirstDocument();
}
else
{
// Just open the diagram the currently selected canvas.
BaseController canvasController = ServiceManager.Get <IFlowSharpCanvasService>().ActiveController;
ServiceManager.Get <IFlowSharpEditService>().ClearSavePoints();
LoadFileIntoCanvas(e.Filename, Constants.META_CANVAS, canvasController);
}
}
protected void Compile()
{
tempToTextBoxMap.Clear();
var outputWindow = ServiceManager.Get <IFlowSharpCodeOutputWindowService>();
outputWindow.Clear();
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
IFlowSharpMenuService menuService = ServiceManager.Get <IFlowSharpMenuService>();
IFlowSharpCodeService codeService = ServiceManager.Get <IFlowSharpCodeService>();
BaseController canvasController = canvasService.ActiveController;
List <string> refs = GetCanvasReferences(canvasController);
List <GraphicElement> shapeSources = GetCanvasSources(canvasController);
List <string> sourceFilenames = GetSourceFiles(shapeSources);
bool isStandAlone = runner is StandAloneRunner;
string filename = GetExeOrDllFilename(menuService.Filename);
CompilerResults results = Compile(filename, sourceFilenames, refs, isStandAlone);
DeleteTempFiles(sourceFilenames);
if (!results.Errors.HasErrors)
{
outputWindow.WriteLine("No Errors");
}
}
private void mnuOpen_Click(object sender, EventArgs e)
{
if (CheckForChanges())
{
return;
}
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = "FlowSharp (*.fsd)|*.fsd";
DialogResult res = ofd.ShowDialog();
if (res == DialogResult.OK)
{
filename = ofd.FileName;
}
else
{
return;
}
IFlowSharpCanvasService canvasService = serviceManager.Get <IFlowSharpCanvasService>();
canvasService.LoadDiagrams(filename);
UpdateCaption();
UpdateMru(filename);
}
protected void OnRun(object sender, EventArgs e)
{
var outputWindow = ServiceManager.Get <IFlowSharpCodeOutputWindowService>();
var fscSvc = ServiceManager.Get <IFlowSharpCodeService>();
outputWindow.Clear();
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
BaseController canvasController = canvasService.ActiveController;
// One and only one Python class element must be selected.
if (canvasController.SelectedElements.Count == 1)
{
var el = canvasController.SelectedElements[0];
if (el is IPythonClass)
{
// TODO: Unify with FlowSharpCodeCompilerService.Run
string filename = ((IPythonClass)el).Filename;
fscSvc.LaunchProcess("python", filename,
stdout => outputWindow.WriteLine(stdout),
stderr => outputWindow.WriteLine(stderr));
}
else
{
outputWindow.WriteLine("Please select a Python class file to run.");
}
}
else
{
outputWindow.WriteLine("Please select a single Python class file to run.");
}
}
public ClosingState CheckForChanges()
{
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
bool changed = canvasService.Controllers.Any(c => GetSavePoint(c) != c.UndoStack.UndoStackSize);
ClosingState ret = ClosingState.NoChanges;
if (changed)
{
DialogResult res = MessageBox.Show("Do you wish to save changes to this drawing?", "Save Changes", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
switch (res)
{
case DialogResult.Cancel:
ret = ClosingState.CancelClose;
break;
case DialogResult.Yes:
ret = ClosingState.SaveChanges;
break;
case DialogResult.No:
ret = ClosingState.ExitWithoutSaving;
break;
}
}
return(ret);
}
protected void RemoveRouting()
{
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
BaseController canvasController = canvasService.ActiveController;
var receptorConnections = canvasController.Elements.Where(el => el.Name == "_RCPTRCONN_").ToList();
receptorConnections.ForEach(rc => canvasController.DeleteElement(rc));
}
protected List <IAgentReceptor> GetReceptors()
{
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
BaseController canvasController = canvasService.ActiveController;
List <IAgentReceptor> receptors = GetReceptors(canvasController);
return(receptors);
}
protected void SaveDiagram(string filename)
{
IFlowSharpCanvasService canvasService = serviceManager.Get <IFlowSharpCanvasService>();
canvasService.SaveDiagramsAndLayout(filename);
//BaseController canvasController = serviceManager.Get<IFlowSharpCanvasService>().ActiveController;
//string data = Persist.Serialize(canvasController.Elements);
//File.WriteAllText(filename, data);
serviceManager.Get <IFlowSharpEditService>().SetSavePoint();
}
protected void OnCodeEditorServiceTextChanged(object sender, TextChangedEventArgs e)
{
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
if (canvasService.ActiveController.SelectedElements.Count == 1)
{
GraphicElement el = canvasService.ActiveController.SelectedElements[0];
el.Json["Code"] = e.Text;
}
}
public void RemoveCarriers()
{
lock (this)
{
IFlowSharpCanvasService canvasService = serviceManager.Get <IFlowSharpCanvasService>();
BaseController canvasController = canvasService.ActiveController;
carriers.ForEach(c => canvasController.DeleteElement(c));
carriers.Clear();
}
}
// TODO: We want to be able to associate many different code types with the same shape.
// This requires setting the Json dictionary appropriately for whatever editor is generating the event.
// Are we doing this the right why?
protected void OnCSharpEditorServiceTextChanged(object sender, TextChangedEventArgs e)
{
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
if (canvasService.ActiveController.SelectedElements.Count == 1)
{
GraphicElement el = canvasService.ActiveController.SelectedElements[0];
el.Json["Code"] = e.Text; // Should we call this C# or CSharp?
el.Json["TextChanged"] = true.ToString();
}
}
protected void OnScintillaEditorServiceTextChanged(object sender, TextChangedEventArgs e)
{
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
if (canvasService.ActiveController.SelectedElements.Count == 1)
{
GraphicElement el = canvasService.ActiveController.SelectedElements[0];
el.Json[e.Language] = e.Text; // TODO: Should we call this Script or something else?
el.Json["TextChanged"] = true.ToString();
}
}
protected void OnCompile(object sender, EventArgs e)
{
var outputWindow = ServiceManager.Get <IFlowSharpCodeOutputWindowService>();
outputWindow.Clear();
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
BaseController canvasController = canvasService.ActiveController;
// List<GraphicElement> rootSourceShapes = GetSources(canvasController);
CompileClassSources(canvasController);
RunLint(canvasController);
}
private void OnRecentFileSelected(object sender, EventArgs e)
{
if (CheckForChanges())
{
return;
}
ToolStripItem tsi = sender as ToolStripItem;
filename = tsi.Text;
IFlowSharpCanvasService canvasService = serviceManager.Get <IFlowSharpCanvasService>();
canvasService.LoadDiagrams(filename);
UpdateCaption();
}
protected void Initialize()
{
IFlowSharpMenuService menuService = ServiceManager.Get <IFlowSharpMenuService>();
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
IFlowSharpMouseControllerService mouseService = ServiceManager.Get <IFlowSharpMouseControllerService>();
menuService.Initialize(form);
menuService.Initialize(canvasService.ActiveController);
canvasService.AddCanvas += (sndr, args) => CreateCanvas();
canvasService.LoadLayout += OnLoadLayout;
canvasService.SaveLayout += OnSaveLayout;
// mouseService.Initialize(canvasService.ActiveController);
InformServicesOfNewCanvas(canvasService.ActiveController);
}
protected void EnableCanvasPaint()
{
// Enable canvas paint after all initialization has completed,
// because adding certain controls, like TextboxShape, causes a panel canvas OnPaint to be called
// when the TextboxShape is being added to the toolbox canvas, and this results in all shapes
// attempting to draw, and they are not fully initialized at this point!
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
canvasService.Controllers.ForEach(c => c.Canvas.EndInit());
canvasService.Controllers.ForEach(c => c.Canvas.Invalidate());
IFlowSharpToolboxService toolboxService = ServiceManager.Get <IFlowSharpToolboxService>();
toolboxService.Controller.Canvas.EndInit();
toolboxService.Controller.Canvas.Invalidate();
}
protected void CreateCanvas()
{
// Create canvas.
Panel panel = new Panel()
{
Dock = DockStyle.Fill, Tag = Constants.META_CANVAS
};
Control dockPanel = ServiceManager.Get <IDockingFormService>().CreateDocument(DockState.Document, "Canvas", Constants.META_CANVAS);
dockPanel.Controls.Add(panel);
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
canvasService.CreateCanvas(panel);
canvasService.ActiveController.Canvas.EndInit();
InformServicesOfNewCanvas(canvasService.ActiveController);
}
public void Compile()
{
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
IFlowSharpMenuService menuService = ServiceManager.Get <IFlowSharpMenuService>();
BaseController canvasController = canvasService.ActiveController;
tempToTextBoxMap.Clear();
List <GraphicElement> compiledAssemblies = new List <GraphicElement>();
bool ok = CompileAssemblies(canvasController, compiledAssemblies);
if (!ok)
{
DeleteTempFiles();
return;
}
List <string> refs = new List <string>();
List <string> sources = new List <string>();
List <GraphicElement> rootSourceShapes = GetSources(canvasController);
rootSourceShapes.ForEach(root => GetReferencedAssemblies(root).Where(refassy => refassy is IAssemblyBox).ForEach(refassy => refs.Add(((IAssemblyBox)refassy).Filename)));
// Get code for workflow boxes first, as this code will then be included in the rootSourceShape code listing.
IEnumerable <GraphicElement> workflowShapes = canvasController.Elements.Where(el => el is IWorkflowBox);
workflowShapes.ForEach(wf =>
{
string code = GetWorkflowCode(canvasController, wf);
wf.Json["Code"] = code;
// CreateCodeFile(wf, sources, code);
});
// TODO: Better Linq!
rootSourceShapes.Where(root => !String.IsNullOrEmpty(GetCode(root))).ForEach(root =>
{
CreateCodeFile(root, sources, GetCode(root));
});
exeFilename = String.IsNullOrEmpty(menuService.Filename) ? "temp.exe" : Path.GetFileNameWithoutExtension(menuService.Filename) + ".exe";
Compile(exeFilename, sources, refs, true);
DeleteTempFiles();
}
protected void EnableCanvasPaint()
{
// Enable canvas paint after all initialization has completed,
// because adding certain controls, like TextboxShape, causes a panel canvas OnPaint to be called
// when the TextboxShape is being added to the toolbox canvas, and this results in all shapes
// attempting to draw, and they are not fully initialized at this point!
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
canvasService.Controllers.ForEach(c => c.Canvas.EndInit());
canvasService.Controllers.ForEach(c => c.Canvas.Invalidate());
IFlowSharpToolboxService toolboxService = ServiceManager.Get <IFlowSharpToolboxService>();
// Will be null if canvas was not created when app starts. Sanity check here
// mainly for when we debug a form with no panels initialized by default.
if (toolboxService.Controller != null)
{
toolboxService.Controller.Canvas.EndInit();
toolboxService.Controller.Canvas.Invalidate();
}
}
protected void Initialize()
{
IFlowSharpMenuService menuService = ServiceManager.Get <IFlowSharpMenuService>();
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
IFlowSharpMouseControllerService mouseService = ServiceManager.Get <IFlowSharpMouseControllerService>();
menuService.Initialize(form);
canvasService.AddCanvas += (sndr, args) => CreateCanvas();
canvasService.LoadLayout += OnLoadLayout;
canvasService.SaveLayout += OnSaveLayout;
// mouseService.Initialize(canvasService.ActiveController);
// Will be null if canvas was not created when app starts. Sanity check here
// mainly for when we debug a form with no panels initialized by default.
if (canvasService.ActiveController != null)
{
menuService.Initialize(canvasService.ActiveController);
InformServicesOfNewCanvas(canvasService.ActiveController);
}
}
protected void CreateConnectors(List <ReceptorDescription> descr)
{
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
BaseController canvasController = canvasService.ActiveController;
Canvas canvas = canvasController.Canvas;
descr.ForEach(d =>
{
// TODO: Deal with namespace handling better than this RightOof kludge.
// TODO: Converting to lowercase is a bit of a kludge as well.
GraphicElement elSrc = canvasController.Elements.SingleOrDefault(el => (el is IAgentReceptor) && el.Text.RemoveWhitespace().ToLower() == d.ReceptorTypeName.RightOf(".").ToLower());
if (elSrc != null)
{
d.Publishes.ForEach(p =>
{
// Get all receivers that receive the type being published.
var receivers = descr.Where(r => r.ReceivingSemanticType == p);
receivers.ForEach(r =>
{
// TODO: Deal with namespace handling better than this RightOof kludge.
// TODO: Converting to lowercase is a bit of a kludge as well.
GraphicElement elDest = canvasController.Elements.SingleOrDefault(el => (el is IAgentReceptor) && el.Text.RemoveWhitespace().ToLower() == r.ReceptorTypeName.RightOf(".").ToLower());
if (elDest != null)
{
DiagonalConnector dc = new DiagonalConnector(canvas, elSrc.DisplayRectangle.Center(), elDest.DisplayRectangle.Center());
dc.Name = "_RCPTRCONN_";
dc.EndCap = AvailableLineCap.Arrow;
dc.BorderPenColor = Color.Red;
dc.UpdateProperties();
canvasController.Insert(dc);
}
});
});
}
});
}
public void Compile()
{
TerminateRunningProcess();
var outputWindow = ServiceManager.Get <IFlowSharpCodeOutputWindowService>();
outputWindow.Clear();
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
IFlowSharpMenuService menuService = ServiceManager.Get <IFlowSharpMenuService>();
IFlowSharpCodeService codeService = ServiceManager.Get <IFlowSharpCodeService>();
BaseController canvasController = canvasService.ActiveController;
tempToTextBoxMap.Clear();
List <GraphicElement> compiledAssemblies = new List <GraphicElement>();
bool ok = CompileAssemblies(canvasController, compiledAssemblies);
if (!ok)
{
DeleteTempFiles();
return;
}
List <string> refs = new List <string>();
List <string> sources = new List <string>();
// Add specific assembly references on the drawing.
List <IAssemblyReferenceBox> references = GetReferences(canvasController);
refs.AddRange(references.Select(r => r.Filename));
List <GraphicElement> rootSourceShapes = GetSources(canvasController);
rootSourceShapes.ForEach(root => GetReferencedAssemblies(root).Where(refassy => refassy is IAssemblyBox).ForEach(refassy => refs.Add(((IAssemblyBox)refassy).Filename)));
// Get code for workflow boxes first, as this code will then be included in the rootSourceShape code listing.
IEnumerable <GraphicElement> workflowShapes = canvasController.Elements.Where(el => el is IWorkflowBox);
workflowShapes.ForEach(wf =>
{
string code = GetWorkflowCode(codeService, canvasController, wf);
wf.Json["Code"] = code;
});
List <GraphicElement> excludeClassShapes = new List <GraphicElement>();
List <GraphicElement> classes = GetClasses(canvasController);
// Get CSharpClass shapes that contain DRAKON shapes.
classes.Where(cls => HasDrakonShapes(canvasController, cls)).ForEach(cls =>
{
excludeClassShapes.AddRange(canvasController.Elements.Where(el => cls.DisplayRectangle.Contains(el.DisplayRectangle)));
DrakonCodeTree dcg = new DrakonCodeTree();
var workflowStart = codeService.FindStartOfWorkflow(canvasController, cls);
codeService.ParseDrakonWorkflow(dcg, codeService, canvasController, workflowStart);
var codeGenSvc = new CSharpCodeGeneratorService();
dcg.GenerateCode(codeGenSvc);
InsertCodeInRunWorkflowMethod(cls, codeGenSvc.CodeResult);
string filename = CreateCodeFile(cls);
sources.Add(filename);
});
rootSourceShapes.Where(root => !excludeClassShapes.Contains(root)).ForEach(root =>
{
// Get all other shapes that are not part of CSharpClass shapes:
// TODO: Better Linq!
if (!String.IsNullOrEmpty(GetCode(root)))
{
string filename = CreateCodeFile(root);
sources.Add(filename);
}
});
exeFilename = String.IsNullOrEmpty(menuService.Filename) ? "temp.exe" : Path.GetFileNameWithoutExtension(menuService.Filename) + ".exe";
Compile(exeFilename, sources, refs, true);
DeleteTempFiles();
if (!results.Errors.HasErrors)
{
outputWindow.WriteLine("No Errors");
}
}
public void SetSavePoint()
{
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
canvasService.Controllers.ForEach(c => SetSavePoint(c));
}
public void Animate(object sender, HopeRunnerAppDomainInterface.ProcessEventArgs args)
{
IFlowSharpCanvasService canvasService = serviceManager.Get <IFlowSharpCanvasService>();
BaseController canvasController = canvasService.ActiveController;
var(sourceShapeName, shapeType) = GetSourceShapeName(args);
GraphicElement elSrc = null;
GraphicElement elDest = null;
lock (this)
{
elSrc = GetElement(canvasController, sourceShapeName.RightOf('.'), shapeType);
elDest = GetElement(canvasController, args.ToReceptorTypeName.RightOf('.'), FromShapeType.Receptor);
}
if (ShowAnimation)
{
CarrierShape carrier = new CarrierShape(canvasController.Canvas);
carrier.DisplayRectangle = new Rectangle(elSrc.DisplayRectangle.Center().X, elSrc.DisplayRectangle.Center().Y, 10, 10);
canvasController.Canvas.FindForm().BeginInvoke(() =>
{
lock (this)
{
carriers.Add(carrier);
canvasController.Insert(carrier);
}
});
double dx = elDest.DisplayRectangle.Center().X - elSrc.DisplayRectangle.Center().X;
double dy = elDest.DisplayRectangle.Center().Y - elSrc.DisplayRectangle.Center().Y;
double steps = 20;
double subx = dx / steps;
double suby = dy / steps;
double px = elSrc.DisplayRectangle.Center().X;
double py = elSrc.DisplayRectangle.Center().Y;
for (int i = 0; i < steps; i++)
{
Application.DoEvents();
System.Threading.Thread.Sleep(25);
px += subx;
py += suby;
canvasController.Canvas.FindForm().BeginInvoke(() =>
{
lock (this)
{
Assert.SilentTry(() => canvasController.MoveElementTo(carrier, new Point((int)px, (int)py)));
}
});
}
lock (this)
{
carriers.Remove(carrier);
Assert.SilentTry(() => canvasController.DeleteElement(carrier));
}
}
if (ShowActivation)
{
canvasController.Canvas.FindForm().BeginInvoke(() =>
{
lock (this)
{
elDest.FillBrush.Color = Color.Blue;
canvasController.Redraw(elDest);
Application.DoEvents();
System.Threading.Thread.Sleep(25);
elDest.FillBrush.Color = ((IAgentReceptor)elDest).EnabledColor;
canvasController.Redraw(elDest);
Application.DoEvents();
System.Threading.Thread.Sleep(25);
}
});
}
}
protected void OnContentLoaded(object sender, ContentLoadedEventArgs e)
{
switch (e.Metadata.LeftOf(","))
{
case Constants.META_CANVAS:
pnlFlowSharp = new Panel()
{
Dock = DockStyle.Fill, Tag = Constants.META_CANVAS
};
e.DockContent.Controls.Add(pnlFlowSharp);
e.DockContent.Text = "Canvas";
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
canvasService.CreateCanvas(pnlFlowSharp);
BaseController baseController = ServiceManager.Get <IFlowSharpCanvasService>().ActiveController;
if (e.Metadata.Contains(","))
{
string filename = e.Metadata.Between(",", ",");
string canvasName = e.Metadata.RightOfRightmostOf(",");
canvasName = String.IsNullOrWhiteSpace(canvasName) ? "Canvas" : canvasName;
e.DockContent.Text = canvasName;
LoadFileIntoCanvas(filename, canvasName, baseController);
}
// ServiceManager.Get<IFlowSharpMouseControllerService>().Initialize(baseController);
break;
case Constants.META_TOOLBOX:
pnlToolbox = new Panel()
{
Dock = DockStyle.Fill, Tag = Constants.META_TOOLBOX
};
e.DockContent.Controls.Add(pnlToolbox);
e.DockContent.Text = "Toolbox";
break;
case Constants.META_PROPERTYGRID:
propGrid = new PropertyGrid()
{
Dock = DockStyle.Fill, Tag = Constants.META_PROPERTYGRID
};
e.DockContent.Controls.Add(propGrid);
e.DockContent.Text = "Property Grid";
ServiceManager.Get <IFlowSharpPropertyGridService>().Initialize(propGrid);
break;
default:
ContentResolver.Fire(this, e);
break;
}
// Associate the toolbox with a canvas controller after both canvas and toolbox panels are created.
// !!! This handles the defaultLayout configuration. !!!
if ((e.Metadata == Constants.META_CANVAS || e.Metadata == Constants.META_TOOLBOX) && (pnlFlowSharp != null && pnlToolbox != null))
{
IFlowSharpCanvasService canvasService = ServiceManager.Get <IFlowSharpCanvasService>();
BaseController canvasController = canvasService.ActiveController;
IFlowSharpToolboxService toolboxService = ServiceManager.Get <IFlowSharpToolboxService>();
toolboxService.CreateToolbox(pnlToolbox);
toolboxService.InitializeToolbox();
toolboxService.InitializePluginsInToolbox();
toolboxService.UpdateToolboxPaths();
}
//if ((e.Metadata == Constants.META_CANVAS || e.Metadata == Constants.META_PROPERTYGRID) && (pnlFlowSharp != null && propGrid != null))
//{
// ServiceManager.Get<IFlowSharpPropertyGridService>().Initialize(propGrid);
//}
}
