// Start is called before the first frame update
void Start()
{
var container = new UFrameContainer();
container.RegisterInstance(container);
container.Register <IPlayer, Player>();
container.Resolve <IPlayer>().Run();
var player1 = container.Resolve <IPlayer>();
var player2 = container.Resolve <IPlayer>();
Debug.Log(player1.GetHashCode());
Debug.Log(player2.GetHashCode());
container.RegisterInstance <IPlayer>(new Player());
var player3 = container.Resolve <IPlayer>();
var player4 = container.Resolve <IPlayer>();
Debug.Log(player3.GetHashCode());
Debug.Log(player4.GetHashCode());
Debug.Log(container.Resolve <UFrameContainer>().GetHashCode());
Debug.Log(container.GetHashCode());
}
public override void Loaded(UFrameContainer container)
{
base.Loaded(container);
MVVM.HasSubNode <ServiceNode>();
MVVM.HasSubNode <SimpleClassNode>();
MVVM.HasSubNode <TypeReferenceNode>();
MVVM.Name = "MVVM Kernel Graph";
ComputedProperty.Name = "Computed Property";
Subsystem.HasSubNode <TypeReferenceNode>();
Element.HasSubNode <TypeReferenceNode>();
Subsystem.HasSubNode <EnumNode>();
Element.HasSubNode <EnumNode>();
Service.HasSubNode <EnumNode>();
Service.HasSubNode <SimpleClassNode>();
Service.HasSubNode <TypeReferenceNode>();
SceneType.Name = "Scene Type";
Subsystem.Name = "Sub System";
Service.Name = "Service";
ViewComponent.Name = "View Component";
StateMachine.Name = "State Machine";
BindingTypes = InvertGraphEditor.Container.Instances.Where(p => p.Key.Item1 == typeof(uFrameBindingType)).ToArray();
container.AddItemFlag <CommandsChildItem>("Publish", Color.green);
container.RegisterConnectable <PropertiesChildItem, ComputedPropertyNode>();// container.Connectable<PropertiesChildItem, ComputedPropertyNode>();
}
private void AddBindingMethods_UGUIExtenstions(UFrameContainer container)
{
container.AddBindingMethod(typeof(UGUIExtensions), "BindInputFieldToProperty", // Registration
_ => _ is PropertiesChildItem && _.RelatedTypeName == typeof(string).Name) // Validation
.SetDescription("Binds a string property to an uGUI input field. A field will be created on the view for specifying the uGUI field.")
.SetNameFormat("{0} To Input Field"); // Configuration
container.AddBindingMethod(typeof(UGUIExtensions), "BindButtonToCommand", _ => _ is CommandsChildItem)
.SetDescription("The ButtonToCommand binding will create a reference to a uGUI button on the view and automatically wire the click event to invoke the command.")
.SetNameFormat("{0} To Button");
container.AddBindingMethod(typeof(UGUIExtensions), "BindToggleToProperty",
_ => _ is PropertiesChildItem && _.RelatedTypeName == typeof(bool).Name)
.SetDescription("Bind toggle to property will bind a boolean property directly to a uGUI toggle box.")
.SetNameFormat("{0} To Toggle");
container.AddBindingMethod(typeof(UGUIExtensions), "BindTextToProperty",
_ => _ is PropertiesChildItem && _.RelatedTypeName == typeof(string).Name)
.SetDescription("Binds a string property to a uGUI text label.")
.SetNameFormat("{0} To Text");
container.AddBindingMethod(typeof(UGUIExtensions), "BindSliderToProperty",
_ => _ is PropertiesChildItem && _.RelatedTypeName == typeof(float).Name)
.SetDescription("Binds a slider to a float value.")
.SetNameFormat("{0} To Slider");
}
public override void Initialize(UFrameContainer container)
{
base.Initialize(container);
var path = DbRootPath;
var dbDirectories = Directory.GetDirectories(path, "*.db", SearchOption.AllDirectories);
foreach (var item in dbDirectories)
{
var db = new TypeDatabase(new JsonRepositoryFactory(item));
var config = GetConfig(db, Path.GetFileNameWithoutExtension(item));
config.FullPath = item;
container.RegisterInstance <IGraphConfiguration>(config, config.Identifier);
}
CurrentConfiguration = Configurations.ContainsKey(CurrentDatabaseIdentifier)
? Configurations[CurrentDatabaseIdentifier]
: Configurations.Values.FirstOrDefault();
if (CurrentConfiguration != null)
{
container.RegisterInstance <IGraphConfiguration>(CurrentConfiguration);
container.RegisterInstance <IRepository>(CurrentConfiguration.Database);
//var typeDatabase = container.Resolve<IRepository>();
CurrentConfiguration.Database.AddListener <IDataRecordInserted>(this);
CurrentConfiguration.Database.AddListener <IDataRecordRemoved>(this);
CurrentConfiguration.Database.AddListener <IDataRecordPropertyChanged>(this);
CurrentConfiguration.Database.AddListener <IDataRecordPropertyBeforeChange>(this);
}
else
{
InvertApplication.Log("A uFrameDatabase doesn't exist.");
}
}
public override void Initialize(UFrameContainer container)
{
EditorUtility.ClearProgressBar();
// TODO 2.0: Obviously fix undo
//Undo.undoRedoPerformed = delegate
//{
// var ps = container.Resolve<WorkspaceService>();
// ps.RefreshProjects();
// InvertGraphEditor.DesignerWindow.RefreshContent();
//};
container.RegisterInstance <IPlatformDrawer>(InvertGraphEditor.PlatformDrawer);
container.RegisterInstance <IStyleProvider>(new UnityStyleProvider());
#if DOCS
container.RegisterToolbarCommand <GenerateDocsCommand>();
container.RegisterToolbarCommand <DocsModeCommand>();
#endif
// container.RegisterInstance<IToolbarCommand>(new Test(), "Test");
//container.RegisterInstance<IAssetManager>(new UnityAssetManager());
// Command Drawers
container.RegisterInstance <ToolbarUI>(new UnityToolbar()
{
});
container.Register <ContextMenuUI, UnityContextMenu>();
container.RegisterInstance <IGraphEditorSettings>(new UFrameSettings());
// Where the generated code files are placed
container.Register <ICodePathStrategy, DefaultCodePathStrategy>("Default");
container.RegisterInstance <IWindowManager>(new UnityWindowManager());
}
public override void Initialize(UFrameContainer container)
{
RegisteredTemplateGeneratorsFactory.RegisterTemplate <SystemNode, SystemTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <SystemNode, SystemPartialTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <ComponentNode, ComponentTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <ComponentNode, ComponentEditableTemplate>();
// RegisteredTemplateGeneratorsFactory.RegisterTemplate<ComponentGroupNode,ComponentGroupTemplate>();
// RegisteredTemplateGeneratorsFactory.RegisterTemplate<ComponentGroupNode,ComponentGroupManagerTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <EventNode, EventTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <GroupNode, GroupTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <GroupNode, GroupItemTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <HandlerNode, HandlerTemplate>();
//RegisteredTemplateGeneratorsFactory.RegisterTemplate<HandlerNode, EditableHandlerTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <uFrameDatabaseConfig, DbLoaderTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <uFrameDatabaseConfig, EcsEditorExtensionTemplate>();
//RegisteredTemplateGeneratorsFactory.RegisterTemplate<PropertyChangedNode, PropertyHandlerTemplate>();
// RegisteredTemplateGeneratorsFactory.RegisterTemplate<EntityNode, EntityTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <CustomActionNode, CustomActionEditableTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <CustomActionNode, CustomActionDesignerTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <CustomActionNode, CustomActionSequenceTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <CodeActionNode, CodeActionEditableTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <CodeActionNode, CodeActionDesignerTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <SystemNode, LoaderTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <ModuleNode, ComponentExtensionsTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <DescriptorNode, DescriptorInterfaceTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <DescriptorNode, DescriptorAttributeTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <DescriptorNode, DescriptorGroupTemplate>();
}
public override void Initialize(UFrameContainer container)
{
Container = container;
}
public override void Loaded(UFrameContainer container)
{
base.Loaded(container);
//foreach (var item in Configurations.Values)
//{
//}
}
public override void Initialize(UFrameContainer container)
{
base.Initialize(container);
var typeDatabase = new TypeDatabase(new JsonRepositoryFactory(Path.Combine(Application.dataPath, "../uFrame")));
container.RegisterInstance <IRepository>(typeDatabase, "Settings");
container.RegisterInstance <IDesctiptorsService>(new DescriptorsService(typeDatabase));
}
public override void Loaded(UFrameContainer container)
{
base.Loaded(container);
if (CurrentWorkspace == null && InvertGraphEditor.Prefs != null)
{
CurrentWorkspace = Workspaces.FirstOrDefault(p => p.Identifier == InvertGraphEditor.Prefs.GetString("LastLoadedWorkspace", string.Empty));
}
Configurations = container.ResolveAll <WorkspaceConfiguration>().ToDictionary(p => p.WorkspaceType);
}
public override void Initialize(UFrameContainer container)
{
container.RegisterInstance <IDiagramNodeCommand>(new CreateSceneCommand(), "CreateScene");
container.RegisterInstance <IDiagramNodeCommand>(new AddManagerToSceneCommand(), "AddToScene");
container.RegisterInstance <IDiagramNodeCommand>(new AddManagerToSceneSelectionCommand(), "AddToSceneSelection");
container.RegisterInstance <IDiagramNodeCommand>(new AddViewToSceneCommand(), "AddViewToScene");
//container.RegisterInstance<IDiagramNodeCommand>(new AddViewToSceneSelectionCommand(), "AddViewToSceneSelection");
container.RegisterInstance <IToolbarCommand>(new ScaffoldOrUpdateKernelCommand(), "ScaffoldOrUpdateKernel");
}
public override void Initialize(UFrameContainer container)
{
container.RegisterInstance<IDiagramNodeCommand>(new CreateSceneCommand(), "CreateScene");
container.RegisterInstance<IDiagramNodeCommand>(new AddManagerToSceneCommand(), "AddToScene");
container.RegisterInstance<IDiagramNodeCommand>(new AddManagerToSceneSelectionCommand(), "AddToSceneSelection");
container.RegisterInstance<IDiagramNodeCommand>(new AddViewToSceneCommand(), "AddViewToScene");
//container.RegisterInstance<IDiagramNodeCommand>(new AddViewToSceneSelectionCommand(), "AddViewToSceneSelection");
container.RegisterInstance<IToolbarCommand>(new ScaffoldOrUpdateKernelCommand(),"ScaffoldOrUpdateKernel");
}
public override void Initialize(UFrameContainer container)
{
container.RegisterWindow <WelcomeWindowViewModel>("WelcomeWindowViewModel")
.HasPanel <WelcomeWindowSplashScreenDrawer, WelcomeWindowViewModel>(new AreaLayout(0, 0, 16, 14))
.HasPanel <WelcomeWindowToolbarDrawer, WelcomeWindowViewModel>(new AreaLayout(0, 14, 16, 2))
.WithDefaultInstance(CreateWelcomeWindow);
ListenFor <IWelcomeWindowToolbarItemsQuery>();
}
private Dictionary <string, MethodInfo> _commandInvokeMethodInfos = new Dictionary <string, MethodInfo>();//uFrame_kbe
public void OnDestroy()
{
_container = null;
IsKernelLoaded = false;
Services.Clear();
SystemLoaders.Clear();
EventAggregator = null;
Instance = null;
}
public void ResetKernel()
{
DestroyImmediate(Instance.gameObject);
_container = null;
IsKernelLoaded = false;
Services.Clear();
SystemLoaders.Clear();
EventAggregator = null;
Instance = null;
}
// Start is called before the first frame update
void Start()
{
var container = new UFrameContainer();
container.RegisterInstance(new A());
container.Inject(this);
AObj.LogSelf();
}
public override void Initialize(UFrameContainer container)
{
base.Initialize(container);
uFrameECS.EcsComponentType = typeof(EcsComponent);
uFrameECS.EntityComponentType = typeof(Entity);
DebugSystem = container.Resolve<DebugSystem>();
if (Disposer != null)
{
Disposer.Dispose();
}
Disposer = DebugService.DebugInfo.Subscribe(SignalInfo);
}
public override void Initialize(UFrameContainer container)
{
base.Initialize(container);
uFrameECS.EcsComponentType = typeof(EcsComponent);
uFrameECS.EntityComponentType = typeof(Entity);
DebugSystem = container.Resolve <DebugSystem>();
if (Disposer != null)
{
Disposer.Dispose();
}
Disposer = DebugService.DebugInfo.Subscribe(SignalInfo);
}
public override void Initialize(UFrameContainer container)
{
base.Initialize(container);
container.AddNode <NoteNode, NoteNodeViewModel, NoteNodeDrawer>("Note");
container.AddNode <ImageNode, ImageNodeViewModel, ImageNodeDrawer>("Image");
foreach (var node in FilterExtensions.AllowedFilterNodes)
{
node.Value.Add(typeof(NoteNode));
node.Value.Add(typeof(ImageNode));
}
}
public override void Initialize(UFrameContainer container)
{
base.Initialize(container);
container.AddNode<NoteNode, NoteNodeViewModel, NoteNodeDrawer>("Note");
container.AddNode<ImageNode, ImageNodeViewModel, ImageNodeDrawer>("Image");
foreach (var node in FilterExtensions.AllowedFilterNodes)
{
node.Value.Add(typeof(NoteNode));
node.Value.Add(typeof(ImageNode));
}
}
public override void Initialize(UFrameContainer container)
{
base.Initialize(container);
container.RegisterWindow<QuickAccessWindowViewModel>("QuickAccessWindowFactory")
.HasPanel<QuickAccessWindowSearchPanel, QuickAccessWindowViewModel>()
.WithDefaultInstance(_ => new QuickAccessWindowViewModel(new QuickAccessContext()
{
ContextType = typeof(IInsertQuickAccessContext)
}));
container.RegisterWindow<QuickAccessWindowViewModel>("ConnectionWindowFactory")
.HasPanel<QuickAccessWindowSearchPanel, QuickAccessWindowViewModel>()
.WithDefaultInstance(_ => new QuickAccessWindowViewModel(new QuickAccessContext()
{
ContextType = typeof(IConnectionQuickAccessContext)
}));
}
public override void Initialize(UFrameContainer container)
{
// Grab a reference to the main framework graphs plugin
var framework = container.Resolve <uFrameMVVM>();
//Framework.ElementsGraphRoot.AddCodeTemplate<BackupData>();
// Register the code template
RegisteredTemplateGeneratorsFactory.RegisterTemplate <PropertiesChildItem, SetPropertyActionsTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <PropertiesChildItem, GetPropertyActionsTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <PropertiesChildItem, GetCurrentStateActionsTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <PropertiesChildItem, CheckPropertyActionsTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <PropertiesChildItem, CheckStateActionsTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <CommandsChildItem, ExecuteCommandsActionsTemplate>();
framework.ComputedProperty.AddCodeTemplate <ComputedPropertyActionsTemplate>();
framework.ComputedProperty.AddCodeTemplate <CheckComputedPropertyActionsTemplate>();
}
public override void Initialize(UFrameContainer container)
{
base.Initialize(container);
container.RegisterWindow <QuickAccessWindowViewModel>("QuickAccessWindowFactory")
.HasPanel <QuickAccessWindowSearchPanel, QuickAccessWindowViewModel>()
.WithDefaultInstance(_ => new QuickAccessWindowViewModel(new QuickAccessContext()
{
ContextType = typeof(IInsertQuickAccessContext)
}));
container.RegisterWindow <QuickAccessWindowViewModel>("ConnectionWindowFactory")
.HasPanel <QuickAccessWindowSearchPanel, QuickAccessWindowViewModel>()
.WithDefaultInstance(_ => new QuickAccessWindowViewModel(new QuickAccessContext()
{
ContextType = typeof(IConnectionQuickAccessContext)
}));
}
public override void Initialize(UFrameContainer container)
{
// Grab a reference to the main framework graphs plugin
var framework = container.Resolve<uFrameMVVM>();
//Framework.ElementsGraphRoot.AddCodeTemplate<BackupData>();
// Register the code template
RegisteredTemplateGeneratorsFactory.RegisterTemplate<PropertiesChildItem, SetPropertyActionsTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate<PropertiesChildItem, GetPropertyActionsTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate<PropertiesChildItem, GetCurrentStateActionsTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate<PropertiesChildItem, CheckPropertyActionsTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate<PropertiesChildItem, CheckStateActionsTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate<CommandsChildItem, ExecuteCommandsActionsTemplate>();
framework.ComputedProperty.AddCodeTemplate<ComputedPropertyActionsTemplate>();
framework.ComputedProperty.AddCodeTemplate<CheckComputedPropertyActionsTemplate>();
}
public override void Initialize(UFrameContainer container)
{
base.Initialize(container);
SubSystem.Name = "SubSystem";
SceneType.Name = "Scene Type";
container.AddWorkspaceConfig <MvvmWorkspace>("MVVM")
.WithGraph <MVVMGraph>("MVVM", "Create MVVM")
.WithGraph <SubSystemGraph>("SubSystem", "Create SubSystem");
MVVM.HasSubNode <TypeReferenceNode>();
SubSystem.HasSubNode <TypeReferenceNode>();
SubSystem.HasSubNode <EnumNode>();
Service.HasSubNode <TypeReferenceNode>();
Service.HasSubNode <EnumNode>();
Element.HasSubNode <TypeReferenceNode>();
Element.HasSubNode <EnumNode>();
uFrameMVVM.BindingTypes = InvertGraphEditor.Container.Instances.Where(p => p.Key.Item1 == typeof(uFrameBindingType)).ToArray();
}
public override void Loaded(UFrameContainer container)
{
base.Loaded(container);
//#if DEMO
// Signal<INotify>(_=>_.NotifyWithActions("You're using the demo version of uFrame ECS.",NotificationIcon.Warning,new NotifyActionItem()
// {
// Title = "Buy Now",
// Action = ()=>
// {
// InvertGraphEditor.Platform.OpenLink("https://invertgamestudios.com/ecs/purchase");
// }
// }));
// return;
//#endif
}
public override void Loaded(UFrameContainer container)
{
base.Loaded(container);
FlagByName.Clear();
foreach (var item in InvertApplication.GetDerivedTypes <IDiagramNodeItem>())
{
var flagProperties = item.GetProperties(BindingFlags.Default | BindingFlags.Public | BindingFlags.Instance).Where(p => p.IsDefined(typeof(NodeFlag), true)).ToArray();
foreach (var property in flagProperties)
{
var attr = property.GetCustomAttributes(typeof(NodeFlag), true).OfType <NodeFlag>().FirstOrDefault();
FlagByName.Add(attr.Name, new FlagConfig(item, attr.Name, attr.Color)
{
PropertyInfo = property
});
}
}
foreach (var item in container.ResolveAll <FlagConfig>())
{
FlagByName.Add(item.FlagName, item);
}
}
public override void Loaded(UFrameContainer container)
{
base.Loaded(container);
if (ExampleProjectNeedInstall)
{
ExampleProjectNeedInstall = false;
var scenes = EditorBuildSettings.scenes;
EditorBuildSettings.scenes =
scenes.Concat(GetExampleProjectScenes().Select(s => new EditorBuildSettingsScene(s, true)))
.Distinct()
.ToArray();
EditorApplication.OpenScene(ExamplePackageScenesPath + "IntroScene.unity");
if (ElementsDesigner.Instance)
{
ElementsDesigner.Instance.Close();
}
EditorApplication.isPlaying = true;
}
}
public override void Initialize(UFrameContainer container)
{
EditorUtility.ClearProgressBar();
// TODO 2.0: Obviously fix undo
//Undo.undoRedoPerformed = delegate
//{
// var ps = container.Resolve<WorkspaceService>();
// ps.RefreshProjects();
// InvertGraphEditor.DesignerWindow.RefreshContent();
//};
container.RegisterInstance<IPlatformDrawer>(InvertGraphEditor.PlatformDrawer);
container.RegisterInstance<IStyleProvider>(new UnityStyleProvider());
#if DOCS
container.RegisterToolbarCommand<GenerateDocsCommand>();
container.RegisterToolbarCommand<DocsModeCommand>();
#endif
// container.RegisterInstance<IToolbarCommand>(new Test(), "Test");
//container.RegisterInstance<IAssetManager>(new UnityAssetManager());
// Command Drawers
container.RegisterInstance<ToolbarUI>(new UnityToolbar()
{
});
container.Register<ContextMenuUI, UnityContextMenu>();
container.RegisterInstance<IGraphEditorSettings>(new UFrameSettings());
// Where the generated code files are placed
container.Register<ICodePathStrategy, DefaultCodePathStrategy>("Default");
container.RegisterInstance<IWindowManager>(new UnityWindowManager());
}
public override void Initialize(UFrameContainer container)
{
base.Initialize(container);
RegisteredTemplateGeneratorsFactory.RegisterTemplate <SubSystemNode, SystemLoaderTemplate>();
//RegisteredTemplateGeneratorsFactory.RegisterTemplate<SubSystemNode, SystemLoaderPartialTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <SceneTypeNode, SceneTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <SceneTypeNode, SceneLoaderTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <SceneTypeNode, SceneSettingsTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <ServiceNode, ServiceTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <SimpleClassNode, SimpleClassTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <ElementNode, ViewModelTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <ElementNode, ViewModelConstructorTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <ElementNode, ControllerTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <CommandsChildItem, ViewModelCommandClassTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <CommandNode, CommandTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <ViewNode, ViewTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <StateMachineNode, StateMachineTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <StateNode, StateTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <ViewComponentNode, ViewComponentTemplate>();
// Register bindable methods
AddBindingMethods(container);
AddBindingMethods_UGUIExtenstions(container);
}
public override void Loaded(UFrameContainer container)
{
InvertGraphEditor.DesignerPluginLoaded();
}
public override void Loaded(UFrameContainer container)
{
base.Loaded(container);
}
public override void Initialize(UFrameContainer container)
{
base.Initialize(container);
}
public override void Loaded(UFrameContainer container)
{
base.Loaded(container);
InvertGraphEditor.DesignerWindow = this;
}
public override void Loaded(UFrameContainer container)
{
base.Loaded(container);
UpdateBreakpoints();
}
public override void Initialize(UFrameContainer container)
{
ListenFor<ICompileEvents>();
}
private static void InitializeTypesContainer(UFrameContainer container)
{
}
public override void Initialize(UFrameContainer container)
{
base.Initialize(container);
container.RegisterDrawer<ConsoleViewModel,ConsoleDrawer>();
}
public override void Initialize(UFrameContainer container)
{
// Grab a reference to the main framework graphs plugin
Framework = container.Resolve<uFrameMVVM>();
//Framework.ElementsGraphRoot.AddCodeTemplate<BackupData>();
// Register the code template
Framework.Service.AddCodeTemplate<ServiceTemplate>();
Framework.SimpleClass.AddCodeTemplate<SimpleClassTemplate>();
Framework.Element.AddCodeTemplate<ControllerTemplate>();
Framework.Element.AddCodeTemplate<ViewModelTemplate>();
Framework.Element.AddCodeTemplate<ViewModelConstructorTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate<CommandsChildItem, ViewModelCommandClassTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate<CommandNode, CommandClassTemplate>();
//Framework.SceneManager.AddCodeTemplate<SceneManagerTemplate>();
//Framework.SceneManager.AddCodeTemplate<SceneManagerSettingsTemplate>();
Framework.SceneType.AddCodeTemplate<SceneTemplate>();
Framework.SceneType.AddCodeTemplate<SceneSettingsTemplate>();
Framework.Subsystem.AddCodeTemplate<SystemLoaderTemplate>();
Framework.SceneType.AddCodeTemplate<SceneLoaderTemplate>();
Framework.View.AddCodeTemplate<ViewTemplate>();
Framework.ViewComponent.AddCodeTemplate<ViewComponentTemplate>();
Framework.State.AddCodeTemplate<StateTemplate>();
Framework.StateMachine.AddCodeTemplate<StateMachineTemplate>();
// Register our bindable methods
container.AddBindingMethod(typeof (ViewBindings), "BindProperty",
_ => _ is PropertiesChildItem || _ is ComputedPropertyNode)
.SetNameFormat("{0} Changed")
.ImplementWith(args =>
{
var sourceItem = args.SourceItem as ITypedItem;
if (sourceItem.RelatedNode() is StateMachineNode)
{
args.Method.Parameters.Clear();
args.Method.Parameters.Add(new CodeParameterDeclarationExpression(typeof (State), "State"));
}
})
;
container.AddBindingMethod(typeof (ViewBindings), "BindStateProperty",
_ => _ is PropertiesChildItem && _.RelatedNode() is StateMachineNode)
.SetNameFormat("{0} State Changed")
.SetDescription(
"Binding to a state property creates methods for each state, and in the designer code will property call the each state's method when it changes.")
.ImplementWith(args =>
{
args.Method.Parameters[0].Type = typeof (State).ToCodeReference();
var sourceItem = args.SourceItem as ITypedItem;
var stateMachine = sourceItem.RelatedNode() as StateMachineNode;
if (args.IsDesignerFile)
{
foreach (var state in stateMachine.States)
{
var method = new CodeMemberMethod()
{
Name = "On" + state.Name,
Attributes = MemberAttributes.Public
};
var conditionStatement =
new CodeConditionStatement(
new CodeSnippetExpression(string.Format("arg1 is {0}", state.Name)));
conditionStatement.TrueStatements.Add(
new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), method.Name));
args.Method.Statements.Add(conditionStatement);
args.Decleration.Members.Add(method);
}
}
args.Method.Parameters[0].Type = "Invert.StateMachine.State".ToCodeReference();
});
container.AddBindingMethod(typeof (ViewBindings), "BindCollection", _ => _ is CollectionsChildItem)
.SetNameFormat("{0} Collection Changed")
.SetDescription(
"Collection bindings bind to a collection giving you two methods, {CollectionName}Added, and {CollectionName}Removed, override these methods to execute something when the collection is modified.")
;
container.AddBindingMethod(typeof (ViewBindings), "BindToViewCollection", _ => _ is CollectionsChildItem)
.SetNameFormat("{0} View Collection Changed")
.SetDescription(
"The view collection changed binding automatically creates views for each element's viewmodel when created.")
.ImplementWith(args =>
{
if (args.Method.Name.EndsWith("CreateView"))
{
args.Method.Parameters[0].Name = "viewModel";
args.Method._("return InstantiateView(viewModel)");
}
else
{
args.Method.Parameters[0].Name = "view";
}
})
;
container.AddBindingMethod(typeof (ViewBindings), "BindCommandExecuted", _ => _ is CommandsChildItem)
.SetNameFormat("{0} Executed")
.SetDescription(
"The executed binding is for listening to when a command is invoked on a view. It will provide you with a method in the format {CommandName}Executed({CommandClass} data)")
.ImplementWith(args =>
{
args.Method.Parameters[0].Name = "command";
var commandItem = args.SourceItem as CommandsChildItem;
args.Method.Parameters[0].Type = commandItem.ClassName.ToCodeReference();
})
;
container.AddBindingMethod(typeof (UGUIExtensions), "BindInputFieldToProperty", // Registration
_ => _ is PropertiesChildItem && _.RelatedTypeName == typeof (string).Name) // Validation
.SetDescription(
"Binds a string property to an uGUI input field. A field will be created on the view for specifying the uGUI field.")
.SetNameFormat("{0} To Input Field") // Configuration
;
container.AddBindingMethod(typeof (UGUIExtensions), "BindButtonToCommand", _ => _ is CommandsChildItem)
.SetDescription(
"The ButtonToCommand binding will create a reference to a uGUI button on the view and automatically wire the click event to invoke the command.")
.SetNameFormat("{0} To Button");
container.AddBindingMethod(typeof (UGUIExtensions), "BindToggleToProperty",
_ => _ is PropertiesChildItem && _.RelatedTypeName == typeof (bool).Name)
.SetDescription("Bind toggle to property will bind a boolean property directly to a uGUI toggle box.")
.SetNameFormat("{0} To Toggle");
container.AddBindingMethod(typeof (UGUIExtensions), "BindTextToProperty",
_ => _ is PropertiesChildItem && _.RelatedTypeName == typeof (string).Name)
.SetDescription("Binds a string property to a uGUI text label.")
.SetNameFormat("{0} To Text");
container.AddBindingMethod(typeof (UGUIExtensions), "BindSliderToProperty",
_ => _ is PropertiesChildItem && _.RelatedTypeName == typeof (float).Name)
.SetDescription("Binds a slider to a float value.")
.SetNameFormat("{0} To Slider");
}
public override void Initialize(UFrameContainer container)
{
base.Initialize(container);
container.RegisterInstance<IExplorerProvider>(new GraphExplorerProvider(),"Graphs");
}
public override void Loaded(UFrameContainer container)
{
base.Loaded(container);
ExplorerViews = container.ResolveAll<IExplorerProvider>().ToArray();
ExplorerViewsStrings = container.ResolveAll<IExplorerProvider>().Select(p=>p.Name).ToArray();
}
public override void Initialize(UFrameContainer container)
{
if (!Ctx.IsDesignerFile)
{
return;
}
Ctx.CurrentMethodAttribute.CallBase = false;
var method = Ctx.CurrentMethod;
//foreach (var item in Ctx.Data.Graph.NodeItems.OfType<ShellChildItemTypeNode>())
//{
// if (!item["Typed"]) continue;
// method._(
// "container.RegisterInstance<IEditorCommand>(Get{0}SelectionCommand(), typeof({1}).Name + \"TypeSelection\");", item.Name, item.ClassName);
//}
foreach (var itemType in Ctx.Data.Graph.NodeItems.OfType <IShellNode>().Where(p => p.IsValid))
{
if (itemType is ShellNodeTypeNode)
{
continue;
}
if (itemType is ShellSectionNode)
{
continue;
}
if (itemType is ShellGraphTypeNode)
{
continue;
}
if (itemType["Typed"])
{
method.Statements.Add(
new CodeSnippetExpression(string.Format("container.AddTypeItem<{0},{1}ViewModel,{1}Drawer>()", itemType.ClassName, itemType.Name)));
}
else
{
//if (itemType.Flags.ContainsKey("Custom") && itemType["Custom"])
//{
// method.Statements.Add(
// new CodeSnippetExpression(string.Format("container.AddItem<{0}, {1}ViewModel, {1}Drawer>()", itemType.ClassName, itemType.Name)));
//}
//else
//{
method.Statements.Add(
new CodeSnippetExpression(string.Format("container.AddItem<{0}>()", itemType.ClassName)));
//}
}
}
var graphTypes = Ctx.Data.Graph.NodeItems.OfType <ShellGraphTypeNode>().Where(p => p.IsValid).ToArray();
foreach (var nodeType in Ctx.Data.Graph.NodeItems.OfType <ShellNodeTypeNode>().Where(p => p.IsValid))
{
InitializeNodeType(method, nodeType, graphTypes.FirstOrDefault(p => p.RootNode == nodeType));
}
foreach (var nodeType in Ctx.Data.Graph.NodeItems.OfType <IShellConnectable>().Where(p => p.IsValid))
{
foreach (var item in nodeType.ConnectableTo)
{
method._("container.Connectable<{0},{1}>()", nodeType.ClassName, item.SourceItem.ClassName);
}
}
foreach (var nodeType in Ctx.Data.Graph.NodeItems.OfType <IReferenceNode>().Where(p => p.IsValid))
{
if (nodeType["Output"])
{
method._("container.Connectable<{0},{1}>()", nodeType.ClassName, nodeType.ReferenceClassName);
}
else
{
method._("container.Connectable<{0},{1}>()", nodeType.ReferenceClassName, nodeType.ClassName);
}
}
}
public override void Initialize(UFrameContainer container)
{
//
//#if UNITY_EDITOR
// foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
// {
// InvertApplication.CachedAssemblies.Add(assembly);
// }
//#endif
var typeContainer = InvertGraphEditor.TypesContainer;
// Drawers
container.Register<DiagramViewModel,DiagramViewModel>();
container.RegisterDrawer<PropertyFieldViewModel, PropertyFieldDrawer>();
container.Register<SectionHeaderDrawer, SectionHeaderDrawer>();
container.RegisterItemDrawer<GenericItemHeaderViewModel, GenericChildItemHeaderDrawer>();
container.RegisterDrawer<InspectorViewModel, InspectorDrawer>();
container.RegisterDrawer<SectionHeaderViewModel, SectionHeaderDrawer>();
container.RegisterDrawer<ConnectorViewModel, ConnectorDrawer>();
container.RegisterDrawer<ConnectionViewModel, ConnectionDrawer>();
container.RegisterDrawer<InputOutputViewModel, SlotDrawer>();
container.RegisterDrawer<DiagramViewModel, DiagramDrawer>();
//typeContainer.AddItem<GenericSlot,InputOutputViewModel,SlotDrawer>();
//typeContainer.AddItem<BaseClassReference, InputOutputViewModel, SlotDrawer>();
container.RegisterInstance<IConnectionStrategy>(new InputOutputStrategy(),"InputOutputStrategy");
//container.RegisterConnectable<GenericTypedChildItem, IClassTypeNode>();
container.RegisterConnectable<GenericInheritableNode, GenericInheritableNode>();
container.RegisterInstance<IConnectionStrategy>(new TypedItemConnectionStrategy(), "TypedConnectionStrategy");
//container.RegisterInstance<IConnectionStrategy>(new RegisteredConnectionStrategy(),"RegisteredConnectablesStrategy");
container.AddNode<EnumNode>("Enum")
.AddCodeTemplate<EnumNode, EnumNodeGenerator>();
container.AddItem<EnumChildItem>();
typeContainer.RegisterInstance(new GraphTypeInfo() { Type = typeof(int), Group = "", Label = "int", IsPrimitive = true }, "int");
typeContainer.RegisterInstance(new GraphTypeInfo() { Type = typeof(string), Group = "", Label = "string", IsPrimitive = true }, "string");
typeContainer.RegisterInstance(new GraphTypeInfo() { Type = typeof(decimal), Group = "", Label = "decimal", IsPrimitive = true }, "decimal");
typeContainer.RegisterInstance(new GraphTypeInfo() { Type = typeof(float), Group = "", Label = "float", IsPrimitive = true }, "float");
typeContainer.RegisterInstance(new GraphTypeInfo() { Type = typeof(bool), Group = "", Label = "bool", IsPrimitive = true }, "bool");
typeContainer.RegisterInstance(new GraphTypeInfo() { Type = typeof(char), Group = "", Label = "char", IsPrimitive = true }, "char");
typeContainer.RegisterInstance(new GraphTypeInfo() { Type = typeof(DateTime), Group = "", Label = "date", IsPrimitive = true }, "date");
typeContainer.RegisterInstance(new GraphTypeInfo() { Type = typeof(Vector2), Group = "", Label = "Vector2", IsPrimitive = true }, "Vector2");
typeContainer.RegisterInstance(new GraphTypeInfo() { Type = typeof(Vector3), Group = "", Label = "Vector3", IsPrimitive = true }, "Vector3");
container.Register<DesignerGeneratorFactory, RegisteredTemplateGeneratorsFactory>("TemplateGenerators");
#if UNITY_EDITOR
typeContainer.RegisterInstance(new GraphTypeInfo() { Type = typeof(Quaternion), Group = "", Label = "Quaternion", IsPrimitive = true }, "Quaternion");
//container.Register<DesignerGeneratorFactory, Invert.uFrame.CodeGen.ClassNodeGenerators.SimpleClassNodeCodeFactory>("ClassNodeData");
#endif
// Register the container itself
container.RegisterInstance<IUFrameContainer>(container);
container.RegisterInstance<UFrameContainer>(container);
container.AddNode<TypeReferenceNode, TypeReferenceNodeViewModel, TypeReferenceNodeDrawer>("Type Reference");
container.AddNode<NoteNode, NoteNodeViewModel, NoteNodeDrawer>("Note");
// TODO 2.0 Key-bindings
// container.RegisterKeyBinding(new RenameCommand(), "Rename", KeyCode.F2);
// container.RegisterKeyBinding(new SimpleEditorCommand<DiagramViewModel>((p) =>
// {
// p.DeselectAll();
// }), "End All Editing", KeyCode.Return);
// container.RegisterKeyBinding(new DeleteItemCommand(), "Delete Item", KeyCode.X, true);
// container.RegisterKeyBinding(new DeleteCommand(), "Delete", KeyCode.Delete);
//#if UNITY_EDITOR
// container.RegisterKeyBinding(new MoveUpCommand(), "Move Up", KeyCode.UpArrow);
// container.RegisterKeyBinding(new MoveDownCommand(), "Move Down", KeyCode.DownArrow);
//#endif
// container.RegisterKeyBinding(new SimpleEditorCommand<DiagramViewModel>((p) =>
// {
// InvertGraphEditor.Settings.ShowHelp = !InvertGraphEditor.Settings.ShowHelp;
// }), "Show/Hide This Help", KeyCode.F1);
//#if DEBUG
// container.RegisterKeyBinding(new SimpleEditorCommand<DiagramViewModel>((p) =>
// {
// InvertGraphEditor.Settings.ShowGraphDebug = !InvertGraphEditor.Settings.ShowGraphDebug;
// }), "Show/Hide Debug", KeyCode.F3);
//#endif
// container.RegisterKeyBinding(new SimpleEditorCommand<DiagramViewModel>((p) =>
// {
// var saveCommand = InvertApplication.Container.Resolve<IToolbarCommand>("Save");
// InvertGraphEditor.ExecuteCommand(saveCommand);
// }), "Save & Compile", KeyCode.S, true, true);
}
public override void Initialize(UFrameContainer container)
{
Percentage = 0f;
}
public override void Loaded(UFrameContainer container)
{
base.Loaded(container);
Repository = container.Resolve<IRepository>();
}
public override void Loaded(UFrameContainer container)
{
base.Loaded(container);
EditorApplication.update -= SaveSnapshotIfNeeded;
EditorApplication.update += SaveSnapshotIfNeeded;
}
public override void Loaded(UFrameContainer container)
{
}
public override void Initialize(UFrameContainer container)
{
//RegisteredTemplateGeneratorsFactory.RegisterTemplate<ComponentNode, AddComponentTemplate>();
}
public override void Initialize(UFrameContainer container)
{
#if DEBUG && UNITY_EDITOR
//container.RegisterInstance<IToolbarCommand>(new PrintPlugins(), "Json");
#endif
//container.RegisterInstance<IDiagramNodeCommand>(new SelectColorCommand(), "SelectColor");
var pluginConfig = container
.AddItem<ShellNodeSectionsSlot>()
.AddItem<ShellNodeInputsSlot>()
.AddItem<ShellNodeOutputsSlot>()
.AddItem<TemplatePropertyReference>()
.AddItem<TemplateMethodReference>()
.AddItem<TemplateFieldReference>()
.AddItem<TemplateEventReference>()
.AddItem<ShellAcceptableReferenceType>()
.AddItem<ShellConnectableReferenceType>()
.AddTypeItem<ShellPropertySelectorItem>()
.AddGraph<PluginGraphData,ShellPluginNode>("Shell Plugin")
.Color(NodeColor.Green)
.HasSubNode<IShellNode>()
.HasSubNode<TypeReferenceNode>()
.HasSubNode<ShellNodeConfig>()
.HasSubNode<ScreenshotNode>()
#if UNITY_EDITOR
// .AddCodeTemplate<DocumentationTemplate>()
#endif
;
// container.AddNode<ScreenshotNode, ScreenshotNodeViewModel, ScreenshotNodeDrawer>("Screenshot");
container.AddWorkspaceConfig<ArchitectWorkspace>("Architect","Create a uFrame Architect workspace for creating plugin graphs.")
.WithGraph<PluginGraphData>("Plugin", "Creates a new plugin graph for creating node configurations.");
var shellConfigurationNode =
container.AddNode<ShellNodeConfig, ShellNodeConfigViewModel, ShellNodeConfigDrawer>("Node Config")
.HasSubNode<ShellNodeConfig>()
.HasSubNode<ScreenshotNode>()
.HasSubNode<ShellTemplateConfigNode>()
;
// shellConfigurationNode.AddFlag("Graph Type");
container.AddNode<ShellTemplateConfigNode>("Code Template")
.Color(NodeColor.Purple);
RegisteredTemplateGeneratorsFactory.RegisterTemplate<ShellNodeConfig, ShellNodeConfigTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate<ShellNodeConfigSection, ShellNodeConfigReferenceSectionTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate<ShellNodeConfigSection, ShellNodeConfigChildItemTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate<ShellNodeConfig, ShellNodeAsGraphTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate<ShellPluginNode, ShellConfigPluginTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate<ShellNodeConfig, ShellNodeConfigViewModelTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate<ShellNodeConfig, ShellNodeConfigDrawerTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate<ShellTemplateConfigNode, ShellNodeConfigTemplateTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate<IShellSlotType, ShellSlotItemTemplate>();
#if UNITY_EDITOR
if (GenerateDocumentation)
{
RegisteredTemplateGeneratorsFactory.RegisterTemplate<ShellPluginNode, DocumentationTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate<IDocumentable, DocumentationPageTemplate>();
}
#endif
container.Connectable<ShellNodeConfigSection, ShellNodeConfig>();
container.Connectable<ShellNodeConfigSection, ShellNodeConfigSection>();
container.Connectable<IShellNodeConfigItem, IShellNodeConfigItem>();
container.Connectable<ShellNodeConfigOutput, ShellNodeConfigInput>();
container.Connectable<ShellNodeConfigOutput, ShellNodeConfig>();
container.Connectable<ShellNodeConfigOutput, ShellNodeConfigSection>();
container.Connectable<ShellNodeConfig, ShellNodeConfigInput>();
container.Connectable<ShellNodeConfig, ShellNodeConfigSection>();
container.Connectable<IShellNodeConfigItem, ShellTemplateConfigNode>();
container.Connectable<ShellNodeConfigSection, ShellNodeConfigInput>();
container.Connectable<ShellNodeConfigSection, ShellNodeConfigSection>();
}
public override void Initialize(UFrameContainer container)
{
#if DEBUG && UNITY_EDITOR
//container.RegisterInstance<IToolbarCommand>(new PrintPlugins(), "Json");
#endif
//container.RegisterInstance<IDiagramNodeCommand>(new SelectColorCommand(), "SelectColor");
var pluginConfig = container
.AddItem <ShellNodeSectionsSlot>()
.AddItem <ShellNodeInputsSlot>()
.AddItem <ShellNodeOutputsSlot>()
.AddItem <TemplatePropertyReference>()
.AddItem <TemplateMethodReference>()
.AddItem <TemplateFieldReference>()
.AddItem <TemplateEventReference>()
.AddItem <ShellAcceptableReferenceType>()
.AddItem <ShellConnectableReferenceType>()
.AddTypeItem <ShellPropertySelectorItem>()
.AddGraph <PluginGraphData, ShellPluginNode>("Shell Plugin")
.Color(NodeColor.Green)
.HasSubNode <IShellNode>()
.HasSubNode <TypeReferenceNode>()
.HasSubNode <ShellNodeConfig>()
.HasSubNode <ScreenshotNode>()
#if UNITY_EDITOR
// .AddCodeTemplate<DocumentationTemplate>()
#endif
;
// container.AddNode<ScreenshotNode, ScreenshotNodeViewModel, ScreenshotNodeDrawer>("Screenshot");
container.AddWorkspaceConfig <ArchitectWorkspace>("Architect", "Create a uFrame Architect workspace for creating plugin graphs.")
.WithGraph <PluginGraphData>("Plugin", "Creates a new plugin graph for creating node configurations.");
var shellConfigurationNode =
container.AddNode <ShellNodeConfig, ShellNodeConfigViewModel, ShellNodeConfigDrawer>("Node Config")
.HasSubNode <ShellNodeConfig>()
.HasSubNode <ScreenshotNode>()
.HasSubNode <ShellTemplateConfigNode>()
;
// shellConfigurationNode.AddFlag("Graph Type");
container.AddNode <ShellTemplateConfigNode>("Code Template")
.Color(NodeColor.Purple);
RegisteredTemplateGeneratorsFactory.RegisterTemplate <ShellNodeConfig, ShellNodeConfigTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <ShellNodeConfigSection, ShellNodeConfigReferenceSectionTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <ShellNodeConfigSection, ShellNodeConfigChildItemTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <ShellNodeConfig, ShellNodeAsGraphTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <ShellPluginNode, ShellConfigPluginTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <ShellNodeConfig, ShellNodeConfigViewModelTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <ShellNodeConfig, ShellNodeConfigDrawerTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <ShellTemplateConfigNode, ShellNodeConfigTemplateTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <IShellSlotType, ShellSlotItemTemplate>();
#if UNITY_EDITOR
if (GenerateDocumentation)
{
RegisteredTemplateGeneratorsFactory.RegisterTemplate <ShellPluginNode, DocumentationTemplate>();
RegisteredTemplateGeneratorsFactory.RegisterTemplate <IDocumentable, DocumentationPageTemplate>();
}
#endif
container.Connectable <ShellNodeConfigSection, ShellNodeConfig>();
container.Connectable <ShellNodeConfigSection, ShellNodeConfigSection>();
container.Connectable <IShellNodeConfigItem, IShellNodeConfigItem>();
container.Connectable <ShellNodeConfigOutput, ShellNodeConfigInput>();
container.Connectable <ShellNodeConfigOutput, ShellNodeConfig>();
container.Connectable <ShellNodeConfigOutput, ShellNodeConfigSection>();
container.Connectable <ShellNodeConfig, ShellNodeConfigInput>();
container.Connectable <ShellNodeConfig, ShellNodeConfigSection>();
container.Connectable <IShellNodeConfigItem, ShellTemplateConfigNode>();
container.Connectable <ShellNodeConfigSection, ShellNodeConfigInput>();
container.Connectable <ShellNodeConfigSection, ShellNodeConfigSection>();
}
public override void Loaded(UFrameContainer container)
{
base.Loaded(container);
ToolbarUI = container.Resolve<ToolbarUI>();
Signal<IToolbarQuery>(_ => _.QueryToolbarCommands(ToolbarUI));
}
//public string CurrentUserId
//{
// get { return EditorPrefs.GetString("UF_CurrentUserId", string.Empty); }
// set
// {
// EditorPrefs.SetString("UF_CurrentUserId",value);
// }
//}
//public UserSettings CurrentUser
//{
// get { return _currentUser ?? (_currentUser = Repository.GetSingle<UserSettings>(CurrentUserId)); }
//}
public override void Loaded(UFrameContainer container)
{
base.Loaded(container);
}
public override void Initialize(UFrameContainer container)
{
base.Initialize(container);
container.RegisterDrawer<HelloWorldWindowViewModel,HelloWorldWindowDrawer>();
}
