/// <summary>
/// Dialog for getting path input.
/// </summary>
/// <param name="view">The view.</param>
/// <returns>System.Object.</returns>
private object _pathInput(ExecutionView view)
{
var oldPath = FullPath.Get();
if (oldPath == null)
{
oldPath = ResolveFullPath(".", Services);
}
var fullpath = Dialogs.PathProvider.GetFolderPath(oldPath);
if (fullpath == null)
{
view.Abort("Path hasn't been selected");
return(null);
}
var relative = RelativePath(Services.CodeBaseFullPath, fullpath);
if (relative.Length > fullpath.Length)
{
return(fullpath);
}
return(relative);
}
/// <summary>
/// Accepts the component by appending to ComposeParts call.
/// </summary>
/// <param name="e">The edits provider used for accepting.</param>
/// <param name="view">The view where instance will be accepted.</param>
/// <returns>Variable with accepted instance and correct scope.</returns>
private object acceptAppendComponent(EditsProvider e, ExecutionView view)
{
var toAccept = UserInteraction.DraggedInstance;
var componentInfo = Services.GetComponentInfo(toAccept.Info);
if (componentInfo == null)
{
view.Abort("Can accept only components");
return(null);
}
return(e.GetVariableFor(toAccept, view));
}
/// <summary>
/// Dialog for path input.
/// </summary>
/// <param name="view">View where path edit will be processed.</param>
/// <returns>System.Object.</returns>
private object _pathInput(ExecutionView view)
{
var oldPath = FullPath.Get();
var path = Dialogs.PathProvider.GetAssemblyPath(oldPath);
if (path == null)
{
view.Abort("Path hasn't been selected");
return(null);
}
return(path);
}
/// <summary>
/// Accepts the component.
/// </summary>
/// <param name="view">The view where component will be accepted.</param>
/// <returns>CallEditInfo.</returns>
private CallEditInfo acceptComponent(ExecutionView view)
{
var toAccept = UserInteraction.DraggedInstance;
var componentInfo = Services.GetComponentInfo(toAccept.Info);
if (componentInfo == null)
{
view.Abort("Can accept only components");
return(null);
}
return(new CallEditInfo(This, "AddPart", toAccept));
}
/// <summary>
/// Handler for accept catalog edit.
/// </summary>
/// <param name="view">The view.</param>
/// <returns>CallEditInfo.</returns>
private CallEditInfo acceptCatalog(ExecutionView view)
{
var instance = UserInteraction.DraggedInstance;
var isCatalog = Services.IsAssignable(TypeDescriptor.Create <ComposablePartCatalog>(), instance.Info);
if (!isCatalog)
{
view.Abort("AggregateCatalog can only accept part catalogs");
return(null);
}
return(new CallEditInfo(This, "Catalogs.Add", instance));
}
/// <summary>
/// Accepts the part catalog in constructor.
/// </summary>
/// <param name="e">The edits provider used for accepting.</param>
/// <param name="view">The view where instance will be accepted.</param>
/// <returns>Variable with accepted catalog and correct scope.</returns>
private object acceptPartCatalog(EditsProvider e, ExecutionView view)
{
var instance = UserInteraction.DraggedInstance;
var isCatalog = Services.IsAssignable(TypeDescriptor.Create <ComposablePartCatalog>(), instance.Info);
if (!isCatalog)
{
//allow accepting only components
view.Abort("CompositionContainer can accept only single part catalog");
return(null);
}
return(e.GetVariableFor(instance, view));
}
/// <summary>
/// Dialog for getting pattern input.
/// </summary>
/// <param name="view">The view.</param>
/// <returns>System.Object.</returns>
private object _patternInput(ExecutionView view)
{
var oldPattern = Pattern.Get();
var inputPattern = Dialogs.ValueProvider.GetSearchPattern(oldPattern);
if (inputPattern == null || inputPattern == "")
{
view.Abort("No pattern has been selected");
return(null);
}
return(inputPattern);
}
/// <summary>
/// Accepts the component.
/// </summary>
/// <param name="thisObj">The this object.</param>
/// <param name="services">The services.</param>
/// <returns>CallEditInfo.</returns>
private CallEditInfo acceptComponent(Instance thisObj, ExecutionView services)
{
var instance = UserInteraction.DraggedInstance;
var componentInfo = Services.GetComponentInfo(instance.Info);
if (componentInfo == null)
{
//allow accepting only components
services.Abort("CompositionTester can only accept components");
return(null);
}
return(new CallEditInfo(thisObj, "Add", instance));
}
/// <summary>
/// Dialog for adding component type.
/// </summary>
/// <param name="callerAssembly">The caller assembly.</param>
/// <param name="v">View where component type will be added.</param>
/// <returns>System.Object.</returns>
private object addComponentTypeProvider(TypeAssembly callerAssembly, ExecutionView v)
{
var components = getComponents(callerAssembly);
var dialog = new ComponentType(components);
if (dialog.ShowDialog() == true)
{
return(dialog.SelectedComponent);
}
else
{
v.Abort("No component has been selected");
return(null);
}
}
/// <summary>
/// Add component into composition point.
/// </summary>
/// <param name="component">The component to add.</param>
/// <param name="v">View of composition point.</param>
/// <returns>Edit info for component adding.</returns>
private CallEditInfo addComponent(ComponentInfo component, ExecutionView v)
{
var call = new CallEditInfo(component.ComponentType, Naming.CtorName);
var name = TypeSystem.Dialogs.VariableName.GetName(component.ComponentType, _currentResult.EntryContext);
if (name == null)
{
v.Abort("User aborted component adding");
return(null);
}
call.ReturnName = name;
return(call);
}
/// <summary>
/// Accepts the instance in given view.
/// </summary>
/// <param name="view">The view where instance will be accepted.</param>
/// <returns>Accepting call.</returns>
private CallEditInfo acceptInstance(ExecutionView view)
{
var toAccept = UserInteraction.DraggedInstance;
if (Services.IsAssignable(CompositionBatchDefinition.Info, toAccept.Info))
{
return(new CallEditInfo(This, "Compose", toAccept));
}
var componentInfo = Services.GetComponentInfo(toAccept.Info);
if (componentInfo == null)
{
view.Abort("Can accept only components");
return(null);
}
return(new CallEditInfo(TypeDescriptor.Create(typeof(AttributedModelServices)), "ComposeParts", true, This, toAccept));
}
private object componentAccepter(ExecutionView view)
{
//instanci, kterou uživatel přesunul myší, získáme následovně
var toAccept = UserInteraction.DraggedInstance;
//zjistíme, zda se jedná o komponentu
var componentInfo = Services.GetComponentInfo(toAccept.Info);
//akceptovat chceme pouze komponenty
if (componentInfo == null)
{
//pokud se o komponentu nejedná, sdělíme uživateli
//proč nelze instanci akceptovat a editaci zrušíme
view.Abort("Can only accept components");
return(null);
}
//pokud akceptujeme komponentu,
//získáme proměnnou, ve které je dostupná
//a vrátíme ji jako hodnotu k akceptování
return(Edits.GetVariableFor(toAccept, view));;
}