Coverage Report

 /**
  * Copyright 2010 The Kuali Foundation Licensed under the
  * Educational Community License, Version 2.0 (the "License"); you may
  * not use this file except in compliance with the License. You may
  * obtain a copy of the License at
  *
  * http://www.osedu.org/licenses/ECL-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an "AS IS"
  * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  * or implied. See the License for the specific language governing
  * permissions and limitations under the License.
  */
 
 package org.kuali.student.common.ui.client.configurable.mvc;
 
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 
 import org.kuali.student.common.ui.client.configurable.mvc.layouts.MenuSectionController;
 import org.kuali.student.common.ui.client.configurable.mvc.layouts.TabMenuController;
 import org.kuali.student.common.ui.client.configurable.mvc.layouts.ViewLayoutController;
 import org.kuali.student.common.ui.client.configurable.mvc.sections.Section;
 import org.kuali.student.common.ui.client.configurable.mvc.views.SectionView;
 import org.kuali.student.common.ui.client.event.ActionEvent;
 import org.kuali.student.common.ui.client.event.SaveActionEvent;
 import org.kuali.student.common.ui.client.event.SectionUpdateEvent;
 import org.kuali.student.common.ui.client.event.SectionUpdateHandler;
 import org.kuali.student.common.ui.client.event.ValidateRequestEvent;
 import org.kuali.student.common.ui.client.event.ValidateRequestHandler;
 import org.kuali.student.common.ui.client.mvc.ActionCompleteCallback;
 import org.kuali.student.common.ui.client.mvc.Callback;
 import org.kuali.student.common.ui.client.mvc.Controller;
 import org.kuali.student.common.ui.client.mvc.DataModel;
 import org.kuali.student.common.ui.client.mvc.ModelRequestCallback;
 import org.kuali.student.common.ui.client.mvc.View;
 import org.kuali.student.common.ui.client.mvc.history.HistoryManager;
 import org.kuali.student.common.ui.client.widgets.KSButton;
 import org.kuali.student.common.ui.client.widgets.KSLightBox;
 import org.kuali.student.common.ui.client.widgets.field.layout.element.FieldElement;
 import org.kuali.student.common.validation.dto.ValidationResultInfo;
 import org.kuali.student.common.validation.dto.ValidationResultInfo.ErrorLevel;
 
 import com.google.gwt.core.client.GWT;
 import com.google.gwt.event.dom.client.ClickEvent;
 import com.google.gwt.event.dom.client.ClickHandler;
 import com.google.gwt.user.client.ui.FlowPanel;
 import com.google.gwt.user.client.ui.Widget;
 
 /**
  * The LayoutController is a central piece of the UIF.  This controller is also itself a view.
  * As such, LayoutControllers can also have other LayoutControllers as their views.  
  * 
  * @see Controller
  * @author Kuali Student Team
  *
  */
 public abstract class LayoutController extends Controller implements ViewLayoutController, View {
 
         protected Map<Enum<?>, View> viewMap = new LinkedHashMap<Enum<?>, View>();
         protected Map<String, Enum<?>> viewEnumMap = new HashMap<String, Enum<?>>();
         protected Enum<?> defaultView;
         
         protected String name;
         protected Enum<?> viewType;
 
     protected View startPopupView;
     protected KSLightBox startViewWindow;
         
     /**
      * Constructor
      * Sets up event handlers fro section update events and validation request events.
      */
     public LayoutController(){
         super();
         //Global section update Event handling
                 addApplicationEventHandler(SectionUpdateEvent.TYPE, new SectionUpdateHandler(){
 
                         @Override
                         public void onSectionUpdate(final SectionUpdateEvent event) {
                                 LayoutController.this.requestModel(new ModelRequestCallback<DataModel>(){
 
                                         @Override
                                         public void onRequestFail(Throwable cause) {
                                                 GWT.log("Unable to retrieve model for section update", cause);
                                         }
 
                                         @Override
                                         public void onModelReady(DataModel model) {
                                                 event.getSection().updateModel(model);
                                                 event.getSection().updateWidgetData(model);
                                                 
                                         }
                                 });
                                 
                         }
                 });
                 //Global validation Event handling
         addApplicationEventHandler(ValidateRequestEvent.TYPE, new ValidateRequestHandler() {
 
             @Override
             public void onValidateRequest(final ValidateRequestEvent event) {
                     FieldDescriptor originatingField = event.getFieldDescriptor();
                     String modelId = null;
                     if (originatingField != null) {
                             modelId = originatingField.getModelId();
                     }
                     if (modelId == null) {
                             requestModel(new ModelRequestCallback<DataModel>() {
                                     @Override
                                     public void onModelReady(DataModel model) {
                                             validate(model, event);
                                     }
 
                                     @Override
                                     public void onRequestFail(Throwable cause) {
                                             GWT.log("Unable to retrieve model for validation", cause);
                                     }
 
                             });
                     } else {
                             requestModel(modelId, new ModelRequestCallback<DataModel>() {
                                     @Override
                                     public void onModelReady(DataModel model) {
                                             validate(model, event);
                                     }
 
                                     @Override
                                     public void onRequestFail(Throwable cause) {
                                             GWT.log("Unable to retrieve model for validation", cause);
                                     }
 
                             });
                     }
             }
 
         });
     }
     
     private void validate(DataModel model, final ValidateRequestEvent event) {
             if(event.validateSingleField()){
                     model.validateField(event.getFieldDescriptor(), new Callback<List<ValidationResultInfo>>() {
                 @Override
                 public void exec(List<ValidationResultInfo> result) {
                         if(event.getFieldDescriptor() != null){
                                 //We dont need to traverse since it is single field, so don't do isValid call here
                                 //instead add the error messages directly
                                 FieldElement element = event.getFieldDescriptor().getFieldElement();
                                 if(element != null){
                                         element.clearValidationPanel();
                                         for(int i = 0; i < result.size(); i++){
                                             ValidationResultInfo vr = result.get(i);
                                             if(vr.getElement().equals(event.getFieldDescriptor().getFieldKey()) 
                                                             && event.getFieldDescriptor().hasHadFocus()){
                                                                     element.processValidationResult(vr);
                                             }
                                     }
                                 }
                         }
                         
                 }
                     });
             }
             else{
             model.validate(new Callback<List<ValidationResultInfo>>() {
                 @Override
                 public void exec(List<ValidationResultInfo> result) {
                     isValid(result, false, true);
                 }
             });
             }
     }
     
     /**
      * Check to see if the list of validation results have an error.
      * @param list
      * @return
      */
     public ErrorLevel checkForErrors(List<ValidationResultInfo> list){
                 ErrorLevel errorLevel = ErrorLevel.OK;
                 
                 for(ValidationResultInfo vr: list){
                         if(vr.getErrorLevel().getLevel() > errorLevel.getLevel()){
                                 errorLevel = vr.getErrorLevel();
                         }
                         if(errorLevel.equals(ErrorLevel.ERROR)){
                                 break;
                         }
                 }
             
             return errorLevel;
             
     }
     
     /**
      * Finds the first parent LayoutController of this LayoutController, returns null if this
      * is the top level LayoutController.
      * @param w
      * @return
      */
     public static LayoutController findParentLayout(Widget w){
         LayoutController result = null;
         while (true) {
             if (w == null) {
                 break;
             } else if (w instanceof HasLayoutController) {
                     result = ((HasLayoutController)w).getLayoutController();
                     if (result != null) {
                             break;
                     }
             } else if (w instanceof LayoutController) {
                 result = (LayoutController) w;
                 break;
             }
             w = w.getParent();
             
         }
         return result;
     }
     
         /**
          * @see org.kuali.student.common.ui.client.configurable.mvc.layouts.ViewLayoutController#addStartViewPopup(org.kuali.student.common.ui.client.mvc.View)
          */
         public void addStartViewPopup(final View view){
             startPopupView = view;
             if(startViewWindow == null){
                     startViewWindow = new KSLightBox();
             }
 
             FlowPanel panel = new FlowPanel();
             panel.add(view.asWidget());
             KSButton save = new KSButton("Save",new ClickHandler(){
             public void onClick(ClickEvent event) {
                 view.updateModel();
                 SaveActionEvent saveActionEvent = new SaveActionEvent(true);
 
                 saveActionEvent.setActionCompleteCallback(new ActionCompleteCallback(){
                     public void onActionComplete(ActionEvent action) {
                         startViewWindow.hide();
                     }
                 });
                 
 
                 fireApplicationEvent(saveActionEvent);
             }
             });
             startViewWindow.addButton(save);
             
             KSButton cancel = new KSButton("Cancel", new ClickHandler(){
             public void onClick(ClickEvent event) {
                 startViewWindow.hide();
             }
             });
             startViewWindow.addButton(cancel);
 
             if(view instanceof SectionView){
                     ((SectionView) view).setController(this);
             }
             startViewWindow.setWidget(panel);
         }
         
     /**
      * @return true if the start popup is showing
      */
     public boolean isStartViewShowing(){
         if(startViewWindow == null){
             return false;
         }
             return startViewWindow.isShowing();
     }
 
     public View getStartPopupView(){
         return startPopupView;
     }
     
     public void showStartPopup(final Callback<Boolean> onReadyCallback){
         startPopupView.beforeShow(new Callback<Boolean>() {
                         @Override
                         public void exec(Boolean result) {
                                 if (result) {
                                         startViewWindow.show();
                                 }
                                 onReadyCallback.exec(result);
                         }
         });
     }
     
     public KSLightBox getStartPopup(){
         return startViewWindow;
     }
 
 
     /*New methods*/
         
         /**
          * @see org.kuali.student.common.ui.client.configurable.mvc.layouts.ViewLayoutController#addView(org.kuali.student.common.ui.client.mvc.View)
          */
         public void addView(View view){
                 viewMap.put(view.getViewEnum(), view);
                 viewEnumMap.put(view.getViewEnum().toString(), view.getViewEnum());
                 if(view instanceof SectionView){
                         ((SectionView) view).setController(this);
                 }
                 else if(view instanceof ToolView){
                         ((ToolView) view).setController(this);
                 }
         }
         
         /**
          * @see org.kuali.student.common.ui.client.configurable.mvc.layouts.ViewLayoutController#setDefaultView(java.lang.Enum)
          */
         public <V extends Enum<?>> void setDefaultView(V viewType){
                 this.defaultView = viewType;
         }
         
         public Enum<?> getDefaultView(){
                 return this.defaultView;
         }
         
         /**
          * @see org.kuali.student.common.ui.client.mvc.View#updateModel()
          */
         public abstract void updateModel();
         
         /**
          * Update the model with a single views information
          * @param viewType
          */
         public void updateModelFromView(Enum<?> viewType){
                 View v = viewMap.get(viewType);
                 if(v != null){
                         v.updateModel();
                 }
         }
         
         /**
          * Update a the model from the view that is currently being shown by this controller
          */
         public void updateModelFromCurrentView(){
         if(this.getCurrentView() != null){
                     this.getCurrentView().updateModel();
         }
         }
 
         @Override
         public <V extends Enum<?>> void getView(V viewType, Callback<View> callback) {
                 callback.exec(viewMap.get(viewType));
         }
 
         @Override
         public Enum<?> getViewEnumValue(String enumValue) {
                 return viewEnumMap.get(enumValue);
         }
 
         @Override
         public void showDefaultView(final Callback<Boolean> onReadyCallback) {
                 HistoryManager.setLogNavigationHistory(false);
                 //turn of history support for default showing until view is ready
                 if(defaultView != null){
                         showView(defaultView, onReadyCallback);
                 }
                 else if(!viewMap.isEmpty()){                
                         if(defaultView == null){
                                 showView(viewMap.entrySet().iterator().next().getKey(), onReadyCallback);
                         }        
                 }
                 
         }
         
         /**
          * Show the view that was the first one added and will likely be the first one in a layout's menu, for
          * example.  Note that this is different than show default view.
          * 
          * @param onReadyCallback
          */
         public void showFirstView(Callback<Boolean> onReadyCallback){
                 HistoryManager.setLogNavigationHistory(false);
                 if(!viewMap.isEmpty()){        
                         showView(viewMap.entrySet().iterator().next().getKey(), onReadyCallback);
                 }
                 else{
                         showDefaultView(onReadyCallback);
                 }
         }
         
         /**
           * Check to see if current/all section(s) is valid (ie. does not contain any errors) - also displays
           * them in the ui if possible
           *
          * @param validationResults List of validation results for the layouts model.
          * @param checkCurrentSectionOnly true if errors should be checked on current section only, false if all sections should be checked
          * @return true if the specified sections (all or current) has any validation errors
          */
         public boolean isValid(List<ValidationResultInfo> validationResults, boolean checkCurrentSectionOnly){
                 return isValid(validationResults, checkCurrentSectionOnly, true);
         }
         
         /**
          * @see LayoutController#isValid(List, boolean)
          * @param validationResults
          * @param checkCurrentSectionOnly
          * @param allFields
          * @return
          */
         public boolean isValid(List<ValidationResultInfo> validationResults, boolean checkCurrentSectionOnly, boolean allFields){
                 boolean isValid = true;
 
                 if (checkCurrentSectionOnly){
                         //Check for validation errors on the currently displayed section only
                     View v = getCurrentView();
                 if(v instanceof Section){
                         isValid = isValid(validationResults, (Section)v, allFields);
                     }
                      if(this.isStartViewShowing()){
                              if(startPopupView instanceof Section){
                                      isValid = isValid(validationResults, ((Section) startPopupView), allFields) && isValid;
                              }
                      }
                 } else {
                         //Check for validation errors on all sections
                         String errorSections = "";
                         StringBuilder errorSectionsbuffer = new StringBuilder();
                         errorSectionsbuffer.append(errorSections);
                         for (Entry<Enum<?>, View> entry:viewMap.entrySet()) {
                                 View v = entry.getValue();
                                 if (v instanceof Section){
                                         if (!isValid(validationResults, (Section)v, allFields)){
                                                 isValid = false;
                                                 errorSectionsbuffer.append(((SectionView)v).getName() + ", ");
                                         }
                                 }
                         }
                      if(this.isStartViewShowing()){
                              if(startPopupView instanceof Section){
                                      isValid = isValid(validationResults, ((Section) startPopupView), allFields) && isValid;
                              }
                      }
                         errorSections = errorSectionsbuffer.toString();
                         if (!errorSections.isEmpty()){
                                 errorSections = errorSections.substring(0, errorSections.length()-2);
                                 //container.addMessage("Following section(s) has errors & must be corrected: " + errorSections);
                         }
                 }
 
                 return isValid;
         }
 
         private boolean isValid(List<ValidationResultInfo> validationResults, Section section, boolean allFields){
                 ErrorLevel status;
                 if(allFields){
                         section.setFieldHasHadFocusFlags(true);
                         status = section.processValidationResults(validationResults);
                 }
                 else{
                         status = section.processValidationResults(validationResults, false);
                 }
 
                 return (status != ErrorLevel.ERROR);
         }
         
         /**
          * This particular implementation of beforeViewChange checks to see if all its view contains a Controller
          * and if it does checks with that controller to see if it is ok to change the view.  OkToChange callback
          * will be exec with true if the view is allowed to be changed at this time.  This method can be overriden
          * to provide additional functionality to stop a view from being changed when there is some additional
          * processing that needs to occur in the ui before the view changes.
          * 
          * @see org.kuali.student.common.ui.client.mvc.Controller#beforeViewChange(java.lang.Enum, org.kuali.student.common.ui.client.mvc.Callback)
          */
         @Override
         public void beforeViewChange(Enum<?> viewChangingTo, Callback<Boolean> okToChange) {
             
             if(this.getCurrentView() instanceof Controller){
                         ((Controller)this.getCurrentView()).beforeViewChange(viewChangingTo, okToChange);
             }
                 else{
                         okToChange.exec(true);
                 }
         if(this instanceof MenuSectionController){
             ((MenuSectionController)this).showExport(isExportButtonActive());
         } else if(this instanceof TabMenuController){
             ((TabMenuController)this).showExport(isExportButtonActive());
         }
 
         }
 
         @Override
         public Widget asWidget() {
                 return this;
         }
 
         @Override
         public boolean beforeHide() {
                 return true;
         }
 
         /**
          * Default implementation does nothing on before show.  Override to do other things before THIS view is
          * shown.
          * @see org.kuali.student.common.ui.client.mvc.View#beforeShow(org.kuali.student.common.ui.client.mvc.Callback)
          */
         @Override
         public void beforeShow(Callback<Boolean> onReadyCallback) {
                 onReadyCallback.exec(true);
         }
 
         @Override
         public Controller getController() {
                 return parentController;
         }
 
         @Override
         public String getName() {
                 if(name == null && viewType != null){
                         return viewType.toString();
                 }
                 else{
                         return name;
                 }
         }
 
         @Override
         public Enum<?> getViewEnum() {
                 return viewType;
         }
         
         public void setViewEnum(Enum<?> viewType){
                 this.viewType= viewType;
         }
         
         /**
          * Sets the name of this LayoutController.  This name is used in the breadcrumb and window's title.
          * Setting the name to the empty string will omit the breadcrumb - this is sometimes desired.
          * @param name
          */
         public void setName(String name){
                 this.name = name;
         }
         
         public void setController(Controller controller){
                 parentController = controller;
         }
         
         @Override
         public void collectBreadcrumbNames(List<String> names) {
                 names.add(this.getName());
                 if(this.getCurrentView() != null){
                         this.getCurrentView().collectBreadcrumbNames(names);
                 }
         }
         
         @Override
         public void clear() {
                 
         }
 
         public boolean isExportButtonActive() {
             return false;
         }
 }

