private void Initialize(string name) { Name = name; _settings = UIPConfiguration.Config.GetNavigationGraphSettings(name); ViewManager = CreateViewManager(name); _startView = UIPConfiguration.Config.GetFirstViewSettings(name); }
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 void ClosePreviousFormIfNecessary(WindowsFormView currentForm, string previousView, Guid taskId, ViewSettings currentViewSettings) { if (!currentViewSettings.IsFloatable) { if (null != previousView && 0 != previousView.Length) { //Get the current form ViewSettings previousViewSettings = UIPConfiguration.Config.GetViewSettingsFromName(previousView); if (previousViewSettings == null) { throw new UIPException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionViewConfigNotFound, previousView)); } WindowsFormView previousForm = (WindowsFormView)GetActiveForms(taskId)[previousView]; //if we end up staying with same form, we should not close it if (currentForm != null && previousForm != null && previousForm == currentForm) { return; } //if the current one is modal, we don't want to close the preivous view if (currentViewSettings.IsOpenModal && !previousViewSettings.IsOpenModal) { return; } if (previousForm != null && !previousViewSettings.IsStayOpen) { //The current window must be closed previousForm.Close(); } } } }
/// <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> /// Looks up the next view based on the incoming graph, view, and navigation values. /// </summary> /// <param name="navigationGraphName">Name of the navigation graph that is being worked in.</param> /// <param name="currentViewName">Name of the current view.</param> /// <param name="navigateValue">Navigate value used to determine the next view to be navigated to from the current view.</param> public virtual ViewSettings GetNextViewSettings(string navigationGraphName, string currentViewName, string navigateValue) { //Retrieve a navgraph class based on nav name NavigationGraphSettings navigationGraph = GetNavigationGraphSettings(navigationGraphName); ViewSettings nextView = null; // Get the current view node settings NodeSettings node = navigationGraph[currentViewName]; if (null == node) { throw new ConfigurationException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionCouldNotGetNextViewType, navigationGraphName, currentViewName, navigateValue)); } // Get the next view name from the navigateTo node NavigateToSettings navigateTo = node[navigateValue]; if (null == navigateTo) { nextView = GetSharedTransitionView(navigationGraph, navigateValue); } else { nextView = GetViewSettingsFromName(navigateTo.View); } if (nextView == null) { throw new ConfigurationException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionCouldNotGetNextViewType, navigationGraphName, currentViewName, navigateValue)); } return(nextView); }
/// <summary> /// Navigates to the next node in the navigation graph. /// </summary> /// <param name="nextNode">The next node.</param> public override void Navigate(string nextNode) { string previousView = CurrentState.CurrentView; CurrentState.NavigateValue = nextNode; UIPManager.InvokeEventHandlers(CurrentState); ViewSettings nextView = UIPConfiguration.Config.GetNextViewSettings( Name, CurrentState.CurrentView, CurrentState.NavigateValue); CurrentState.CurrentView = nextView.Name; CurrentState.NavigateValue = ""; CurrentState.Save(); try { ActivateNextView(previousView, CurrentState.CurrentView); } catch (System.Threading.ThreadAbortException) {} catch (Exception ex) { throw new UIPException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionCantActivateView, nextView.Name) + UIPException.GetFirstExceptionMessage(ex), ex); } }
private void LayoutControlsIfRequired(ViewSettings viewSettings, WindowsFormView winFormView) { ILayoutManager layoutManager = LayoutManagerFactory.Create(viewSettings.Name); if (layoutManager != null) { layoutManager.LayoutControls(winFormView); } }
private void SetWinFormControlInternals(WindowsFormControlView control, ViewSettings viewSettings, Navigator navigator) { if (control != null) { control.InternalNavigator = navigator; control.InternalNavigationGraph = navigator.Name; control.InternalViewName = viewSettings.Name; } }
private void SetWinFormInternals(WindowsFormView view, ViewSettings viewSettings, Navigator navigator) { if (view != null) { view.InternalNavigator = navigator; view.InternalNavigationGraph = navigator.Name; view.InternalViewName = viewSettings.Name; } }
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); }
/// <summary> /// Gets the settings of the controller object used by the specified view. /// </summary> /// <param name="viewName">The name of the view to retrieve the controller settings for.</param> public virtual ObjectTypeSettings GetControllerSettings(string viewName) { ViewSettings viewSettings = GetViewSettingsFromName(viewName); if (viewSettings == null) { throw new UIPException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionViewConfigNotFound, viewName)); } return((ObjectTypeSettings)_controllerCollection[viewSettings.Controller]); }
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> /// Finds the view setting for a specified view type. /// </summary> /// <param name="viewType">The view type defined in the app.config.</param> /// <returns>The settings.</returns> public virtual ViewSettings GetViewSettingsFromType(string viewType) { ViewSettings viewForType = null; foreach (ViewSettings view in _viewByNameCollection.Values) { if (view.Type == viewType) { viewForType = view; break; } } return(viewForType); }
private void RedirectToNextView(string previousView, ViewSettings viewSettings) { try { if (previousView == null) { HttpContext.Current.Response.Redirect(HttpContext.Current.Request.ApplicationPath + "/" + viewSettings.Type, true); } else { HttpContext.Current.Response.Redirect(HttpContext.Current.Request.ApplicationPath + "/" + viewSettings.Type, false); } } catch (System.Threading.ThreadAbortException) {} }
/// <summary> /// A utility method that checks Web requests to ensure that the requested page and current view match. /// If a user bookmarks page D, then proceeds to page F, and then returns to the bookmark, the /// state, when loaded, will have F as the current view. /// Any submissions on page D will fail, because the navigation graph may not have appropriate view-navigateResult pairs. /// Therefore, you should code defensively against this. Check the current page, check the referring page, andc heck the state object's current view. /// </summary> /// <param name="view">The next view.</param> /// <param name="stateViewName">The view saved in the state.</param> /// <returns></returns> public bool IsRequestCurrentView(IView view, string stateViewName) { // get state currentview; must all match ViewSettings viewSettings = UIPConfiguration.Config.GetViewSettingsFromName(stateViewName); if (viewSettings == null) { throw new UIPException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionViewConfigNotFound, stateViewName)); } string stateViewType = viewSettings.Type; System.Web.UI.Page page = (System.Web.UI.Page)view; string viewType = page.Request.CurrentExecutionFilePath.Replace(page.Request.ApplicationPath + "/", ""); return(string.Compare(viewType, stateViewType, true, System.Globalization.CultureInfo.InvariantCulture) == 0); }
private void LoadViews(XmlNode configNode, IFormatProvider formatProvider) { ObjectTypeSettings typedObject; //Get the configured views foreach (XmlNode viewNode in configNode.SelectNodes(NodeViewXPath)) { typedObject = new ViewSettings(viewNode, formatProvider); if (!_viewByNameCollection.ContainsKey(typedObject.Name)) { _viewByNameCollection.Add(typedObject.Name, typedObject); } else { throw new UIPException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionViewSettingAlreadyConfigured, typedObject.Name)); } } }
/// <summary> /// Activates a specific view. /// </summary> /// <param name="previousView">The view actually displayed.</param> /// <param name="taskId">An existing task identifier (a GUID associated with the task).</param> /// <param name="navGraph">A configured navigation graph name.</param> /// <param name="view">The name of the view to be displayed.</param> public void ActivateView(string previousView, Guid taskId, string navGraph, string view) { // create a session moniker SessionMoniker sessionMoniker = new SessionMoniker(navGraph, view, taskId); // store the moniker into the session, so the next view can get the task information sessionMoniker.StoreInSession(); ViewSettings viewSettings = UIPConfiguration.Config.GetViewSettingsFromName(view); if (viewSettings == null) { throw new UIPException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionViewConfigNotFound, view)); } HttpContext.Current.Session[WebFormView.CurrentTaskKey] = taskId.ToString(); RedirectToNextView(previousView, viewSettings); }
private ViewSettings GetSharedTransitionView(NavigationGraphSettings navigationGraph, string navigateValue) { SharedTransitionSettings sharedTransition = null; ViewSettings sharedView = null; sharedTransition = navigationGraph.GetSharedTransitionSettings(navigateValue); if (null == sharedTransition) { sharedTransition = this.GetSharedTransitionSettings(navigateValue); } if (sharedTransition != null) { sharedView = GetViewSettingsFromName(sharedTransition.View); } return(sharedView); }
private void ShowModal(WindowsFormView winFormView, string previousView, Guid taskId, object parentForm) { if (previousView != null) { //Get the current form ViewSettings previousViewSettings = UIPConfiguration.Config.GetViewSettingsFromName(previousView); if (previousViewSettings == null) { throw new UIPException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionViewConfigNotFound, previousView)); } WindowsFormView previousForm = GetActiveForm(taskId, previousView); winFormView.ShowDialog((IWin32Window)previousForm); } else { //the previous view is unknown, so the first view of the navgraph is modal, // as a last resort we try to get the parentForm from our _properties. winFormView.ShowDialog((IWin32Window)parentForm); } }
/// <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 IView[] CreateViews(Navigator navigator) { IView[] results = new IView[_nodeSettings.Length]; int i = 0; foreach (NodeSettings node in _nodeSettings) { ViewSettings viewSettings = UIPConfiguration.Config.GetViewSettingsFromName(node.View); if (viewSettings == null) { throw new UIPException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionViewConfigNotFound, node.View)); } IView view = (IView)GenericFactory.Create(viewSettings); SetWinFormControlInternals(view as WindowsFormControlView, viewSettings, navigator); SetWinFormInternals(view as WindowsFormView, viewSettings, navigator); results[i++] = view; } return(results); }
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); } }
/// <summary> /// Gets the settings of the layout manager used by the specified view. /// </summary> /// <param name="viewName">The name of the view to retrieve layout manager settings for.</param> public virtual ObjectTypeSettings GetLayoutManagerSettings(string viewName) { ObjectTypeSettings layoutManagerSettings = null; ViewSettings viewSettings = GetViewSettingsFromName(viewName); if (viewSettings == null) { throw new UIPException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionViewConfigNotFound, viewName)); } if (ViewExpectsLayoutManager(viewSettings)) { layoutManagerSettings = (ObjectTypeSettings)_iLayoutManagerCollection[viewSettings.LayoutManager]; if (layoutManagerSettings == null) { throw new UIPException(Resource.ResourceManager.FormatMessage(Resource.Exceptions.RES_ExceptionLayoutManagerNotFound, viewSettings.LayoutManager)); } } return(layoutManagerSettings); }
private void InitializeChildren(Control container, Navigator navigator, Guid taskId) { foreach (Control control in container.Controls) { if (control is WindowsFormControlView) { WindowsFormControlView child = (WindowsFormControlView)control; child.InternalNavigator = navigator; child.InternalTaskId = taskId; string viewName = navigator.GetViewNameFromNodeName(child.Name); child.InternalViewName = viewName; ViewSettings viewSettings = UIPConfiguration.Config.GetViewSettingsFromName(viewName); AddActiveControl(taskId, child.Name, child); child.InternalController = navigator.GetController(child); child.Initialize(null, viewSettings); } if (control.Controls.Count > 0) { InitializeChildren(control, navigator, taskId); } } }
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> /// Returns true if a layout manager is expected. Returns false if no layout manager was specified for a particular view. /// </summary> /// <param name="viewSettings">The configuration of a specific view.</param> /// <returns></returns> private bool ViewExpectsLayoutManager(ViewSettings viewSettings) { return(viewSettings.LayoutManager != null && viewSettings.LayoutManager.Length > 0); }
/// <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) { }