Beispiel #1
0
    public void Execute(params object[] args)
    {
// >>> PARAMETERS

// <<< PARAMETERS


// >>> DECLARATIONS
        var minLibsMVCContextSignals             = new MinLibs.MVC.ContextSignals();
        var minLibsMVCMediators                  = new MinLibs.MVC.Mediators();
        var webExercisesMinHUDSetupMinHUDContext = new WebExercises.MinHUD.SetupMinHUDContext();

// <<< DECLARATIONS


// >>> REGISTRATIONS
        context.RegisterInstance <MinLibs.Signals.ISignalsManager>(minLibsMVCContextSignals, RegisterFlags.PreventInjections);
        context.RegisterInstance <MinLibs.MVC.IMediators>(minLibsMVCMediators, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Shared.ISetupContext>(webExercisesMinHUDSetupMinHUDContext, RegisterFlags.PreventInjections);
// <<< REGISTRATIONS


// >>> HANDLERS
        context.RegisterHandler <MinLibs.MVC.RootMediator>(host => {
            var minLibsMVCRootMediator       = new MinLibs.MVC.RootMediator();
            minLibsMVCRootMediator.mediators = context.Get <MinLibs.MVC.IMediators>();

            return(minLibsMVCRootMediator);
        }, RegisterFlags.NoCache | RegisterFlags.PreventInjections);

        context.RegisterHandler <WebExercises.Shared.Components.FullscreenToggleMediator>(host => {
            var webExercisesSharedComponentsFullscreenToggleMediator    = new WebExercises.Shared.Components.FullscreenToggleMediator();
            webExercisesSharedComponentsFullscreenToggleMediator.screen = context.Get <MinLibs.Utils.IScreen>();
            webExercisesSharedComponentsFullscreenToggleMediator.log    = context.Get <MinLibs.Logging.ILogging>();

            return(webExercisesSharedComponentsFullscreenToggleMediator);
        }, RegisterFlags.NoCache | RegisterFlags.PreventInjections);

// <<< HANDLERS


// >>> ASSIGNMENTS
        minLibsMVCMediators.context = context.Get <MinLibs.MVC.IContext>();

        webExercisesMinHUDSetupMinHUDContext.mediators = context.Get <MinLibs.MVC.IMediators>();
        webExercisesMinHUDSetupMinHUDContext.signals   = context.Get <MinLibs.Signals.ISignalsManager>();

// <<< ASSIGNMENTS


// >>> CLEANUPS
        context.OnCleanUp.AddListener(minLibsMVCContextSignals.Cleanup);
// <<< CLEANUPS


// >>> POSTINJECTIONS

// <<< POSTINJECTIONS
    }
    public void Execute(params object[] args)
    {
// >>> PARAMETERS

// <<< PARAMETERS


// >>> DECLARATIONS
        var minLibsMVCContextSignals            = new MinLibs.MVC.ContextSignals();
        var minLibsMVCMediators                 = new MinLibs.MVC.Mediators();
        var webExercisesHUDSetupDialogueContext = new WebExercises.HUD.SetupDialogueContext();

// <<< DECLARATIONS


// >>> REGISTRATIONS
        context.RegisterInstance <MinLibs.Signals.ISignalsManager>(minLibsMVCContextSignals, RegisterFlags.PreventInjections);
        context.RegisterInstance <MinLibs.MVC.IMediators>(minLibsMVCMediators, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Shared.ISetupContext>(webExercisesHUDSetupDialogueContext, RegisterFlags.PreventInjections);
// <<< REGISTRATIONS


// >>> HANDLERS
        context.RegisterHandler <MinLibs.MVC.RootMediator>(host => {
            var minLibsMVCRootMediator       = new MinLibs.MVC.RootMediator();
            minLibsMVCRootMediator.mediators = context.Get <MinLibs.MVC.IMediators>();

            return(minLibsMVCRootMediator);
        }, RegisterFlags.NoCache | RegisterFlags.PreventInjections);

        context.RegisterHandler <WebExercises.HUD.DialogueMediator>(host => {
            var webExercisesHUDDialogueMediator            = new WebExercises.HUD.DialogueMediator();
            webExercisesHUDDialogueMediator.onShowDialogue = context.Get <WebExercises.Runner.OnShowDialogue>();
            webExercisesHUDDialogueMediator.onHideDialogue = context.Get <WebExercises.Runner.OnHideDialogue>();

            return(webExercisesHUDDialogueMediator);
        }, RegisterFlags.NoCache | RegisterFlags.PreventInjections);

// <<< HANDLERS


// >>> ASSIGNMENTS
        minLibsMVCMediators.context = context.Get <MinLibs.MVC.IContext>();

        webExercisesHUDSetupDialogueContext.mediators = context.Get <MinLibs.MVC.IMediators>();
        webExercisesHUDSetupDialogueContext.signals   = context.Get <MinLibs.Signals.ISignalsManager>();

// <<< ASSIGNMENTS


// >>> CLEANUPS
        context.OnCleanUp.AddListener(minLibsMVCContextSignals.Cleanup);
// <<< CLEANUPS


// >>> POSTINJECTIONS

// <<< POSTINJECTIONS
    }
    public void Execute(params object[] args)
    {
// >>> PARAMETERS
        var minLibsLoggingILogging = (MinLibs.Logging.ILogging)args[0];
// <<< PARAMETERS


// >>> DECLARATIONS
        var minLibsMVCContextSignals             = new MinLibs.MVC.ContextSignals();
        var minLibsMVCMediators                  = new MinLibs.MVC.Mediators();
        var minLibsUtilsUnityPlatform            = new MinLibs.Utils.UnityPlatform();
        var minLibsUtilsUnityScreen              = new MinLibs.Utils.UnityScreen();
        var webExercisesSharedJsonParser         = new WebExercises.Shared.JsonParser();
        var minLibsUtilsUnityResources           = new MinLibs.Utils.UnityResources();
        var minLibsUtilsUnityInput               = new MinLibs.Utils.UnityInput();
        var webExercisesRunnerAppState           = new WebExercises.Runner.AppState();
        var webExercisesRunnerSetupRunnerContext = new WebExercises.Runner.SetupRunnerContext();
        var webExercisesRunnerRunnerSettings     = new WebExercises.Runner.RunnerSettings();
        var minLibsUtilsSystemRandom             = new MinLibs.Utils.SystemRandom();
        var minLibsMVCTimers = new MinLibs.MVC.Timers();
        var webExercisesRunnerFrontendSender     = new WebExercises.Runner.FrontendSender();
        var webExercisesRunnerBundles            = new WebExercises.Runner.Bundles();
        var webExercisesRunnerScenes             = new WebExercises.Runner.Scenes();
        var webExercisesSharedHotKeys            = new WebExercises.Shared.HotKeys();
        var webExercisesSharedLocalization       = new WebExercises.Shared.Localization();
        var webExercisesRunnerGetConfig          = new WebExercises.Runner.GetConfig();
        var webExercisesRunnerLoadBundle         = new WebExercises.Runner.LoadBundle();
        var webExercisesRunnerInitApp            = new WebExercises.Runner.InitApp();
        var webExercisesRunnerLoadExercise       = new WebExercises.Runner.LoadExercise();
        var webExercisesRunnerRemoveExercise     = new WebExercises.Runner.RemoveExercise();
        var webExercisesRunnerOnStartExercise    = new WebExercises.Runner.OnStartExercise();
        var webExercisesRunnerOnShowDialogue     = new WebExercises.Runner.OnShowDialogue();
        var webExercisesRunnerOnHideDialogue     = new WebExercises.Runner.OnHideDialogue();
        var webExercisesSharedOnBlockApp         = new WebExercises.Shared.OnBlockApp();
        var webExercisesSharedOnExerciseFinished = new WebExercises.Shared.OnExerciseFinished();

// <<< DECLARATIONS


// >>> REGISTRATIONS
        context.RegisterInstance <MinLibs.Signals.ISignalsManager>(minLibsMVCContextSignals, RegisterFlags.PreventInjections);
        context.RegisterInstance <MinLibs.MVC.IMediators>(minLibsMVCMediators, RegisterFlags.PreventInjections);
        context.RegisterInstance(minLibsLoggingILogging, RegisterFlags.None);
        context.RegisterInstance <MinLibs.Utils.IPlatform>(minLibsUtilsUnityPlatform, RegisterFlags.PreventInjections);
        context.RegisterInstance <MinLibs.Utils.IScreen>(minLibsUtilsUnityScreen, RegisterFlags.PreventInjections);
        context.RegisterInstance <MinLibs.Utils.IParser>(webExercisesSharedJsonParser, RegisterFlags.PreventInjections);
        context.RegisterInstance <MinLibs.Utils.IResources>(minLibsUtilsUnityResources, RegisterFlags.PreventInjections);
        context.RegisterInstance <MinLibs.Utils.IInput>(minLibsUtilsUnityInput, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Runner.IAppState>(webExercisesRunnerAppState, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Shared.ISetupContext>(webExercisesRunnerSetupRunnerContext, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Runner.IRunnerSettings>(webExercisesRunnerRunnerSettings, RegisterFlags.PreventInjections);
        context.RegisterInstance <MinLibs.Utils.IRandom>(minLibsUtilsSystemRandom, RegisterFlags.PreventInjections);
        context.RegisterInstance <MinLibs.MVC.ITimers>(minLibsMVCTimers, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Runner.IFrontendSender>(webExercisesRunnerFrontendSender, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Runner.IBundles>(webExercisesRunnerBundles, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Runner.IScenes>(webExercisesRunnerScenes, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Shared.IHotKeys>(webExercisesSharedHotKeys, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Shared.ILocalization>(webExercisesSharedLocalization, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Runner.IGetConfig>(webExercisesRunnerGetConfig, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Runner.ILoadBundle>(webExercisesRunnerLoadBundle, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Runner.IInitApp>(webExercisesRunnerInitApp, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Runner.ILoadExercise>(webExercisesRunnerLoadExercise, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Runner.IRemoveExercise>(webExercisesRunnerRemoveExercise, RegisterFlags.PreventInjections);
        context.RegisterInstance(webExercisesRunnerOnStartExercise, RegisterFlags.PreventInjections);
        context.RegisterInstance(webExercisesRunnerOnShowDialogue, RegisterFlags.PreventInjections);
        context.RegisterInstance(webExercisesRunnerOnHideDialogue, RegisterFlags.PreventInjections);
        context.RegisterInstance(webExercisesSharedOnBlockApp, RegisterFlags.PreventInjections);
        context.RegisterInstance(webExercisesSharedOnExerciseFinished, RegisterFlags.PreventInjections);
// <<< REGISTRATIONS


// >>> HANDLERS
        context.RegisterHandler <MinLibs.MVC.RootMediator>(host => {
            var minLibsMVCRootMediator       = new MinLibs.MVC.RootMediator();
            minLibsMVCRootMediator.mediators = context.Get <MinLibs.MVC.IMediators>();

            return(minLibsMVCRootMediator);
        }, RegisterFlags.NoCache | RegisterFlags.PreventInjections);

        context.RegisterHandler <WebExercises.Runner.IAppLifeCycleMediator>(host => {
            var webExercisesRunnerAppLifeCycleMediator        = new WebExercises.Runner.AppLifeCycleMediator();
            webExercisesRunnerAppLifeCycleMediator.appState   = context.Get <WebExercises.Runner.IAppState>();
            webExercisesRunnerAppLifeCycleMediator.onBlockApp = context.Get <WebExercises.Shared.OnBlockApp>();

            return(webExercisesRunnerAppLifeCycleMediator);
        }, RegisterFlags.NoCache | RegisterFlags.PreventInjections);

        context.RegisterHandler <WebExercises.Runner.FrontendReceiverMediator>(host => {
            var webExercisesRunnerFrontendReceiverMediator             = new WebExercises.Runner.FrontendReceiverMediator();
            webExercisesRunnerFrontendReceiverMediator.initApp         = context.Get <WebExercises.Runner.IInitApp>();
            webExercisesRunnerFrontendReceiverMediator.loadExercise    = context.Get <WebExercises.Runner.ILoadExercise>();
            webExercisesRunnerFrontendReceiverMediator.onStartExercise = context.Get <WebExercises.Runner.OnStartExercise>();

            return(webExercisesRunnerFrontendReceiverMediator);
        }, RegisterFlags.NoCache | RegisterFlags.PreventInjections);

// <<< HANDLERS


// >>> ASSIGNMENTS
        minLibsMVCMediators.context = context.Get <MinLibs.MVC.IContext>();

        webExercisesRunnerSetupRunnerContext.sender             = context.Get <WebExercises.Runner.IFrontendSender>();
        webExercisesRunnerSetupRunnerContext.onExerciseFinished = webExercisesSharedOnExerciseFinished;
        webExercisesRunnerSetupRunnerContext.removeExercise     = context.Get <WebExercises.Runner.IRemoveExercise>();
        webExercisesRunnerSetupRunnerContext.screen             = context.Get <MinLibs.Utils.IScreen>();
        webExercisesRunnerSetupRunnerContext.hotKeys            = context.Get <WebExercises.Shared.IHotKeys>();
        webExercisesRunnerSetupRunnerContext.mediators          = context.Get <MinLibs.MVC.IMediators>();
        webExercisesRunnerSetupRunnerContext.signals            = context.Get <MinLibs.Signals.ISignalsManager>();

        webExercisesSharedHotKeys.input = context.Get <MinLibs.Utils.IInput>();

        webExercisesRunnerGetConfig.settings = context.Get <WebExercises.Runner.IRunnerSettings>();
        webExercisesRunnerGetConfig.logger   = minLibsLoggingILogging;
        webExercisesRunnerGetConfig.parser   = context.Get <MinLibs.Utils.IParser>();

        webExercisesRunnerLoadBundle.log      = minLibsLoggingILogging;
        webExercisesRunnerLoadBundle.settings = context.Get <WebExercises.Runner.IRunnerSettings>();
        webExercisesRunnerLoadBundle.bundles  = context.Get <WebExercises.Runner.IBundles>();
        webExercisesRunnerLoadBundle.scenes   = context.Get <WebExercises.Runner.IScenes>();

        webExercisesRunnerInitApp.platform     = context.Get <MinLibs.Utils.IPlatform>();
        webExercisesRunnerInitApp.log          = minLibsLoggingILogging;
        webExercisesRunnerInitApp.parser       = context.Get <MinLibs.Utils.IParser>();
        webExercisesRunnerInitApp.settings     = context.Get <WebExercises.Runner.IRunnerSettings>();
        webExercisesRunnerInitApp.localization = context.Get <WebExercises.Shared.ILocalization>();
        webExercisesRunnerInitApp.sender       = context.Get <WebExercises.Runner.IFrontendSender>();
        webExercisesRunnerInitApp.loadBundle   = context.Get <WebExercises.Runner.ILoadBundle>();

        webExercisesRunnerLoadExercise.context      = context.Get <MinLibs.MVC.IContext>();
        webExercisesRunnerLoadExercise.log          = minLibsLoggingILogging;
        webExercisesRunnerLoadExercise.parser       = context.Get <MinLibs.Utils.IParser>();
        webExercisesRunnerLoadExercise.settings     = context.Get <WebExercises.Runner.IRunnerSettings>();
        webExercisesRunnerLoadExercise.localization = context.Get <WebExercises.Shared.ILocalization>();
        webExercisesRunnerLoadExercise.loadBundle   = context.Get <WebExercises.Runner.ILoadBundle>();
        webExercisesRunnerLoadExercise.sender       = context.Get <WebExercises.Runner.IFrontendSender>();
        webExercisesRunnerLoadExercise.scenes       = context.Get <WebExercises.Runner.IScenes>();

        webExercisesRunnerRemoveExercise.log            = minLibsLoggingILogging;
        webExercisesRunnerRemoveExercise.platform       = context.Get <MinLibs.Utils.IPlatform>();
        webExercisesRunnerRemoveExercise.runnerSettings = context.Get <WebExercises.Runner.IRunnerSettings>();
        webExercisesRunnerRemoveExercise.bundles        = context.Get <WebExercises.Runner.IBundles>();
        webExercisesRunnerRemoveExercise.scenes         = context.Get <WebExercises.Runner.IScenes>();
        webExercisesRunnerRemoveExercise.sender         = context.Get <WebExercises.Runner.IFrontendSender>();

// <<< ASSIGNMENTS


// >>> CLEANUPS
        context.OnCleanUp.AddListener(minLibsMVCContextSignals.Cleanup);
// <<< CLEANUPS


// >>> POSTINJECTIONS

// <<< POSTINJECTIONS
    }
Beispiel #4
0
    public void Execute(params object[] args)
    {
// >>> PARAMETERS

// <<< PARAMETERS


// >>> DECLARATIONS
        var minLibsMVCContextSignals                        = new MinLibs.MVC.ContextSignals();
        var minLibsMVCMediators                             = new MinLibs.MVC.Mediators();
        var webExercisesExerciseExerciseSettings            = new WebExercises.Exercise.ExerciseSettings();
        var webExercisesExerciseExerciseState               = new WebExercises.Exercise.ExerciseState();
        var webExercisesExerciseEndExercise                 = new WebExercises.Exercise.EndExercise();
        var webExercisesSharedGenerateExerciseResult        = new WebExercises.Shared.GenerateExerciseResult();
        var webExercisesExerciseBlockApp                    = new WebExercises.Exercise.BlockApp();
        var webExercisesSharedExerciseControllerProxy       = new WebExercises.Shared.ExerciseControllerProxy();
        var webExercisesSharedExerciseViewAdapter           = new WebExercises.Shared.ExerciseViewAdapter();
        var webExercisesSharedHUDViewAdapter                = new WebExercises.Shared.HUDViewAdapter();
        var webExercisesSharedBackgroundViewAdapter         = new WebExercises.Shared.BackgroundViewAdapter();
        var webExercisesExerciseOnShowExercise              = new WebExercises.Exercise.OnShowExercise();
        var webExercisesExerciseOnFinishInitialRound        = new WebExercises.Exercise.OnFinishInitialRound();
        var webExercisesMemoflowSetupMemoflowContext        = new WebExercises.Memoflow.SetupMemoflowContext();
        var webExercisesMemoflowStartMemoflow               = new WebExercises.Memoflow.StartMemoflow();
        var exerciseEngineColorsBaseColorManagerInitializer = new ExerciseEngine.Colors.BaseColorManagerInitializer();

// <<< DECLARATIONS


// >>> REGISTRATIONS
        context.RegisterInstance <MinLibs.Signals.ISignalsManager>(minLibsMVCContextSignals, RegisterFlags.PreventInjections);
        context.RegisterInstance <MinLibs.MVC.IMediators>(minLibsMVCMediators, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Exercise.IExerciseSettings>(webExercisesExerciseExerciseSettings, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Exercise.IExerciseState>(webExercisesExerciseExerciseState, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Exercise.IEndExercise>(webExercisesExerciseEndExercise, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Shared.IGenerateExerciseResult>(webExercisesSharedGenerateExerciseResult, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Exercise.IBlockApp>(webExercisesExerciseBlockApp, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Shared.IExerciseControllerProxy>(webExercisesSharedExerciseControllerProxy, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Shared.IExerciseViewAdapter>(webExercisesSharedExerciseViewAdapter, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Shared.IHUDViewAdapter>(webExercisesSharedHUDViewAdapter, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Shared.IBackgroundViewAdapter>(webExercisesSharedBackgroundViewAdapter, RegisterFlags.PreventInjections);
        context.RegisterInstance(webExercisesExerciseOnShowExercise, RegisterFlags.PreventInjections);
        context.RegisterInstance(webExercisesExerciseOnFinishInitialRound, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Shared.ISetupContext>(webExercisesMemoflowSetupMemoflowContext, RegisterFlags.PreventInjections);
        context.RegisterInstance <WebExercises.Exercise.IStartExercise>(webExercisesMemoflowStartMemoflow, RegisterFlags.PreventInjections);
        context.RegisterInstance <ExerciseEngine.Colors.IColorManagerInitializer>(exerciseEngineColorsBaseColorManagerInitializer, RegisterFlags.PreventInjections);
// <<< REGISTRATIONS


// >>> HANDLERS
        context.RegisterHandler <MinLibs.MVC.RootMediator>(host => {
            var minLibsMVCRootMediator       = new MinLibs.MVC.RootMediator();
            minLibsMVCRootMediator.mediators = context.Get <MinLibs.MVC.IMediators>();

            return(minLibsMVCRootMediator);
        }, RegisterFlags.NoCache | RegisterFlags.PreventInjections);

        context.RegisterHandler <WebExercises.Exercise.ExerciseRootMediator>(host => {
            var webExercisesExerciseExerciseRootMediator            = new WebExercises.Exercise.ExerciseRootMediator();
            webExercisesExerciseExerciseRootMediator.onShowExercise = context.Get <WebExercises.Exercise.OnShowExercise>();

            return(webExercisesExerciseExerciseRootMediator);
        }, RegisterFlags.NoCache | RegisterFlags.PreventInjections);

        context.RegisterHandler <WebExercises.Memoflow.MemoflowItemPanelMediator>(host => {
            var webExercisesMemoflowMemoflowItemPanelMediator                  = new WebExercises.Memoflow.MemoflowItemPanelMediator();
            webExercisesMemoflowMemoflowItemPanelMediator.controller           = context.Get <WebExercises.Shared.IExerciseControllerProxy>();
            webExercisesMemoflowMemoflowItemPanelMediator.settings             = context.Get <WebExercises.Exercise.IExerciseSettings>();
            webExercisesMemoflowMemoflowItemPanelMediator.onFinishInitialRound = webExercisesExerciseOnFinishInitialRound;

            return(webExercisesMemoflowMemoflowItemPanelMediator);
        }, RegisterFlags.NoCache | RegisterFlags.PreventInjections);

        context.RegisterHandler <WebExercises.Memoflow.MemoflowUIMediator>(host => {
            var webExercisesMemoflowMemoflowUIMediator                  = new WebExercises.Memoflow.MemoflowUIMediator();
            webExercisesMemoflowMemoflowUIMediator.controller           = context.Get <WebExercises.Shared.IExerciseControllerProxy>();
            webExercisesMemoflowMemoflowUIMediator.onFinishInitialRound = webExercisesExerciseOnFinishInitialRound;
            webExercisesMemoflowMemoflowUIMediator.hotKeys              = context.Get <WebExercises.Shared.IHotKeys>();
            webExercisesMemoflowMemoflowUIMediator.localization         = context.Get <WebExercises.Shared.ILocalization>();

            return(webExercisesMemoflowMemoflowUIMediator);
        }, RegisterFlags.NoCache | RegisterFlags.PreventInjections);

// <<< HANDLERS


// >>> ASSIGNMENTS
        minLibsMVCMediators.context = context.Get <MinLibs.MVC.IContext>();

        webExercisesExerciseEndExercise.context            = context.Get <MinLibs.MVC.IContext>();
        webExercisesExerciseEndExercise.parser             = context.Get <MinLibs.Utils.IParser>();
        webExercisesExerciseEndExercise.onExerciseFinished = context.Get <WebExercises.Shared.OnExerciseFinished>();

        webExercisesSharedGenerateExerciseResult.state = context.Get <WebExercises.Exercise.IExerciseState>();

        webExercisesExerciseBlockApp.controller     = context.Get <WebExercises.Shared.IExerciseControllerProxy>();
        webExercisesExerciseBlockApp.appState       = context.Get <WebExercises.Runner.IAppState>();
        webExercisesExerciseBlockApp.localization   = context.Get <WebExercises.Shared.ILocalization>();
        webExercisesExerciseBlockApp.onShowDialogue = context.Get <WebExercises.Runner.OnShowDialogue>();
        webExercisesExerciseBlockApp.onHideDialogue = context.Get <WebExercises.Runner.OnHideDialogue>();

        webExercisesSharedExerciseControllerProxy.generateExerciseResult = context.Get <WebExercises.Shared.IGenerateExerciseResult>();

        webExercisesSharedExerciseViewAdapter.parser          = context.Get <MinLibs.Utils.IParser>();
        webExercisesSharedExerciseViewAdapter.logger          = context.Get <MinLibs.Logging.ILogging>();
        webExercisesSharedExerciseViewAdapter.controllerProxy = context.Get <WebExercises.Shared.IExerciseControllerProxy>();

        webExercisesSharedHUDViewAdapter.logger          = context.Get <MinLibs.Logging.ILogging>();
        webExercisesSharedHUDViewAdapter.parser          = context.Get <MinLibs.Utils.IParser>();
        webExercisesSharedHUDViewAdapter.controllerProxy = context.Get <WebExercises.Shared.IExerciseControllerProxy>();

        webExercisesMemoflowSetupMemoflowContext.controller      = context.Get <WebExercises.Shared.IExerciseControllerProxy>();
        webExercisesMemoflowSetupMemoflowContext.onStartExercise = context.Get <WebExercises.Runner.OnStartExercise>();
        webExercisesMemoflowSetupMemoflowContext.onBlockApp      = context.Get <WebExercises.Shared.OnBlockApp>();
        webExercisesMemoflowSetupMemoflowContext.startExercise   = context.Get <WebExercises.Exercise.IStartExercise>();
        webExercisesMemoflowSetupMemoflowContext.blockApp        = context.Get <WebExercises.Exercise.IBlockApp>();
        webExercisesMemoflowSetupMemoflowContext.endExercise     = context.Get <WebExercises.Exercise.IEndExercise>();
        webExercisesMemoflowSetupMemoflowContext.mediators       = context.Get <MinLibs.MVC.IMediators>();
        webExercisesMemoflowSetupMemoflowContext.signals         = context.Get <MinLibs.Signals.ISignalsManager>();

        webExercisesMemoflowStartMemoflow.colorManager          = context.Get <ExerciseEngine.Colors.IColorManagerInitializer>();
        webExercisesMemoflowStartMemoflow.context               = context.Get <MinLibs.MVC.IContext>();
        webExercisesMemoflowStartMemoflow.platform              = context.Get <MinLibs.Utils.IPlatform>();
        webExercisesMemoflowStartMemoflow.parser                = context.Get <MinLibs.Utils.IParser>();
        webExercisesMemoflowStartMemoflow.runnerSettings        = context.Get <WebExercises.Runner.IRunnerSettings>();
        webExercisesMemoflowStartMemoflow.exerciseSettings      = context.Get <WebExercises.Exercise.IExerciseSettings>();
        webExercisesMemoflowStartMemoflow.exerciseState         = context.Get <WebExercises.Exercise.IExerciseState>();
        webExercisesMemoflowStartMemoflow.getConfig             = context.Get <WebExercises.Runner.IGetConfig>();
        webExercisesMemoflowStartMemoflow.exerciseController    = context.Get <WebExercises.Shared.IExerciseControllerProxy>();
        webExercisesMemoflowStartMemoflow.exerciseViewAdapter   = context.Get <WebExercises.Shared.IExerciseViewAdapter>();
        webExercisesMemoflowStartMemoflow.hudViewAdapter        = context.Get <WebExercises.Shared.IHUDViewAdapter>();
        webExercisesMemoflowStartMemoflow.backgroundViewAdapter = context.Get <WebExercises.Shared.IBackgroundViewAdapter>();
        webExercisesMemoflowStartMemoflow.onShowExercise        = webExercisesExerciseOnShowExercise;

// <<< ASSIGNMENTS


// >>> CLEANUPS
        context.OnCleanUp.AddListener(minLibsMVCContextSignals.Cleanup);
// <<< CLEANUPS


// >>> POSTINJECTIONS

// <<< POSTINJECTIONS
    }