/// <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);
}