1		/**
2		* Copyright 2010 The Kuali Foundation Licensed under the
3		* Educational Community License, Version 2.0 (the "License"); you may
4		* not use this file except in compliance with the License. You may
5		* obtain a copy of the License at
6		*
7		* http://www.osedu.org/licenses/ECL-2.0
8		*
9		* Unless required by applicable law or agreed to in writing,
10		* software distributed under the License is distributed on an "AS IS"
11		* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
12		* or implied. See the License for the specific language governing
13		* permissions and limitations under the License.
14		*/
15
16		package org.kuali.student.common.ui.client.configurable.mvc;
17
18		import java.util.HashMap;
19		import java.util.LinkedHashMap;
20		import java.util.List;
21		import java.util.Map;
22		import java.util.Map.Entry;
23
24		import org.kuali.student.common.ui.client.configurable.mvc.layouts.MenuSectionController;
25		import org.kuali.student.common.ui.client.configurable.mvc.layouts.TabMenuController;
26		import org.kuali.student.common.ui.client.configurable.mvc.layouts.ViewLayoutController;
27		import org.kuali.student.common.ui.client.configurable.mvc.sections.Section;
28		import org.kuali.student.common.ui.client.configurable.mvc.views.SectionView;
29		import org.kuali.student.common.ui.client.event.ActionEvent;
30		import org.kuali.student.common.ui.client.event.SaveActionEvent;
31		import org.kuali.student.common.ui.client.event.SectionUpdateEvent;
32		import org.kuali.student.common.ui.client.event.SectionUpdateHandler;
33		import org.kuali.student.common.ui.client.event.ValidateRequestEvent;
34		import org.kuali.student.common.ui.client.event.ValidateRequestHandler;
35		import org.kuali.student.common.ui.client.mvc.ActionCompleteCallback;
36		import org.kuali.student.common.ui.client.mvc.Callback;
37		import org.kuali.student.common.ui.client.mvc.Controller;
38		import org.kuali.student.common.ui.client.mvc.DataModel;
39		import org.kuali.student.common.ui.client.mvc.ModelRequestCallback;
40		import org.kuali.student.common.ui.client.mvc.View;
41		import org.kuali.student.common.ui.client.mvc.history.HistoryManager;
42		import org.kuali.student.common.ui.client.widgets.KSButton;
43		import org.kuali.student.common.ui.client.widgets.KSLightBox;
44		import org.kuali.student.common.ui.client.widgets.field.layout.element.FieldElement;
45		import org.kuali.student.common.validation.dto.ValidationResultInfo;
46		import org.kuali.student.common.validation.dto.ValidationResultInfo.ErrorLevel;
47
48		import com.google.gwt.core.client.GWT;
49		import com.google.gwt.event.dom.client.ClickEvent;
50		import com.google.gwt.event.dom.client.ClickHandler;
51		import com.google.gwt.user.client.ui.FlowPanel;
52		import com.google.gwt.user.client.ui.Widget;
53
54		/**
55		* The LayoutController is a central piece of the UIF. This controller is also itself a view.
56		* As such, LayoutControllers can also have other LayoutControllers as their views.
57		*
58		* @see Controller
59		* @author Kuali Student Team
60		*
61		*/
62	0	public abstract class LayoutController extends Controller implements ViewLayoutController, View {
63
64	0	protected Map<Enum<?>, View> viewMap = new LinkedHashMap<Enum<?>, View>();
65	0	protected Map<String, Enum<?>> viewEnumMap = new HashMap<String, Enum<?>>();
66		protected Enum<?> defaultView;
67
68		protected String name;
69		protected Enum<?> viewType;
70
71		protected View startPopupView;
72		protected KSLightBox startViewWindow;
73
74		/**
75		* Constructor
76		* Sets up event handlers fro section update events and validation request events.
77		*/
78		public LayoutController(){
79	0	super();
80		//Global section update Event handling
81	0	addApplicationEventHandler(SectionUpdateEvent.TYPE, new SectionUpdateHandler(){
82
83		@Override
84		public void onSectionUpdate(final SectionUpdateEvent event) {
85	0	LayoutController.this.requestModel(new ModelRequestCallback<DataModel>(){
86
87		@Override
88		public void onRequestFail(Throwable cause) {
89	0	GWT.log("Unable to retrieve model for section update", cause);
90	0	}
91
92		@Override
93		public void onModelReady(DataModel model) {
94	0	event.getSection().updateModel(model);
95	0	event.getSection().updateWidgetData(model);
96
97	0	}
98		});
99
100	0	}
101		});
102		//Global validation Event handling
103	0	addApplicationEventHandler(ValidateRequestEvent.TYPE, new ValidateRequestHandler() {
104
105		@Override
106		public void onValidateRequest(final ValidateRequestEvent event) {
107	0	FieldDescriptor originatingField = event.getFieldDescriptor();
108	0	String modelId = null;
109	0	if (originatingField != null) {
110	0	modelId = originatingField.getModelId();
111		}
112	0	if (modelId == null) {
113	0	requestModel(new ModelRequestCallback<DataModel>() {
114		@Override
115		public void onModelReady(DataModel model) {
116	0	validate(model, event);
117	0	}
118
119		@Override
120		public void onRequestFail(Throwable cause) {
121	0	GWT.log("Unable to retrieve model for validation", cause);
122	0	}
123
124		});
125		} else {
126	0	requestModel(modelId, new ModelRequestCallback<DataModel>() {
127		@Override
128		public void onModelReady(DataModel model) {
129	0	validate(model, event);
130	0	}
131
132		@Override
133		public void onRequestFail(Throwable cause) {
134	0	GWT.log("Unable to retrieve model for validation", cause);
135	0	}
136
137		});
138		}
139	0	}
140
141		});
142	0	}
143
144		private void validate(DataModel model, final ValidateRequestEvent event) {
145	0	if(event.validateSingleField()){
146	0	model.validateField(event.getFieldDescriptor(), new Callback<List<ValidationResultInfo>>() {
147		@Override
148		public void exec(List<ValidationResultInfo> result) {
149	0	if(event.getFieldDescriptor() != null){
150		//We dont need to traverse since it is single field, so don't do isValid call here
151		//instead add the error messages directly
152	0	FieldElement element = event.getFieldDescriptor().getFieldElement();
153	0	if(element != null){
154	0	element.clearValidationPanel();
155	0	for(int i = 0; i < result.size(); i++){
156	0	ValidationResultInfo vr = result.get(i);
157	0	if(vr.getElement().equals(event.getFieldDescriptor().getFieldKey())
158		&& event.getFieldDescriptor().hasHadFocus()){
159	0	element.processValidationResult(vr);
160		}
161		}
162		}
163		}
164
165	0	}
166		});
167		}
168		else{
169	0	model.validate(new Callback<List<ValidationResultInfo>>() {
170		@Override
171		public void exec(List<ValidationResultInfo> result) {
172	0	isValid(result, false, true);
173	0	}
174		});
175		}
176	0	}
177
178		/**
179		* Check to see if the list of validation results have an error.
180		* @param list
181		* @return
182		*/
183		public ErrorLevel checkForErrors(List<ValidationResultInfo> list){
184	0	ErrorLevel errorLevel = ErrorLevel.OK;
185
186	0	for(ValidationResultInfo vr: list){
187	0	if(vr.getErrorLevel().getLevel() > errorLevel.getLevel()){
188	0	errorLevel = vr.getErrorLevel();
189		}
190	0	if(errorLevel.equals(ErrorLevel.ERROR)){
191	0	break;
192		}
193		}
194
195	0	return errorLevel;
196
197		}
198
199		/**
200		* Finds the first parent LayoutController of this LayoutController, returns null if this
201		* is the top level LayoutController.
202		* @param w
203		* @return
204		*/
205		public static LayoutController findParentLayout(Widget w){
206	0	LayoutController result = null;
207		while (true) {
208	0	if (w == null) {
209	0	break;
210	0	} else if (w instanceof HasLayoutController) {
211	0	result = ((HasLayoutController)w).getLayoutController();
212	0	if (result != null) {
213	0	break;
214		}
215	0	} else if (w instanceof LayoutController) {
216	0	result = (LayoutController) w;
217	0	break;
218		}
219	0	w = w.getParent();
220
221		}
222	0	return result;
223		}
224
225		/**
226		* @see org.kuali.student.common.ui.client.configurable.mvc.layouts.ViewLayoutController#addStartViewPopup(org.kuali.student.common.ui.client.mvc.View)
227		*/
228		public void addStartViewPopup(final View view){
229	0	startPopupView = view;
230	0	if(startViewWindow == null){
231	0	startViewWindow = new KSLightBox();
232		}
233
234	0	FlowPanel panel = new FlowPanel();
235	0	panel.add(view.asWidget());
236	0	KSButton save = new KSButton("Save",new ClickHandler(){
237		public void onClick(ClickEvent event) {
238	0	view.updateModel();
239	0	SaveActionEvent saveActionEvent = new SaveActionEvent(true);
240
241	0	saveActionEvent.setActionCompleteCallback(new ActionCompleteCallback(){
242		public void onActionComplete(ActionEvent action) {
243	0	startViewWindow.hide();
244	0	}
245		});
246
247
248	0	fireApplicationEvent(saveActionEvent);
249	0	}
250		});
251	0	startViewWindow.addButton(save);
252
253	0	KSButton cancel = new KSButton("Cancel", new ClickHandler(){
254		public void onClick(ClickEvent event) {
255	0	startViewWindow.hide();
256	0	}
257		});
258	0	startViewWindow.addButton(cancel);
259
260	0	if(view instanceof SectionView){
261	0	((SectionView) view).setController(this);
262		}
263	0	startViewWindow.setWidget(panel);
264	0	}
265
266		/**
267		* @return true if the start popup is showing
268		*/
269		public boolean isStartViewShowing(){
270	0	if(startViewWindow == null){
271	0	return false;
272		}
273	0	return startViewWindow.isShowing();
274		}
275
276		public View getStartPopupView(){
277	0	return startPopupView;
278		}
279
280		public void showStartPopup(final Callback<Boolean> onReadyCallback){
281	0	startPopupView.beforeShow(new Callback<Boolean>() {
282		@Override
283		public void exec(Boolean result) {
284	0	if (result) {
285	0	startViewWindow.show();
286		}
287	0	onReadyCallback.exec(result);
288	0	}
289		});
290	0	}
291
292		public KSLightBox getStartPopup(){
293	0	return startViewWindow;
294		}
295
296
297		/New methods/
298
299		/**
300		* @see org.kuali.student.common.ui.client.configurable.mvc.layouts.ViewLayoutController#addView(org.kuali.student.common.ui.client.mvc.View)
301		*/
302		public void addView(View view){
303	0	viewMap.put(view.getViewEnum(), view);
304	0	viewEnumMap.put(view.getViewEnum().toString(), view.getViewEnum());
305	0	if(view instanceof SectionView){
306	0	((SectionView) view).setController(this);
307		}
308	0	else if(view instanceof ToolView){
309	0	((ToolView) view).setController(this);
310		}
311	0	}
312
313		/**
314		* @see org.kuali.student.common.ui.client.configurable.mvc.layouts.ViewLayoutController#setDefaultView(java.lang.Enum)
315		*/
316		public <V extends Enum<?>> void setDefaultView(V viewType){
317	0	this.defaultView = viewType;
318	0	}
319
320		public Enum<?> getDefaultView(){
321	0	return this.defaultView;
322		}
323
324		/**
325		* @see org.kuali.student.common.ui.client.mvc.View#updateModel()
326		*/
327		public abstract void updateModel();
328
329		/**
330		* Update the model with a single views information
331		* @param viewType
332		*/
333		public void updateModelFromView(Enum<?> viewType){
334	0	View v = viewMap.get(viewType);
335	0	if(v != null){
336	0	v.updateModel();
337		}
338	0	}
339
340		/**
341		* Update a the model from the view that is currently being shown by this controller
342		*/
343		public void updateModelFromCurrentView(){
344	0	if(this.getCurrentView() != null){
345	0	this.getCurrentView().updateModel();
346		}
347	0	}
348
349		@Override
350		public <V extends Enum<?>> void getView(V viewType, Callback<View> callback) {
351	0	callback.exec(viewMap.get(viewType));
352	0	}
353
354		@Override
355		public Enum<?> getViewEnumValue(String enumValue) {
356	0	return viewEnumMap.get(enumValue);
357		}
358
359		@Override
360		public void showDefaultView(final Callback<Boolean> onReadyCallback) {
361	0	HistoryManager.setLogNavigationHistory(false);
362		//turn of history support for default showing until view is ready
363	0	if(defaultView != null){
364	0	showView(defaultView, onReadyCallback);
365		}
366	0	else if(!viewMap.isEmpty()){
367	0	if(defaultView == null){
368	0	showView(viewMap.entrySet().iterator().next().getKey(), onReadyCallback);
369		}
370		}
371
372	0	}
373
374		/**
375		* Show the view that was the first one added and will likely be the first one in a layout's menu, for
376		* example. Note that this is different than show default view.
377		*
378		* @param onReadyCallback
379		*/
380		public void showFirstView(Callback<Boolean> onReadyCallback){
381	0	HistoryManager.setLogNavigationHistory(false);
382	0	if(!viewMap.isEmpty()){
383	0	showView(viewMap.entrySet().iterator().next().getKey(), onReadyCallback);
384		}
385		else{
386	0	showDefaultView(onReadyCallback);
387		}
388	0	}
389
390		/**
391		* Check to see if current/all section(s) is valid (ie. does not contain any errors) - also displays
392		* them in the ui if possible
393		*
394		* @param validationResults List of validation results for the layouts model.
395		* @param checkCurrentSectionOnly true if errors should be checked on current section only, false if all sections should be checked
396		* @return true if the specified sections (all or current) has any validation errors
397		*/
398		public boolean isValid(List<ValidationResultInfo> validationResults, boolean checkCurrentSectionOnly){
399	0	return isValid(validationResults, checkCurrentSectionOnly, true);
400		}
401
402		/**
403		* @see LayoutController#isValid(List, boolean)
404		* @param validationResults
405		* @param checkCurrentSectionOnly
406		* @param allFields
407		* @return
408		*/
409		public boolean isValid(List<ValidationResultInfo> validationResults, boolean checkCurrentSectionOnly, boolean allFields){
410	0	boolean isValid = true;
411
412	0	if (checkCurrentSectionOnly){
413		//Check for validation errors on the currently displayed section only
414	0	View v = getCurrentView();
415	0	if(v instanceof Section){
416	0	isValid = isValid(validationResults, (Section)v, allFields);
417		}
418	0	if(this.isStartViewShowing()){
419	0	if(startPopupView instanceof Section){
420	0	isValid = isValid(validationResults, ((Section) startPopupView), allFields) && isValid;
421		}
422		}
423	0	} else {
424		//Check for validation errors on all sections
425	0	String errorSections = "";
426	0	StringBuilder errorSectionsbuffer = new StringBuilder();
427	0	errorSectionsbuffer.append(errorSections);
428	0	for (Entry<Enum<?>, View> entry:viewMap.entrySet()) {
429	0	View v = entry.getValue();
430	0	if (v instanceof Section){
431	0	if (!isValid(validationResults, (Section)v, allFields)){
432	0	isValid = false;
433	0	errorSectionsbuffer.append(((SectionView)v).getName() + ", ");
434		}
435		}
436	0	}
437	0	if(this.isStartViewShowing()){
438	0	if(startPopupView instanceof Section){
439	0	isValid = isValid(validationResults, ((Section) startPopupView), allFields) && isValid;
440		}
441		}
442	0	errorSections = errorSectionsbuffer.toString();
443	0	if (!errorSections.isEmpty()){
444	0	errorSections = errorSections.substring(0, errorSections.length()-2);
445		//container.addMessage("Following section(s) has errors & must be corrected: " + errorSections);
446		}
447		}
448
449	0	return isValid;
450		}
451
452		private boolean isValid(List<ValidationResultInfo> validationResults, Section section, boolean allFields){
453		ErrorLevel status;
454	0	if(allFields){
455	0	section.setFieldHasHadFocusFlags(true);
456	0	status = section.processValidationResults(validationResults);
457		}
458		else{
459	0	status = section.processValidationResults(validationResults, false);
460		}
461
462	0	return (status != ErrorLevel.ERROR);
463		}
464
465		/**
466		* This particular implementation of beforeViewChange checks to see if all its view contains a Controller
467		* and if it does checks with that controller to see if it is ok to change the view. OkToChange callback
468		* will be exec with true if the view is allowed to be changed at this time. This method can be overriden
469		* to provide additional functionality to stop a view from being changed when there is some additional
470		* processing that needs to occur in the ui before the view changes.
471		*
472		* @see org.kuali.student.common.ui.client.mvc.Controller#beforeViewChange(java.lang.Enum, org.kuali.student.common.ui.client.mvc.Callback)
473		*/
474		@Override
475		public void beforeViewChange(Enum<?> viewChangingTo, Callback<Boolean> okToChange) {
476
477	0	if(this.getCurrentView() instanceof Controller){
478	0	((Controller)this.getCurrentView()).beforeViewChange(viewChangingTo, okToChange);
479		}
480		else{
481	0	okToChange.exec(true);
482		}
483	0	if(this instanceof MenuSectionController){
484	0	((MenuSectionController)this).showExport(isExportButtonActive());
485	0	} else if(this instanceof TabMenuController){
486	0	((TabMenuController)this).showExport(isExportButtonActive());
487		}
488
489	0	}
490
491		@Override
492		public Widget asWidget() {
493	0	return this;
494		}
495
496		@Override
497		public boolean beforeHide() {
498	0	return true;
499		}
500
501		/**
502		* Default implementation does nothing on before show. Override to do other things before THIS view is
503		* shown.
504		* @see org.kuali.student.common.ui.client.mvc.View#beforeShow(org.kuali.student.common.ui.client.mvc.Callback)
505		*/
506		@Override
507		public void beforeShow(Callback<Boolean> onReadyCallback) {
508	0	onReadyCallback.exec(true);
509	0	}
510
511		@Override
512		public Controller getController() {
513	0	return parentController;
514		}
515
516		@Override
517		public String getName() {
518	0	if(name == null && viewType != null){
519	0	return viewType.toString();
520		}
521		else{
522	0	return name;
523		}
524		}
525
526		@Override
527		public Enum<?> getViewEnum() {
528	0	return viewType;
529		}
530
531		public void setViewEnum(Enum<?> viewType){
532	0	this.viewType= viewType;
533	0	}
534
535		/**
536		* Sets the name of this LayoutController. This name is used in the breadcrumb and window's title.
537		* Setting the name to the empty string will omit the breadcrumb - this is sometimes desired.
538		* @param name
539		*/
540		public void setName(String name){
541	0	this.name = name;
542	0	}
543
544		public void setController(Controller controller){
545	0	parentController = controller;
546	0	}
547
548		@Override
549		public void collectBreadcrumbNames(List<String> names) {
550	0	names.add(this.getName());
551	0	if(this.getCurrentView() != null){
552	0	this.getCurrentView().collectBreadcrumbNames(names);
553		}
554	0	}
555
556		@Override
557		public void clear() {
558
559	0	}
560
561		public boolean isExportButtonActive() {
562	0	return false;
563		}
564		}