public Question(IPresenter master, string text, params Answer[] possibleAnswers)
 {
     Master = master;
     Text = text;
     PossibleAnswers = new BindableEnumCollection<Answer>(possibleAnswers);
     Buttons = ConvertToButtons(possibleAnswers);
 }

        public override void Given()
        {
            base.Given();

            _key = "Test";
            _presenter = _mock.DynamicMock<IPresenter>();
        }

        public void Bind(IPresenter presenter)
        {
            var presenterType = presenter.GetType();
            var menu = BindingHelper.GetViewControls(presenter.View).OfType<MenuStrip>().FirstOrDefault();
            if (menu == null)
                return;

            var items = GetMenuItems(menu);

            var presenterMethods = BindingHelper.GetParameterlessActionMethods(presenterType);

            foreach (var method in presenterMethods)
            {
                string methodName = method.Name;
                var item = items.FirstOrDefault(
                    x => x.Name == Convensions.MenuItemPrefix + methodName.Substring(Convensions.EventHandlerPrefix.Length));

                if (item == null)
                    continue;

                var action = (Action)Delegate.CreateDelegate(typeof(Action), presenter, method.Name);

                var handler = (EventHandler)((sender, args) => action());
                item.Click += handler;
            }
        }

 public CommandActionsEntryPoint(ICommandManager commandManager, ITheaterApplicationHost appHost, IPresenter presentationManager, IPlaybackManager playbackManager, INavigator navigationService, /*IScreensaverManager screensaverManager,*/ ILogManager logManager, IEventAggregator events)
 {
     _commandManager = commandManager;
     _defaultCommandActionMap = new DefaultCommandActionMap(appHost, presentationManager, playbackManager, navigationService, /*screensaverManager,*/ logManager, events);
 
     _logger = logManager.GetLogger(GetType().Name);
 }

 public DetailForm(string article)
     : this()
 {
     if (!DesignMode)
       {
     _presenter = IoC.Resolve<IPresenter<IDetailView>>(new {view = this, article = article});
       }
 }

        private void UpdateTitle(IPresenter presenter)
        {
            var oldTitle = HtmlPage.Document.GetProperty("title");
            var newTitle = _config.AlterTitle(oldTitle.ToString(), presenter);

            if (!string.IsNullOrEmpty(newTitle))
                HtmlPage.Document.SetProperty("title", newTitle);
        }

 public MainForm()
 {
     InitializeComponent();
       if (!DesignMode)
       {
     _presenter = IoC.Resolve<IPresenter<IMainFormView>>(new {view = this});
       }
 }

 public MainWindow(IPresenter controller)
 {
     m_Controller = controller;
     InitializeComponent();
     loggerType.Items.Add(LoggerFactory.ConsoleLoggerName);
     loggerType.Items.Add(LoggerFactory.MessageboxLoggerName);
     loggerType.SelectedIndex = 0;
 }

        public void Release(IPresenter presenter)
        {
            container.EjectAllInstancesOf<IPresenter>();

            var disposablePresenter = presenter as IDisposable;
            if (disposablePresenter != null)
                disposablePresenter.Dispose();
        }

 /// <summary>
 /// Releases the specified presenter from any of its lifestyle demands.
 /// </summary>
 /// <param name="presenter">The presenter to release.</param>
 public void Release(IPresenter presenter)
 {
     var disposablePresenter = presenter as IDisposable;
     if (disposablePresenter != null)
     {
         disposablePresenter.Dispose();
     }
 }

 public ModsPageView(IParkitect parkitect, ILogger log, IPresenter parent, IQueueableTaskManager queueableTaskManager,
     IWebsite website)
     : base(parkitect, website, log, AssetType.Mod, parent, "Mods")
 {
     _parkitect = parkitect;
     _queueableTaskManager = queueableTaskManager;
     _website = website;
 }

 public LoginContext(IApplicationHost appHost, IPresenter presenter, ISessionManager sessionManager,
                     ILogManager logManager, IImageManager imageManager, IApiClient apiClient) : base(appHost)
 {
     _presenter = presenter;
     _sessionManager = sessionManager;
     _logManager = logManager;
     _imageManager = imageManager;
     _apiClient = apiClient;
 }

 public SideMenuContext(ITheaterApplicationHost appHost, IPresenter presenter, ISessionManager sessionManager, IImageManager imageManager, IApiClient apiClient)
     : base(appHost)
 {
     _appHost = appHost;
     _presenter = presenter;
     _sessionManager = sessionManager;
     _imageManager = imageManager;
     _apiClient = apiClient;
 }

