/**

  * Copyright 2005-2011 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.opensource.org/licenses/ecl2.php

  *

  * 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.rice.krad.uif.view;

 import org.apache.commons.lang.StringUtils;

 import org.kuali.rice.krad.uif.UifConstants;

 import org.kuali.rice.krad.uif.UifConstants.ViewStatus;

 import org.kuali.rice.krad.uif.UifConstants.ViewType;

 import org.kuali.rice.krad.uif.authorization.Authorizer;

 import org.kuali.rice.krad.uif.authorization.PresentationController;

 import org.kuali.rice.krad.uif.container.Container;

 import org.kuali.rice.krad.uif.container.ContainerBase;

 import org.kuali.rice.krad.uif.container.Group;

 import org.kuali.rice.krad.uif.container.NavigationGroup;

 import org.kuali.rice.krad.uif.container.PageGroup;

 import org.kuali.rice.krad.uif.component.BindingInfo;

 import org.kuali.rice.krad.uif.component.Component;

 import org.kuali.rice.krad.uif.component.ReferenceCopy;

 import org.kuali.rice.krad.uif.component.RequestParameter;

 import org.kuali.rice.krad.uif.field.HeaderField;

 import org.kuali.rice.krad.uif.field.LinkField;

 import org.kuali.rice.krad.uif.layout.LayoutManager;

 import org.kuali.rice.krad.uif.service.ViewHelperService;

 import org.kuali.rice.krad.uif.util.BooleanMap;

 import org.kuali.rice.krad.uif.util.ClientValidationUtils;

 import org.kuali.rice.krad.uif.widget.BreadCrumbs;

 import org.kuali.rice.krad.uif.widget.Growls;

 import org.kuali.rice.krad.util.ObjectUtils;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 /**

  * Root of the component tree which encompasses a set of related

  * <code>GroupContainer</code> instances tied together with a common page layout

  * and navigation.

  *

  * <p>

  * The <code>View</code> component ties together all the components and

  * configuration of the User Interface for a piece of functionality. In Rice

  * applications the view is typically associated with a <code>Document</code>

  * instance.

  * </p>

  *

  * <p>

  * The view template lays out the common header, footer, and navigation for the

  * related pages. In addition the view renders the HTML head element bringing in

  * common script files and style sheets, along with optionally rendering a form

  * element for pages that need to post data back to the server.

  * </p>

  *

  * <p>

  * Configuration of UIF features such as model validation is also done through

  * the <code>View</code>

  * </p>

  *

  * @author Kuali Rice Team (rice.collab@kuali.org)

  */

 public class View extends ContainerBase {

     private static final long serialVersionUID = -1220009725554576953L;

     private String viewName;

     private int idSequence;

     // application

     private HeaderField applicationHeader;

     private Group applicationFooter;

     // Breadcrumbs

     private BreadCrumbs breadcrumbs;

     private String viewLabelFieldPropertyName;

     private String appendOption;

     private boolean breadcrumbsInApplicationHeader;

     // Growls support

     private Growls growls;

     private boolean growlMessagingEnabled;

     private String entryPageId;

     @RequestParameter

     private String currentPageId;

     private NavigationGroup navigation;

     private Class<?> formClass;

     private String defaultBindingObjectPath;

     private Map<String, Class<?>> abstractTypeClasses;

     private List<String> additionalScriptFiles;

     private List<String> additionalCssFiles;

     private ViewType viewTypeName;

     private Class<? extends ViewHelperService> viewHelperServiceClassName;

     private String viewStatus;

     private ViewIndex viewIndex;

     private Map<String, String> viewRequestParameters;

     private Class<? extends PresentationController> presentationControllerClass;

     private Class<? extends Authorizer> authorizerClass;

     private BooleanMap actionFlags;

     private BooleanMap editModes;

     private Map<String, String> expressionVariables;

     private boolean singlePageView;

     private PageGroup page;

     private List<? extends Group> items;

     private LinkField viewMenuLink;

     private String viewMenuGrouping;

     private boolean validateDirty;

     private boolean translateCodes;

     private String preLoadScript;

     private Map<String, Object> clientSideState;

     private boolean supportsReadOnlyFieldsOverride;

     @RequestParameter

     private boolean dialogMode;

     @ReferenceCopy

     private ViewHelperService viewHelperService;

     public View() {

         dialogMode = false;

         singlePageView = false;

         translateCodes = false;

         viewTypeName = ViewType.DEFAULT;

         viewStatus = UifConstants.ViewStatus.CREATED;

         breadcrumbsInApplicationHeader = false;

         supportsReadOnlyFieldsOverride = true;

         idSequence = 0;

         this.viewIndex = new ViewIndex();

         additionalScriptFiles = new ArrayList<String>();

         additionalCssFiles = new ArrayList<String>();

         items = new ArrayList<Group>();

         abstractTypeClasses = new HashMap<String, Class<?>>();

         viewRequestParameters = new HashMap<String, String>();

         expressionVariables = new HashMap<String, String>();

         clientSideState = new HashMap<String, Object>();

     }

     /**

      * The following initialization is performed:

      *

      * <ul>

      * <li>If a single paged view, set items in page group and put the page in

      * the items list</li>

      * </ul>

      *

      * @see org.kuali.rice.krad.uif.container.ContainerBase#performInitialization(View, java.lang.Object)

      */

     @SuppressWarnings("unchecked")

     @Override

     public void performInitialization(View view, Object model) {

         super.performInitialization(view, model);

         // populate items on page for single paged view

         if (singlePageView) {

             if (page != null) {

                 page.setItems(new ArrayList<Group>(items));

                 // reset the items list to include the one page

                 items = new ArrayList<Group>();

                 ((List<Group>) items).add(page);

             } else {

                 throw new RuntimeException("For single paged views the page Group must be set.");

             }

         }

         // make sure all the pages have ids before selecting the current page

         for (Group group : this.getItems()) {

             if (StringUtils.isBlank(group.getId())) {

                 group.setId(view.getNextId());

             }

         }

     }

     /**

      * The following is performed:

      *

      * <ul>

      * <li>Adds to its document ready script the setupValidator js function for setting

      * up the validator for this view</li>

      * </ul>

      *

      * @see org.kuali.rice.krad.uif.container.ContainerBase#performFinalize(View,

      *      java.lang.Object, org.kuali.rice.krad.uif.component.Component)

      */

     @Override

     public void performFinalize(View view, Object model, Component parent) {

         super.performFinalize(view, model, parent);

         String prefixScript = "";

         if (this.getOnDocumentReadyScript() != null) {

             prefixScript = this.getOnDocumentReadyScript();

         }

         this.setOnDocumentReadyScript(prefixScript + "jQuery.extend(jQuery.validator.messages, " +

                 ClientValidationUtils.generateValidatorMessagesOption() + ");");

     }

     /**

      * Assigns an id to the component if one was not configured

      *

      * @param component - component instance to assign id to

      */

     public void assignComponentIds(Component component) {

         if (component == null) {

             return;

         }

         // assign IDs if necessary

         if (StringUtils.isBlank(component.getId())) {

             component.setId(getNextId());

         }

         if (StringUtils.isBlank(component.getFactoryId())) {

             component.setFactoryId(component.getId());

         }

         if (component instanceof Container) {

             LayoutManager layoutManager = ((Container) component).getLayoutManager();

             if ((layoutManager != null) && StringUtils.isBlank(layoutManager.getId())) {

                 layoutManager.setId(getNextId());

             }

         }

         // check if component has already been initialized to prevent cyclic references

         // TODO: move to VHS initialize

         //        if (initializedComponentIds.contains(component.getId())) {

         //            throw new RiceRuntimeException(

         //                    "Circular reference or duplicate id found for component with id: " + component.getId());

         //        }

         //        initializedComponentIds.add(component.getId());

         // assign id to nested components

         List<Component> allNested = new ArrayList<Component>(component.getComponentsForLifecycle());

         allNested.addAll(component.getComponentPrototypes());

         for (Component nestedComponent : allNested) {

             assignComponentIds(nestedComponent);

         }

     }

     /**

      * @see org.kuali.rice.krad.uif.component.ComponentBase#getComponentsForLifecycle()

      */

     @Override

     public List<Component> getComponentsForLifecycle() {

         List<Component> components = super.getComponentsForLifecycle();

         components.add(applicationHeader);

         components.add(applicationFooter);

         components.add(navigation);

         components.add(breadcrumbs);

         components.add(growls);

         components.add(viewMenuLink);

         // remove all pages that are not the current page

         if (!singlePageView) {

             for (Group group : this.getItems()) {

                 if ((group instanceof PageGroup) && !StringUtils.equals(group.getId(), getCurrentPageId()) && components

                         .contains(group)) {

                     components.remove(group);

                 }

             }

         }

         return components;

     }

     /**

      * @see org.kuali.rice.krad.uif.component.Component#getComponentPrototypes()

      */

     @Override

     public List<Component> getComponentPrototypes() {

         List<Component> components = super.getComponentPrototypes();

         components.add(page);

         return components;

     }

     /**

      * @see org.kuali.rice.krad.uif.container.Container#getSupportedComponents()

      */

     @Override

     public Set<Class<? extends Component>> getSupportedComponents() {

         Set<Class<? extends Component>> supportedComponents = new HashSet<Class<? extends Component>>();

         supportedComponents.add(Group.class);

         return supportedComponents;

     }

     /**

      * @see org.kuali.rice.krad.uif.component.Component#getComponentTypeName()

      */

     @Override

     public String getComponentTypeName() {

         return "view";

     }

     /**

      * Iterates through the contained page items and returns the Page that

      * matches the set current page id

      *

      * @return Page instance

      */

     public PageGroup getCurrentPage() {

         for (Group pageGroup : this.getItems()) {

             if (StringUtils.equals(pageGroup.getId(), getCurrentPageId()) && pageGroup instanceof PageGroup) {

                 return (PageGroup) pageGroup;

             }

         }

         return null;

     }

     /**

      * View name provides an identifier for a view within a type. That is if a

      * set of <code>View</code> instances have the same values for the

      * properties that are used to retrieve them by their type, the name can be

      * given to further qualify the view that should be retrieved.

      * <p>

      * A view type like the <code>LookupView</code> might have several views for

      * the same object class, but one that is the 'default' lookup and another

      * that is the 'advanced' lookup. Therefore the name on the first could be

      * set to 'default', and likewise the name for the second 'advanced'.

      * </p>

      *

      * @return String name of view

      */

     public String getViewName() {

         return this.viewName;

     }

     /**

      * Setter for the view's name

      *

      * @param viewName

      */

     public void setViewName(String viewName) {

         this.viewName = viewName;

     }

     /**

      * Header for the application containing the view

      *

      * <p>

      * When deploying outside a portal, the application header and footer property can be configured to

      * display a consistent header/footer across all views. Here application logos, menus, login controls

      * and so on can be rendered.

      * </p>

      *

      * @return HeaderField application header

      */

     public HeaderField getApplicationHeader() {

         return applicationHeader;

     }

     /**

      * Setter for the application header

      *

      * @param applicationHeader

      */

     public void setApplicationHeader(HeaderField applicationHeader) {

         this.applicationHeader = applicationHeader;

     }

     /**

      * Footer for the application containing the view

      *

      * <p>

      * When deploying outside a portal, the application header and footer property can be configured to

      * display a consistent header/footer across all views. Here such things as application links, copyrights

      * and so on can be rendered.

      * </p>

      *

      * @return Group application footer

      */

     public Group getApplicationFooter() {

         return applicationFooter;

     }

     /**

      * Setter for the application footer

      *

      * @param applicationFooter

      */

     public void setApplicationFooter(Group applicationFooter) {

         this.applicationFooter = applicationFooter;

     }

     /**

      * Returns the next unique id available for components within the view instance

      *

      * @return String next id available

      */

     public String getNextId() {

         return Integer.toString(idSequence++);

     }

     /**

      * Specifies what page should be rendered by default. This is the page that

      * will be rendered when the <code>View</code> is first rendered or when the

      * current page is not set

      *

      * @return String id of the page to render by default

      */

     public String getEntryPageId() {

         return this.entryPageId;

     }

     /**

      * Setter for default Page id

      *

      * @param entryPageId

      */

     public void setEntryPageId(String entryPageId) {

         this.entryPageId = entryPageId;

     }

     /**

      * The id for the page within the view that should be displayed in the UI.

      * Other pages of the view will not be rendered

      *

      * <p>

      * If current page id is not set, it is set to the configured entry page or first item in list id

      * </p>

      *

      * @return String id of the page that should be displayed

      */

     public String getCurrentPageId() {

         // default current page if not set

         if (StringUtils.isBlank(currentPageId)) {

             if (StringUtils.isNotBlank(entryPageId)) {

                 currentPageId = entryPageId;

             } else if ((getItems() != null) && !getItems().isEmpty()) {

                 Group firstPageGroup = getItems().get(0);

                 currentPageId = firstPageGroup.getId();

             }

         }

         return this.currentPageId;

     }

     /**

      * Setter for the page id to display

      *

      * @param currentPageId

      */

     public void setCurrentPageId(String currentPageId) {

         this.currentPageId = currentPageId;

     }

     /**

      * <code>NavigationGroup</code> instance for the <code>View</code>

      * <p>

      * Provides configuration necessary to render the navigation. This includes

      * navigation items in addition to configuration for the navigation

      * renderer.

      * </p>

      *

      * @return NavigationGroup

      */

     public NavigationGroup getNavigation() {

         return this.navigation;

     }

     /**

      * Setter for the View's <code>NavigationGroup</code>

      *

      * @param navigation

      */

     public void setNavigation(NavigationGroup navigation) {

         this.navigation = navigation;

     }

     /**

      * Class of the Form that should be used with the <code>View</code>

      * instance. The form is the top level object for all the view's data and is

      * used to present and accept data in the user interface. All form classes

      * should extend UifFormBase

      *

      * @return Class<?> class for the view's form

      * @see org.kuali.rice.krad.web.form.UifFormBase

      */

     public Class<?> getFormClass() {

         return this.formClass;

     }

     /**

      * Setter for the form class

      *

      * @param formClass

      */

     public void setFormClass(Class<?> formClass) {

         this.formClass = formClass;

     }

     /**

      * For <code>View</code> types that work primarily with one nested object of

      * the form (for instance document, or bo) the default binding object path

      * can be set for each of the views <code>DataBinding</code> components. If

      * the component does not set its own binding object path it will inherit

      * the default

      *

      * @return String binding path to the object from the form

      * @see org.kuali.rice.krad.uif.BindingInfo.getBindingObjectPath()

      */

     public String getDefaultBindingObjectPath() {

         return this.defaultBindingObjectPath;

     }

     /**

      * Setter for the default binding object path to use for the view

      *

      * @param defaultBindingObjectPath

      */

     public void setDefaultBindingObjectPath(String defaultBindingObjectPath) {

         this.defaultBindingObjectPath = defaultBindingObjectPath;

     }

     /**

      * Configures the concrete classes that will be used for properties in the

      * form object graph that have an abstract or interface type

      *

      * <p>

      * For properties that have an abstract or interface type, it is not

      * possible to perform operations like getting/settings property values and

      * getting information from the dictionary. When these properties are

      * encountered in the object graph, this <code>Map</code> will be consulted

      * to determine the concrete type to use.

      * </p>

      *

      * <p>

      * e.g. Suppose we have a property document.accountingLine.accountNumber and

      * the accountingLine property on the document instance has an interface

      * type 'AccountingLine'. We can then put an entry into this map with key

      * 'document.accountingLine', and value

      * 'org.kuali.rice.sampleapp.TravelAccountingLine'. When getting the

      * property type or an entry from the dictionary for accountNumber, the

      * TravelAccountingLine class will be used.

      * </p>

      *

      * @return Map<String, Class> of class implementations keyed by path

      */

     public Map<String, Class<?>> getAbstractTypeClasses() {

         return this.abstractTypeClasses;

     }

     /**

      * Setter for the Map of class implementations keyed by path

      *

      * @param abstractTypeClasses

      */

     public void setAbstractTypeClasses(Map<String, Class<?>> abstractTypeClasses) {

         this.abstractTypeClasses = abstractTypeClasses;

     }

     /**

      * Declares additional script files that should be included with the

      * <code>View</code>. These files are brought into the HTML page along with

      * common script files configured for the Rice application. Each entry

      * contain the path to the CSS file, either a relative path, path from web

      * root, or full URI

      * <p>

      * e.g. '/krad/scripts/myScript.js', '../scripts/myScript.js',

      * 'http://my.edu/web/myScript.js'

      * </p>

      *

      * @return List<String> script file locations

      */

     public List<String> getAdditionalScriptFiles() {

         return this.additionalScriptFiles;

     }

     /**

      * Setter for the List of additional script files to included with the

      * <code>View</code>

      *

      * @param additionalScriptFiles

      */

     public void setAdditionalScriptFiles(List<String> additionalScriptFiles) {

         this.additionalScriptFiles = additionalScriptFiles;

     }

     /**

      * Declares additional CSS files that should be included with the

      * <code>View</code>. These files are brought into the HTML page along with

      * common CSS files configured for the Rice application. Each entry should

      * contain the path to the CSS file, either a relative path, path from web

      * root, or full URI

      * <p>

      * e.g. '/krad/css/stacked-view.css', '../css/stacked-view.css',

      * 'http://my.edu/web/stacked-view.css'

      * </p>

      *

      * @return List<String> CSS file locations

      */

     public List<String> getAdditionalCssFiles() {

         return this.additionalCssFiles;

     }

     /**

      * Setter for the List of additional CSS files to included with the

      * <code>View</code>

      *

      * @param additionalCssFiles

      */

     public void setAdditionalCssFiles(List<String> additionalCssFiles) {

         this.additionalCssFiles = additionalCssFiles;

     }

     public boolean isDialogMode() {

         return this.dialogMode;

     }

     public void setDialogMode(boolean dialogMode) {

         this.dialogMode = dialogMode;

     }

     /**

      * View type name the view is associated with the view instance

      *

      * <p>

      * Views that share common features and functionality can be grouped by the

      * view type. Usually view types extend the <code>View</code> class to

      * provide additional configuration and to set defaults. View types can also

      * implement the <code>ViewTypeService</code> to add special indexing and

      * retrieval of views.

      * </p>

      *

      * @return String view type name for the view

      */

     public ViewType getViewTypeName() {

         return this.viewTypeName;

     }

     /**

      * Setter for the view's type name

      *

      * @param viewTypeName

      */

     public void setViewTypeName(ViewType viewTypeName) {

         this.viewTypeName = viewTypeName;

     }

     /**

      * Class name of the <code>ViewHelperService</code> that handles the various

      * phases of the Views lifecycle

      *

      * @return Class for the spring bean

      * @see org.kuali.rice.krad.uif.service.ViewHelperService

      */

     public Class<? extends ViewHelperService> getViewHelperServiceClassName() {

         return this.viewHelperServiceClassName;

     }

     /**

      * Setter for the <code>ViewHelperService</code> class name

      *

      * @param viewLifecycleService

      */

     public void setViewHelperServiceClassName(Class<? extends ViewHelperService> viewHelperServiceClassName) {

         this.viewHelperServiceClassName = viewHelperServiceClassName;

     }

     /**

      * Creates the <code>ViewHelperService</code> associated with the View

      *

      * @return ViewHelperService instance

      */

     public ViewHelperService getViewHelperService() {

         if (this.viewHelperService == null) {

             viewHelperService = ObjectUtils.newInstance(viewHelperServiceClassName);

         }

         return viewHelperService;

     }

     /**

      * Invoked to produce a ViewIndex of the current view's components

      */

     public void index() {

         if (this.viewIndex == null) {

             this.viewIndex = new ViewIndex();

         }

         this.viewIndex.index(this);

     }

     /**

      * Holds field indexes of the <code>View</code> instance for retrieval

      *

      * @return ViewIndex instance

      */

     public ViewIndex getViewIndex() {

         return this.viewIndex;

     }

     /**

      * Map of parameters from the request that set view options, used to rebuild

      * the view on each post

      * <p>

      * Views can be configured by parameters. These might impact which parts of

      * the view are rendered or how the view behaves. Generally these would get

      * passed in when a new view is requested (by request parameters). These

      * will be used to initially populate the view properties. In addition, on a

      * post the view will be rebuilt and properties reset again by the allow

      * request parameters.

      * </p>

      * <p>

      * Example parameter would be for MaintenaceView whether a New, Edit, or

      * Copy was requested (maintenance mode)

      * </p>

      *

      * @return

      */

     public Map<String, String> getViewRequestParameters() {

         return this.viewRequestParameters;

     }

     /**

      * Setter for the view's request parameters map

      *

      * @param viewRequestParameters

      */

     public void setViewRequestParameters(Map<String, String> viewRequestParameters) {

         this.viewRequestParameters = viewRequestParameters;

     }

     /**

      * PresentationController class that should be used for the

      * <code>View</code> instance

      * <p>

      * The presentation controller is consulted to determine component (group,

      * field) state such as required, read-only, and hidden. The presentation

      * controller does not take into account user permissions. The presentation

      * controller can also output action flags and edit modes that will be set

      * onto the view instance and can be referred to by conditional expressions

      * </p>

      *

      * @return Class<? extends PresentationController>

      * @see View.getActionFlags()

      * @see View.getEditModes()

      */

     public Class<? extends PresentationController> getPresentationControllerClass() {

         return this.presentationControllerClass;

     }

     /**

      * Setter for the view's presentation controller

      *

      * @param presentationControllerClass

      */

     public void setPresentationControllerClass(Class<? extends PresentationController> presentationControllerClass) {

         this.presentationControllerClass = presentationControllerClass;

     }

     /**

      * Authorizer class that should be used for the <code>View</code> instance

      * <p>

      * The authorizer class is consulted to determine component (group, field)

      * state such as required, read-only, and hidden based on the users

      * permissions. It typically communicates with the Kuali Identity Management

      * system to determine roles and permissions. It is used with the

      * presentation controller and dictionary conditional logic to determine the

      * final component state. The authorizer can also output action flags and

      * edit modes that will be set onto the view instance and can be referred to

      * by conditional expressions

      * </p>

      *

      * @return Class<? extends Authorizer>

      * @see View.getActionFlags()

      * @see View.getEditModes()

      */

     public Class<? extends Authorizer> getAuthorizerClass() {

         return this.authorizerClass;

     }

     /**

      * Setter for the view's authorizer

      *

      * @param authorizerClass

      */

     public void setAuthorizerClass(Class<? extends Authorizer> authorizerClass) {

         this.authorizerClass = authorizerClass;

     }

     /**

      * Map of strings that flag what actions can be taken in the UI

      * <p>

      * These can be used in conditional expressions in the dictionary or by

      * other UI logic

      * </p>

      *

      * @return BooleanMap action flags

      */

     public BooleanMap getActionFlags() {

         return this.actionFlags;

     }

     /**

      * Setter for the action flags Map

      *

      * @param actionFlags

      */

     public void setActionFlags(BooleanMap actionFlags) {

         this.actionFlags = actionFlags;

     }

     /**

      * Map of edit modes that enabled for the view

      * <p>

      * These can be used in conditional expressions in the dictionary or by

      * other UI logic

      * </p>

      *

      * @return BooleanMap edit modes

      */

     public BooleanMap getEditModes() {

         return this.editModes;

     }

     /**

      * Setter for the edit modes Map

      *

      * @param editModes

      */

     public void setEditModes(BooleanMap editModes) {

         this.editModes = editModes;

     }

     /**

      * Map that contains expressions to evaluate and make available as variables

      * for conditional expressions within the view

      * <p>

      * Each Map entry contains one expression variables, where the map key gives

      * the name for the variable, and the map value gives the variable

      * expression. The variables expressions will be evaluated before

      * conditional logic is run and made available as variables for other

      * conditional expressions. Variable expressions can be based on the model

      * and any object contained in the view's context

      * </p>

      *

      * @return Map<String, String> variable expressions

      */

     public Map<String, String> getExpressionVariables() {

         return this.expressionVariables;

     }

     /**

      * Setter for the view's map of variable expressions

      *

      * @param expressionVariables

      */

     public void setExpressionVariables(Map<String, String> expressionVariables) {

         this.expressionVariables = expressionVariables;

     }

     /**

      * Indicates whether the <code>View</code> only has a single page

      * <code>Group</code> or contains multiple page <code>Group</code>

      * instances. In the case of a single page it is assumed the group's items

      * list contains the section groups for the page, and the page itself is

      * given by the page property ({@link #getPage()}. This is for convenience

      * of configuration and also can drive other configuration like styling.

      *

      * @return boolean true if the view only contains one page group, false if

      *         it contains multple pages

      */

     public boolean isSinglePageView() {

         return this.singlePageView;

     }

     /**

      * Setter for the single page indicator

      *

      * @param singlePageView

      */

     public void setSinglePageView(boolean singlePageView) {

         this.singlePageView = singlePageView;

     }

     /**

      * For single paged views ({@link #isSinglePageView()}, gives the page

      * <code>Group</code> the view should render. The actual items for the page

      * is taken from the group's items list ({@link #getItems()}, and set onto

      * the give page group. This is for convenience of configuration.

      *

      * @return Group page group for single page views

      */

     public PageGroup getPage() {

         return this.page;

     }

     /**

      * Setter for the page group for single page views

      *

      * @param page

      */

     public void setPage(PageGroup page) {

         this.page = page;

     }

     /**

      * @see org.kuali.rice.krad.uif.container.ContainerBase#getItems()

      */

     @Override

     public List<? extends Group> getItems() {

         return this.items;

     }

     /**

      * Setter for the view's <code>Group</code> instances

      *

      * @param items

      */

     @Override

     public void setItems(List<? extends Component> items) {

         // TODO: fix this generic issue

         this.items = (List<? extends Group>) items;

     }

     /**

      * Provides configuration for displaying a link to the view from an

      * application menu

      *

      * @return LinkField view link field

      */

     public LinkField getViewMenuLink() {

         return this.viewMenuLink;

     }

     /**

      * Setter for the views link field

      *

      * @param viewMenuLink

      */

     public void setViewMenuLink(LinkField viewMenuLink) {

         this.viewMenuLink = viewMenuLink;

     }

     /**

      * Provides a grouping string for the view to group its menu link (within a

      * portal for instance)

      *

      * @return String menu grouping

      */

     public String getViewMenuGrouping() {

         return this.viewMenuGrouping;

     }

     /**

      * Setter for the views menu grouping

      *

      * @param viewMenuGrouping

      */

     public void setViewMenuGrouping(String viewMenuGrouping) {

         this.viewMenuGrouping = viewMenuGrouping;

     }

     /**

      * Indicates what lifecycle phase the View instance is in

      * <p>

      * The view lifecycle begins with the CREATED status. In this status a new

      * instance of the view has been retrieved from the dictionary, but no

      * further processing has been done. After the initialize phase has been run

      * the status changes to INITIALIZED. After the model has been applied and

      * the view is ready for render the status changes to FINAL

      * </p>

      *

      * @return String view status

      * @see org.kuali.rice.krad.uif.UifConstants.ViewStatus

      */

     public String getViewStatus() {

         return this.viewStatus;

     }

     /**

      * Setter for the view status

      *

      * @param viewStatus

      */

     public void setViewStatus(String viewStatus) {

         this.viewStatus = viewStatus;

     }

     /**

      * Indicates whether the view has been initialized

      *

      * @return boolean true if the view has been initialized, false if not

      */

     public boolean isInitialized() {

         return StringUtils.equals(viewStatus, ViewStatus.INITIALIZED) ||

                 StringUtils.equals(viewStatus, ViewStatus.FINAL);

     }

     /**

      * Indicates whether the view has been updated from the model and final

      * updates made

      *

      * @return boolean true if the view has been updated, false if not

      */

     public boolean isFinal() {

         return StringUtils.equals(viewStatus, ViewStatus.FINAL);

     }

     /**

      * onSubmit script configured on the <code>View</code> gets placed on the

      * form element

      *

      * @see org.kuali.rice.krad.uif.component.ComponentBase#getSupportsOnSubmit()

      */

     @Override

     public boolean getSupportsOnSubmit() {

         return true;

     }

     /**

      * onLoad script configured on the <code>View</code> gets placed in a load

      * call

      *

      * @see org.kuali.rice.krad.uif.component.ComponentBase#getSupportsOnLoad()

      */

     @Override

     public boolean getSupportsOnLoad() {

         return true;

     }

     /**

      * onDocumentReady script configured on the <code>View</code> gets placed in

      * a document ready jQuery block

      *

      * @see org.kuali.rice.krad.uif.component.ComponentBase#getSupportsOnLoad()

      */

     @Override

     public boolean getSupportsOnDocumentReady() {

         return true;

     }

     /**

      * Breadcrumb widget used for displaying homeward path and history

      *

      * @return the breadcrumbs

      */

     public BreadCrumbs getBreadcrumbs() {

         return this.breadcrumbs;

     }

     /**

      * @param breadcrumbs the breadcrumbs to set

      */

     public void setBreadcrumbs(BreadCrumbs breadcrumbs) {

         this.breadcrumbs = breadcrumbs;

     }

     /**

      * Indicates whether the breadcrumbs are rendered in the application header and should not

      * be rendered as part of the view template

      *

      * <p>

      * For layout purposes it is sometimes necessary to render the breadcrumbs in the application header. This flag

      * indicates that is being done and therefore should not be rendered in the view template.

      * </p>

      *

      * @return boolean true if breadcrumbs are rendered in the application header, false if not and they should be

      *         rendered with the view

      */

     public boolean isBreadcrumbsInApplicationHeader() {

         return breadcrumbsInApplicationHeader;

     }

     /**

      * Setter for the breadcrumbs in application header indicator

      *

      * @param breadcrumbsInApplicationHeader

      */

     public void setBreadcrumbsInApplicationHeader(boolean breadcrumbsInApplicationHeader) {

         this.breadcrumbsInApplicationHeader = breadcrumbsInApplicationHeader;

     }

     /**

      * Growls widget which sets up global settings for the growls used in this

      * view and its pages

      *

      * @return the growls

      */

     public Growls getGrowls() {

         return this.growls;

     }

     /**

      * @param growls the growls to set

      */

     public void setGrowls(Growls growls) {

         this.growls = growls;

     }

     /**

      * Growls use the messages contained in the message map. If enabled, info

      * messages in their entirety will be displayed in growls, for warning and

      * error messages a growl message will notify the user that these messages

      * exist on the page. If this setting is disabled, it is recommended that

      * infoMessage display be enabled for the page ErrorsField bean in order to

      * display relevant information to the user. Note: the growl scripts are

      * built out in the PageGroup class.

      *

      * @return the growlMessagingEnabled

      */

     public boolean isGrowlMessagingEnabled() {

         return this.growlMessagingEnabled;

     }

     /**

      * @param growlMessagingEnabled the growlMessagingEnabled to set

      */

     public void setGrowlMessagingEnabled(boolean growlMessagingEnabled) {

         this.growlMessagingEnabled = growlMessagingEnabled;

     }

     /**

      * Indicates whether the form should be validated for dirtyness

      *

      * <p>

      * For FormView, it's necessary to validate when the user tries to navigate out of the form. If set, all the

      * InputFields will be validated on refresh, navigate, cancel or close Action or on form

      * unload and if dirty, displays a message and user can decide whether to continue with

      * the action or stay on the form. For lookup and inquiry, it's not needed to validate.

      * </p>

      *

      * @return true if dirty validation is set

      */

     public boolean isValidateDirty() {

         return this.validateDirty;

     }

     /**

      * Setter for dirty validation.

      */

     public void setValidateDirty(boolean validateDirty) {

         this.validateDirty = validateDirty;

     }

     /**

      * Indicates whether the Name of the Code should be displayed when a property is of type <code>KualiCode</code>

      *

      * @param translateCodes - indicates whether <code>KualiCode</code>'s name should be included

      */

     public void setTranslateCodes(boolean translateCodes) {

         this.translateCodes = translateCodes;

     }

     /**

      * Returns whether the current view supports displaying <code>KualiCode</code>'s name as additional display value

      *

      * @return true if the current view supports

      */

     public boolean isTranslateCodes() {

         return translateCodes;

     }

     /**

      * The property name to be used to determine what will be used in the

      * breadcrumb title of this view

      *

      * <p>

      * The title can be determined from a combination of this and viewLabelFieldbindingInfo: If only

      * viewLabelFieldPropertyName is set, the title we be determined against the

      * defaultBindingObjectPath. If only viewLabelFieldbindingInfo is set it

      * must provide information about what object(bindToForm or explicit) and

      * path to use. If both viewLabelFieldbindingInfo and viewLabelFieldPropertyName are set,

      * the bindingInfo will be used with a

      * the viewLabelFieldPropertyName as its bindingPath. If neither are set,

      * the default title attribute from the dataObject's metadata (determined by the

      * defaultBindingObjectPath's object) will be used.

      * </p>

      *

      * @return String property name whose value should be displayed in view label

      */

     public String getViewLabelFieldPropertyName() {

         return this.viewLabelFieldPropertyName;

     }

     /**

      * Setter for the view label property name

      *

      * @param viewLabelFieldPropertyName the viewLabelFieldPropertyName to set

      */

     public void setViewLabelFieldPropertyName(String viewLabelFieldPropertyName) {

         this.viewLabelFieldPropertyName = viewLabelFieldPropertyName;

     }

     /**

      * The option to use when appending the view label on the breadcrumb title.

      * Available options: 'dash', 'parenthesis', and 'replace'(don't append -

      * simply replace the title). MUST be set for the viewLabelField to be used

      * in the breadcrumb, if not set no appendage will be added.

      *

      * @return the appendOption

      */

     public String getAppendOption() {

         return this.appendOption;

     }

     /**

      * Setter for the append option

      *

      * @param appendOption the appendOption to set

      * @see View#setViewLabelFieldPropertyName(String)

      * @see View#setViewLabelFieldBindingInfo(BindingInfo)

      */

     public void setAppendOption(String appendOption) {

         this.appendOption = appendOption;

     }

     /**

      * Map of key name/value pairs that will be exposed on the client with JavaScript

      *

      * <p>

      * Any state contained in the Map will be in addition to general state added by the

      * <code>ViewHelperService</code> and also state generated from the component properties

      * annotated with <code>ClientSideState</code>. If this map does contain a key that is

      * the same as the generated state, it will override the generated, with the exception

      * of keys that refer to component ids and have a nested map as value, which will be merged

      * </p>

      *

      * @return Map<String, Object> contains key name/value pairs to expose on client

      */

     public Map<String, Object> getClientSideState() {

         return clientSideState;

     }

     /**

      * Setter for the client side state map

      *

      * @param clientSideState

      */

     public void setClientSideState(Map<String, Object> clientSideState) {

         this.clientSideState = clientSideState;

     }

     /**

      * Adds a variable name/value pair to the client side state map associated with the given

      * component id

      *

      * @param componentId - id of the component the state is associated with

      * @param variableName - name to expose the state as

      * @param value - initial value for the variable on the client

      */

     public void addToClientSideState(String componentId, String variableName, Object value) {

         Map<String, Object> componentClientState = new HashMap<String, Object>();

         // find any existing client state for component

         if (clientSideState.containsKey(componentId)) {

             Object clientState = clientSideState.get(componentId);

             if ((clientState != null) && (clientState instanceof Map)) {

                 componentClientState = (Map<String, Object>) clientState;

             } else {

                 throw new IllegalArgumentException("Client side state for component: " + componentId + " is not a Map");

             }

         }

         // add variables to component state and reinsert into view's client state

         componentClientState.put(variableName, value);

         clientSideState.put(componentId, componentClientState);

     }

     /**

      * Indicates whether the view allows read only fields to be specified on the request URL which will

      * override the view setting

      *

      * <p>

      * If enabled, the readOnlyFields request parameter can be sent to indicate fields that should be set read only

      * </p>

      *

      * @return boolean true if read only request overrides are allowed, false if not

      */

     public boolean isSupportsReadOnlyFieldsOverride() {

         return supportsReadOnlyFieldsOverride;

     }

     /**