Package org.kuali.rice.krad.uif.layout

Class LayoutManagerBase

java.lang.Object
org.kuali.rice.krad.datadictionary.DictionaryBeanBase
org.kuali.rice.krad.datadictionary.uif.UifDictionaryBeanBase
org.kuali.rice.krad.uif.layout.LayoutManagerBase
All Implemented Interfaces:
Serializable, Cloneable, Copyable, DictionaryBean, UifDictionaryBean, LayoutManager, LifecycleElement
Direct Known Subclasses:
BoxLayoutManager, CollectionLayoutManagerBase, CssGridLayoutManagerBase, GridLayoutManagerBase, ListLayoutManager, SimpleLayoutManager
public abstract class LayoutManagerBase extends UifDictionaryBeanBase implements LayoutManager
Base class for all layout managers

Provides general properties of all layout managers, such as the unique id, rendering template, and style settings

Author:
Kuali Rice Team (rice.collab@kuali.org)
See Also:

  • Constructor Details

    • LayoutManagerBase

      public LayoutManagerBase()

  • Method Details

    • checkMutable

      public void checkMutable(boolean legalDuringInitialization)
      Description copied from interface: LifecycleElement
      Check for mutability on the element before modifying state.
      Specified by:
      checkMutable in interface LifecycleElement
      Parameters:
      legalDuringInitialization - True if the operation is legal during view initialization, false if the operation is only allowed during the component lifecycle.
      See Also:

    • isMutable

      public boolean isMutable(boolean legalDuringInitialization)
      Description copied from interface: LifecycleElement
      Determine if this lifecycle element is mutable.

      Most lifecycle element are immutable, and all are immutable expect during initialization and the during the view lifecycle. Those that have been copied within the view lifecycle, however, may be modified during the same lifecycle.

      Specified by:
      isMutable in interface LifecycleElement
      Parameters:
      legalDuringInitialization - true if the current operation may be called before the lifecycle element has been cached, for example while being initialized as part of a Spring context.
      Returns:
      True if the component is mutable.
      See Also:

    • getViewStatus

      public String getViewStatus()
      Indicates what lifecycle phase the layout manager instance is in

      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

      Specified by:
      getViewStatus in interface LifecycleElement
      Returns:
      view status
      See Also:

    • setViewStatus

      public void setViewStatus(String status)
      Sets the view status.
      Specified by:
      setViewStatus in interface LifecycleElement
      Parameters:
      status - view status
      See Also:

    • notifyCompleted

      public void notifyCompleted(ViewLifecyclePhase phase)
      Receive notification that a lifecycle phase, and all successor phases, have been completed on this component.
      Specified by:
      notifyCompleted in interface LifecycleElement
      Parameters:
      phase - The completed view lifecycle phase

    • performInitialization

      public void performInitialization(Object model)
      Initializes the component

      Where components can set defaults and setup other necessary state. The initialize method should only be called once per component lifecycle and is invoked within the initialize phase of the view lifecylce.

      Specified by:
      performInitialization in interface LifecycleElement
      Parameters:
      model - - object instance containing the view data
      See Also:

    • performApplyModel

      public void performApplyModel(Object model, LifecycleElement component)
      Called after the initialize phase to perform conditional logic based on the model data

      Where components can perform conditional logic such as dynamically generating new fields or setting field state based on the given data

      Specified by:
      performApplyModel in interface LifecycleElement
      Parameters:
      model - - Top level object containing the data (could be the form or a top level business object, dto)
      component - parent lifecycle element

    • performFinalize

      public void performFinalize(Object model, LifecycleElement component)
      The last phase before the view is rendered

      Here final preparations can be made based on the updated view state.

      Specified by:
      performFinalize in interface LifecycleElement
      Parameters:
      model - - top level object containing the data
      component - - parent component

    • skipLifecycle

      public boolean skipLifecycle()
      Return true if the lifecycle should be skipped for this component.

      Skipping the lifecycle means do not invoke the performInitialize, performApplyModel, and performFinalize methods of this component and its children. This means that content built by those lifecycle tasks will not be processed or applied. Skipping the lifecycle on a component helps initial load/setup performance by only performing the full lifecycle when the component is requested on subsequent requests (ajax retrievals).

      Specified by:
      skipLifecycle in interface LifecycleElement
      Returns:
      true if lifecycle should be skipped for this component

    • getSupportedContainer

      public Class<? extends Container> getSupportedContainer()
      Default Impl Determines what Container classes are supported by the LayoutManager
      Specified by:
      getSupportedContainer in interface LayoutManager
      Returns:
      Classinvalid input: '<'? extends Container> container class supported

    • getId

      public String getId()
      The unique id (within a given tree) for the element.

      The id is used to identify an element instance within the tree, and will be used by renderers to set the HTML element id. This gives a way to find various elements for scripting. If the id is not given, a default will be generated by the framework.

      Specified by:
      getId in interface LifecycleElement
      Returns:
      A unique ID for this lifecycle element.

    • setId

      public void setId(String id)
      Setter for the unique id (within a given tree) for the component
      Specified by:
      setId in interface LifecycleElement
      Parameters:
      id - - string to set as the component id

    • getContainerIdSuffix

      public String getContainerIdSuffix()
      A string suffix that should get applied to the id for all child components of the given element.

      This is mainly used within the framework to keep ids unique. For instance, for components generated for collection lines, all the components within those should get a line suffix. The framework will set this property to be '_line0', '_line1', etc. Then when the apply model phase is run on the child components their ids will be updated with this suffix.

      Specified by:
      getContainerIdSuffix in interface LifecycleElement
      Returns:
      String id suffix for child components
      See Also:

    • setContainerIdSuffix

      public void setContainerIdSuffix(String containerIdSuffix)
      Specified by:
      setContainerIdSuffix in interface LifecycleElement
      See Also:

    • getViewPath

      public String getViewPath()
      Gets a property for referring to this component from the view, relative to the view, as assigned by the current or most recent lifecycle.
      Specified by:
      getViewPath in interface LifecycleElement
      Returns:
      property path

    • setViewPath

      public void setViewPath(String viewPath)
      Setter for LifecycleElement.getViewPath().
      Specified by:
      setViewPath in interface LifecycleElement
      Parameters:
      viewPath - The property path.

    • getPhasePathMapping

      public Map<String,String> getPhasePathMapping()
      Map of paths for this component that will be used to process a refresh (if necessary).
      Specified by:
      getPhasePathMapping in interface LifecycleElement
      Returns:
      map of refresh paths, key represents the lifecycle phase and the value is the path for the component at that phase

    • setPhasePathMapping

      public void setPhasePathMapping(Map<String,String> phasePathMapping)
      Specified by:
      setPhasePathMapping in interface LifecycleElement
      See Also:

    • getTemplate

      public String getTemplate()
      The path to the JSP file that should be called to invoke the layout manager

      The path should be relative to the web root. All layout manager templates receive the list of items of be placed, the configured layout manager, and the container to which the layout manager applies

      e.g. '/krad/WEB-INF/jsp/tiles/boxLayout.jsp'

      Specified by:
      getTemplate in interface LayoutManager
      Returns:
      String representing the template path

    • setTemplate

      public void setTemplate(String template)
      Setter for the layout managers template
      Specified by:
      setTemplate in interface LayoutManager
      Parameters:
      template -

    • getTemplateName

      public String getTemplateName()
      The name for which the template can be invoked by

      Whether the template name is needed depends on the underlying rendering engine being used. In the example of Freemarker, the template points to the actual source file, which then loads a macro. From then on the macro is simply invoked to execute the template

      e.g. 'uif_grid'

      Specified by:
      getTemplateName in interface LayoutManager
      Returns:
      template name

    • setTemplateName

      public void setTemplateName(String templateName)
      Setter for the name of the template (a name which can be used to invoke)
      Specified by:
      setTemplateName in interface LayoutManager
      Parameters:
      templateName -

    • getStyle

      public String getStyle()
      CSS style string to be applied to the area (div) the layout manager generates for the items

      Note the styleClass/style configured on the Container applies to all the container content (header, body, footer), while the styleClass/style configured on the LayoutManager only applies to the div surrounding the items placed by the manager (the container's body)

      Any style override or additions can be specified with this attribute. This is used by the renderer to set the style attribute on the corresponding element.

      e.g. 'color: #000000;text-decoration: underline;'

      Specified by:
      getStyle in interface LayoutManager
      Returns:
      String css style string

    • setStyle

      public void setStyle(String style)
      Setter for the layout manager div style
      Specified by:
      setStyle in interface LayoutManager
      Parameters:
      style -

    • getLibraryCssClasses

      public List<String> getLibraryCssClasses()
      Additional css classes that come before css classes listed in the cssClasses property

      These are used by the framework for styling with a library (for example, bootstrap), and should normally not be overridden.

      Specified by:
      getLibraryCssClasses in interface LayoutManager
      Returns:
      the library cssClasses

    • setLibraryCssClasses

      public void setLibraryCssClasses(List<String> libraryCssClasses)
      Set the libraryCssClasses
      Specified by:
      setLibraryCssClasses in interface LayoutManager
      Parameters:
      libraryCssClasses -

    • getCssClasses

      public List<String> getCssClasses()
      Description copied from interface: LayoutManager
      CSS style class(s) to be applied to the area (div) the layout manager generates for the items

      Note the styleClass/style configured on the Container applies to all the container content (header, body, footer), while the styleClass/style configured on the LayoutManager only applies to the div surrounding the items placed by the manager (the container's body)

      Declares additional style classes for the div. Multiple classes are specified with a space delimiter. This is used by the renderer to set the class attribute on the corresponding element. The class(s) declared must be available in the common style sheets or the style sheets specified for the view

      e.g. 'header left'

      Specified by:
      getCssClasses in interface LayoutManager
      Returns:
      List<String> css style classes to apply
      See Also:

    • setCssClasses

      public void setCssClasses(List<String> cssClasses)
      Description copied from interface: LayoutManager
      Setter for the layout manager div style class
      Specified by:
      setCssClasses in interface LayoutManager
      See Also:

    • getAdditionalCssClasses

      public List<String> getAdditionalCssClasses()
      Specified by:
      getAdditionalCssClasses in interface LayoutManager
      See Also:

    • setAdditionalCssClasses

      public void setAdditionalCssClasses(List<String> additionalCssClasses)
      Specified by:
      setAdditionalCssClasses in interface LayoutManager
      See Also:

    • getStyleClassesAsString

      public String getStyleClassesAsString()
      Builds the HTML class attribute string by combining the styleClasses list with a space delimiter
      Returns:
      class attribute string

    • setStyleClasses

      public void setStyleClasses(String styleClasses)
      Sets the styleClasses list from the given string that has the classes delimited by space. This is a convenience for configuration. If a child bean needs to inherit the classes from the parent, it should configure as a list and use merge="true"
      Parameters:
      styleClasses -

    • addStyleClass

      public void addStyleClass(String styleClass)
      This method adds a single style class to the list of css style classes on this component
      Specified by:
      addStyleClass in interface LayoutManager

    • appendToStyle

      public void appendToStyle(String styleRules)
      Appends to the inline style set on this layoutManager
      Specified by:
      appendToStyle in interface LayoutManager

    • getContext

      public Map<String,Object> getContext()
      Context map for the lifecycle element.

      Any el statements configured for the components properties (e.g. title="@{foo.property}") are evaluated using the el context map. This map will get populated with default objects like the model, view, and request from the ViewHelperService. Other components can push further objects into the context so that they are available for use with that component. For example, field instances that are part of a collection line as receive the current line instance

      Context map also provides objects to methods that are invoked for GeneratedField instances

      The Map key gives the name of the variable that can be used within expressions, and the Map value gives the object instance for which expressions containing the variable should evaluate against

      NOTE: Calling getContext().putAll() will skip updating any configured property replacers for the component. Instead you should call #pushAllToContextDeep

      Specified by:
      getContext in interface LifecycleElement
      Returns:
      Mapinvalid input: '<'String, Object> context

    • setContext

      public void setContext(Map<String,Object> context)
      Specified by:
      setContext in interface LifecycleElement
      See Also:

    • pushObjectToContext

      public void pushObjectToContext(String objectName, Object object)
      Places the given object into the context Map for the component with the given name

      Note this also will push context to property replacers configured on the component. To place multiple objects in the context, you should use #pushAllToContextDeep since that will call this method for each and update property replacers. Using Component.getContext().putAll() will bypass property replacers.

      Specified by:
      pushObjectToContext in interface LifecycleElement
      Parameters:
      objectName - - name the object should be exposed under in the context map
      object - - object instance to place into context

    • pushAllToContext

      public void pushAllToContext(Map<String,Object> sourceContext)
      Places each entry of the given Map into the context for the component

      Note this will call #pushObjectToContextDeep for each entry which will update any configured property replacers as well. This should be used in place of getContext().putAll()

      Specified by:
      pushAllToContext in interface LifecycleElement
      Parameters:
      sourceContext - - Mapinvalid input: '<'String, Object> objects to add to context, where the entry key will be the context key and the entry value will be the context value

    • getPropertyReplacers

      public List<PropertyReplacer> getPropertyReplacers()
      List of PropertyReplacer instances that will be evaluated during the view lifecycle to conditional set properties on the LayoutManager based on expression evaluations
      Specified by:
      getPropertyReplacers in interface LayoutManager
      Returns:
      List<PropertyReplacer> replacers to evaluate

    • setPropertyReplacers

      public void setPropertyReplacers(List<PropertyReplacer> propertyReplacers)
      Setter for the layout managers property substitutions
      Specified by:
      setPropertyReplacers in interface LayoutManager

    • clone

      public LayoutManagerBase clone() throws CloneNotSupportedException
      Description copied from interface: Copyable
      Override Object.clone() to assign the public modifier.
      Specified by:
      clone in interface Copyable
      Overrides:
      clone in class DictionaryBeanBase
      Returns:
      Object.clone()
      Throws:
      CloneNotSupportedException - If Cloneable is not implemented. This should not be possible when using this interface.
      See Also:

    • isInitialized

      public boolean isInitialized()
      Indicates whether the component has been initialized.
      Specified by:
      isInitialized in interface LifecycleElement
      Returns:
      True if the component has been initialized, false if not.

    • isModelApplied

      public boolean isModelApplied()
      Indicates whether the component has been updated from the model.
      Specified by:
      isModelApplied in interface LifecycleElement
      Returns:
      True if the component has been updated, false if not.

    • isFinal

      public boolean isFinal()
      Indicates whether the component has been updated from the model and final updates made.
      Specified by:
      isFinal in interface LifecycleElement
      Returns:
      True if the component has been updated, false if not.

    • isRender

      public boolean isRender()
      Indicates whether the component should be rendered in the UI

      If set to false, the corresponding component template will not be invoked (therefore nothing will be rendered to the UI).

      Specified by:
      isRender in interface LifecycleElement
      Returns:
      boolean true if the component should be rendered, false if it should not be

    • setRender

      public void setRender(boolean render)
      Setter for the components render indicator
      Specified by:
      setRender in interface LifecycleElement
      Parameters:
      render -