//        private readonly IPlaybackManager _playback;

        public SessionManager(INavigator navService, IPresenter presenter, IApiClient apiClient, ILogger logger, ITheaterConfigurationManager config) //, IPlaybackManager playback)
        {
            _navService = navService;
            _presenter = presenter;
            _apiClient = apiClient;
            _logger = logger;
            _config = config;
//            _playback = playback;
        }

        public virtual void Release(IPresenter presenter)
        {
            this._container.EjectAllInstancesOf<IPresenter>();

            IDisposable disposablePresenter = presenter as IDisposable;

            if(disposablePresenter != null)
                disposablePresenter.Dispose();
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="presenter"></param>
        public MainWindow(IPresenter presenter)
        {
            InitializeComponent();

            this.Text = "System ekspercki - Marcin Foder, listopad 2015";
            this.presenter = presenter;
            presenter.AddCheckBoxs(inferenceModulePanel);
            presenter.LoadKnowledgeEditorModule(cbFacts, cbRules, lbAllFacts, cbRuleCreatingFact, lbFactsElements, cbElements);
        }

        /// <summary>
        /// Releases the specified presenter.
        /// </summary>
        /// <param name="presenter">The presenter.</param>
        public virtual void Release(IPresenter presenter)
        {
            var released = Kernel.Release(presenter);

            Trace.WriteLine(string.Format("Presenter instance found and released by kernel {0}", released));

            var disposablePresenter = presenter as IDisposable;
            if (disposablePresenter != null)
                disposablePresenter.Dispose();
        }

 public PlaybackManager(ITheaterConfigurationManager configurationManager, ILogger logger, IApiClient apiClient, INavigator nav, IPresenter presentationManager, IEventAggregator events)
 {
     _configurationManager = configurationManager;
     _logger = logger;
     _apiClient = apiClient;
     _nav = nav;
     _presentationManager = presentationManager;
     _playbackStart = events.Get<PlaybackStartEventArgs>();
     _playbackStop = events.Get<PlaybackStopEventArgs>();
 }

        public override void Given()
        {
            base.Given();

            _key = "Test";
            _presenter = _mock.DynamicMock<IPresenter>();
            _viewModel = _mock.DynamicMock<IViewModel>();

            _facade.Register(_key, _presenter);
        }

        public override bool Execute()
        {
            mPresenter = mContainer.Resolve<IPresenter>();
              string cPageException = "Cannot create page";

              var menuVmDef = new ViewModelDefinition();
              menuVmDef.AddQuality<MenuQuality>();
              menuVmDef.AddQuality<MyQuality>();
              var mainChildVmDef = new ViewModelDefinition();
              mainChildVmDef.AddQuality<MainChildQuality>();

              try
              {
            mViewModelManager.RegisterPageForViewModel<FirstViewModel, FirstPage>(mainChildVmDef);
              }
              catch (Exception e) when (e.Message.StartsWith(cPageException)) { }
              try
              {
            mViewModelManager.RegisterPageForViewModel<SecondViewModel, SecondPage>(menuVmDef);
              }
              catch (Exception e) when (e.Message.StartsWith(cPageException)) { }

              // show
              var first = mPresenter.Show<FirstViewModel>().Result;
              if (first == null || !first.NavTo)
              {
            return false;
              }
              var second = mPresenter.Show(
            def => def.HasQuality<MyQuality>())
            .Result as SecondViewModel;
              if (second == null || !second.NavTo)
              {
            return false;
              }

              // close
              second = mPresenter.Close(
            x => x.HasQuality<MyQuality>())
            .Result as SecondViewModel;
              if (second == null || !second.NavFrom)
              {
            return false;
              }
              first = mPresenter.Close<FirstViewModel>().Result;
              if (first == null || !first.NavFrom)
              {
            return false;
              }

              // TODO : find way to test alerts
              //return PathwayCore.DisplayAlertAsync("Alert", "Are you sure?", "Ok").Result;

              return true;
        }