/// <summary> /// Navigates to the next navigation graph. /// </summary> /// <param name="nextNavigatorName">Name of the next navigation graph.</param> /// <param name="taskArguments">A holder for originating the navigation graph and task ID, and an object that /// the controller can use to get state information from the previous navigation graph.</param> /// <param name="nextTask">Task to be started.</param> protected void OnStartTask(string nextNavigatorName, TaskArgumentsHolder taskArguments, ITask nextTask) { if (null != StartTask) { StartTask(this, new StartTaskEventArgs(nextNavigatorName, taskArguments, nextTask)); } }
private void StartTask(TaskArgumentsHolder args) { ControllerBase firstController = ControllerFactory.Create(_startView.Name, this); firstController.EnterTask(null); CurrentState.CurrentView = _startView.Name; CurrentState.Save(); try { ViewManager.ActivateView(null, _startView.Name, this, args); } catch (System.Threading.ThreadAbortException) {} catch (Exception ex) { throw new UIPException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionCantActivateView, _startView.Name) + UIPException.GetFirstExceptionMessage(ex), ex); } }
/// <summary> /// Overloaded. Starts open navigation beginning with the first view. /// </summary> /// <param name="firstView">The name of the first view.</param> /// <param name="args">Additional navigation arguments.</param> public void StartTask(string firstView, TaskArgumentsHolder args) { string startViewName = null; if (CurrentState.CurrentView != null && CurrentState.CurrentView.Length > 0) { startViewName = CurrentState.CurrentView; _startView = UIPConfiguration.Config.GetViewSettingsFromName(CurrentState.CurrentView); } else if (firstView != null && firstView.Length > 0) { startViewName = firstView; _startView = UIPConfiguration.Config.GetViewSettingsFromName(firstView); } if (_startView == null) { throw new UIPException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionViewConfigNotFound, startViewName)); } StartTask(args); }
private void StartTask(TaskArgumentsHolder args) { FormSettings hostSettings = _settings[_settings.StartFormName]; ViewSettings startFormSettings = UIPConfiguration.Config.GetViewSettingsFromName(hostSettings.Name); CurrentState.CurrentView = startFormSettings.Name; try { ViewManager.ActivateView(null, startFormSettings.Name, this, args); } catch (System.Threading.ThreadAbortException) {} catch (Exception ex) { throw new UIPException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionCantActivateView, startFormSettings.Name) + UIPException.GetFirstExceptionMessage(ex), ex); } CurrentState.Save(); if (hostSettings.InitialView != null) { Navigate(hostSettings.InitialView); } }
private void StartTask(TaskArgumentsHolder holder) { CurrentState.NavigationGraph = Name; if (CurrentState.CurrentView != null && CurrentState.CurrentView.Length > 0) { _startView = UIPConfiguration.Config.GetViewSettingsFromName(CurrentState.CurrentView); } ControllerBase firstController = ControllerFactory.Create(StartView.Name, this); firstController.EnterTask(holder); CurrentState.CurrentView = StartView.Name; CurrentState.NavigateValue = ""; CurrentState.Save(); try { ViewManager.ActivateView(null, StartView.Name, this); } catch (System.Threading.ThreadAbortException) {} catch (Exception ex) { throw new UIPException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionCantActivateView, StartView.Name) + UIPException.GetFirstExceptionMessage(ex), ex); } }
/// <summary> /// Overloaded. Starts open navigation, beginning with the first view for the specified task. /// </summary> /// <param name="firstView">The name of the first view.</param> /// <param name="task">The name of the task.</param> /// <param name="args">Additional navigation arguments.</param> public void StartTask(string firstView, ITask task, TaskArgumentsHolder args) { SetState(GetState(task)); StartTask(firstView, args); }
/// <summary> /// Overloaded. Starts open navigation for the specified task. /// </summary> /// <param name="task">The name of the task.</param> /// <param name="args">Additional navigation arguments.</param> public void StartTask(ITask task, TaskArgumentsHolder args) { StartTask(null, task, args); }
/// <summary> /// Initializes the WinFormControlView. /// </summary> /// <param name="args">The initialization arguments.</param> /// <param name="settings">The settings for the view.</param> public virtual void Initialize(TaskArgumentsHolder args, ViewSettings settings) { }
/// <summary> /// Activates a specific view. /// </summary> /// <param name="previousView">The view actually displayed.</param> /// <param name="view">The name of the view to be displayed.</param> /// <param name="navigator">The navigator requesting the transition.</param> /// <param name="args">Not used in this implementation of ActivateView.</param> public void ActivateView(string previousView, string view, Navigator navigator, TaskArgumentsHolder args) { ActivateView(previousView, view, navigator); }
/// <summary> /// The UIPManager calls this method when a new task starts. /// </summary> /// <param name="taskArguments">A holder for originating the navigation graph and task ID, and an object that /// the controller can use to get state information from the previous navigation graph.</param> public virtual void EnterTask(TaskArgumentsHolder taskArguments) { }
private void ActivateControl(WindowsFormControlView control, ViewSettings viewSettings, Navigator navigator, Guid taskId, TaskArgumentsHolder args) { control.InternalViewName = viewSettings.Name; control.InternalTaskId = taskId; ControllerBase controller = navigator.GetController(control); control.InternalNavigator = navigator; control.InternalController = controller; control.Initialize(args, viewSettings); }
private ViewSettings CreateNewView(string viewName, Navigator navigator, Guid taskId, TaskArgumentsHolder args) { //Create a new instance ViewSettings viewSettings = UIPConfiguration.Config.GetViewSettingsFromName(viewName); if (viewSettings == null) { throw new UIPException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionViewConfigNotFound, viewName)); } IView view = (IView)GenericFactory.Create(viewSettings); if (view is WindowsFormView) { WindowsFormView form = (WindowsFormView)view; ActivateForm(form, viewSettings, navigator, taskId, null, args); } else { WindowsFormControlView ctrl = (WindowsFormControlView)view; AddActiveControl(taskId, viewName, ctrl); ctrl.Disposed += new EventHandler(ControlDisposed); ActivateControl(ctrl, viewSettings, navigator, taskId, args); ctrl.Show(); } return(viewSettings); }
private WindowsFormView ActivateForm(WindowsFormView winFormView, ViewSettings viewSettings, Navigator navigator, Guid taskId, string previousView, TaskArgumentsHolder args) { winFormView.InternalTaskId = taskId; winFormView.InternalNavigationGraph = navigator.Name; winFormView.InternalViewName = viewSettings.Name; winFormView.InternalNavigator = navigator; ControllerBase controller = navigator.GetController(winFormView); winFormView.InternalController = controller; InitializeChildren(winFormView, navigator, taskId); winFormView.Initialize(args, viewSettings); AddActiveForm(taskId, viewSettings.Name, winFormView); AddActiveView(taskId, winFormView, viewSettings.Name); LayoutControlsIfRequired(viewSettings, winFormView); winFormView.Activated += new EventHandler(Form_Activated); winFormView.Closed += new EventHandler(Form_Closed); //Get the parent form Form parentForm = (Form)GetProperty(taskId, ParentFormKey); if (winFormView.IsMdiContainer || viewSettings.CanHaveFloatingWindows) { StoreProperty(taskId, ParentFormKey, winFormView); } else if (parentForm != null) { if (parentForm.IsMdiContainer) { winFormView.MdiParent = parentForm; } else if (viewSettings.IsFloatable) { winFormView.TopLevel = true; parentForm.AddOwnedForm(winFormView); winFormView.Show(); } } if (viewSettings.IsOpenModal) { ShowModal(winFormView, previousView, taskId, parentForm); } else { winFormView.Show(); } return(winFormView); }
/// <summary> /// Activates a specific view with activation arguments. /// </summary> /// <param name="previousView">The view currently displayed.</param> /// <param name="view">The name of the view to be displayed next.</param> /// <param name="navigator">The navigator.</param> /// <param name="args">The arguments for the next view.</param> public void ActivateView(string previousView, string view, Navigator navigator, TaskArgumentsHolder args) { Guid taskId = navigator.CurrentState.TaskId; InitiailizeFormAndViews(taskId); WindowsFormView winFormView = GetActiveForm(taskId, view); WindowsFormControlView controlView = GetActiveControl(taskId, view); ViewSettings viewSettings = null; if (winFormView != null) { winFormView.Activate(); winFormView.Visible = true; viewSettings = UIPConfiguration.Config.GetViewSettingsFromName(winFormView.ViewName); ClosePreviousFormIfNecessary(winFormView, previousView, taskId, viewSettings); } else if (controlView != null) { ActivateControl(controlView, previousView); viewSettings = UIPConfiguration.Config.GetViewSettingsFromName(controlView.ViewName); } else { viewSettings = CreateNewView(view, navigator, taskId, args); ClosePreviousFormIfNecessary(null, previousView, taskId, viewSettings); } }
/// <summary> /// Overloaded. Initializes a new StartTaskEventArgs class that assumes chaining of the navigation graphs, and /// the need for all information relevant to having a return pointer on a stack. /// </summary> /// <param name="nextNavigationGraphName">The next navigation graph.</param> /// <param name="taskArguments">The task arguments.</param> /// <param name="nextTask">A known point in a previously used navigation graph.</param> public StartTaskEventArgs(string nextNavigationGraphName, TaskArgumentsHolder taskArguments, ITask nextTask) { _nextNavGraphName = nextNavigationGraphName; _taskArguments = taskArguments; _nextTask = nextTask; }
/// <summary> /// Starts a UIProcess for hosted controls. /// </summary> /// <param name="name">The name of the hostedControl element in app.config.</param> /// <param name="taskId">The task identifier (a GUID associated with the task).</param> /// <param name="args">Arguments to the view.</param> public static void StartUserControlsTask(string name, Guid taskId, TaskArgumentsHolder args) { UserControlsNavigator navigator = new UserControlsNavigator(name); navigator.StartTask(taskId, args); }
/// <summary> /// Resumes an existing task or begins a new one, passing the TaskArgumentsHolder to the controller of the first view. /// </summary> /// <param name="task">The task to resume.</param> /// <param name="holder">The holder for any arguments to pass to the controller of the first view. Can be null.</param> public void StartTask(ITask task, TaskArgumentsHolder holder) { SetState(GetState(task)); StartTask(holder); }
/// <summary> /// Resumes a saved task and passes optional arguments to the first view. /// </summary> /// <param name="taskId">The task identifier of the task to resume.</param> /// <param name="args">Optional arguments to pass to the first view.</param> public void StartTask(Guid taskId, TaskArgumentsHolder args) { SetState(GetState(taskId)); StartTask(args); }
/// <summary> /// Resumes an existing task, passing the TaskArgumentsHolder to the controller of the first view. /// </summary> /// <param name="taskId">The identifier of the task to resume.</param> /// <param name="holder">The holder for any arguments to pass to the controller of the first view. Can be null.</param> public void StartTask(Guid taskId, TaskArgumentsHolder holder) { SetState(GetState(taskId)); StartTask(holder); }
/// <summary> /// Starts or resumes a task, and passes optional arguments to the first view. /// </summary> /// <param name="task">The task to start or resume.</param> /// <param name="args">Optional arguments to pass to the first view.</param> public void StartTask(ITask task, TaskArgumentsHolder args) { SetState(GetState(task)); StartTask(args); }
/// <summary> /// Activates a specific view with activation arguments. /// </summary> /// <param name="previousView">The view that is currently active.</param> /// <param name="viewName">The view name to be activated.</param> /// <param name="navigator">The navigator.</param> /// <param name="args">The arguments for the next view.</param> public void ActivateView(string previousView, string viewName, Navigator navigator, TaskArgumentsHolder args) { Guid taskId = navigator.CurrentState.TaskId; WizardContainer currentWizardContainer = GetWizardContainer(taskId, navigator); currentWizardContainer.Activate(viewName); }