Serialized Form (wcomponents-core 1.5.25 API)

Package com.github.bordertech.wcomponents
- Class com.github.bordertech.wcomponents.AbstractBasicTableModel extends Object implements Serializable
- Class com.github.bordertech.wcomponents.AbstractBeanBoundTableModel extends AbstractTableModel implements Serializable
  - Serialized Fields
    - beanProvider
```
BeanProvider beanProvider
```
      The data model's BeanProvider.
    - beanId
```
Object beanId
```
      The beanId is used to obtain the bean from the provider.
    - beanProperty
```
String beanProperty
```
      This bean property that this component is interested in. The property is specified using Jakarta BeanUtils bean notation.
- Class com.github.bordertech.wcomponents.AbstractBeanTableDataModel extends AbstractTableDataModel implements Serializable
  - Serialized Fields
    - beanProvider
```
BeanProvider beanProvider
```
      Deprecated.
      
      The data model's BeanProvider.
    - beanId
```
Object beanId
```
      Deprecated.
      
      The beanId is used to obtain the bean from the provider.
    - beanProperty
```
String beanProperty
```
      Deprecated.
      
      This bean property that this component is interested in. The property is specified using Jakarta BeanUtils bean notation.
- Class com.github.bordertech.wcomponents.AbstractContainer extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.AbstractEnvironment extends Object implements Serializable
  - Serialized Fields
    - postPath
```
String postPath
```
      The URL that responses should be directed to.
    - appHostPath
```
String appHostPath
```
      The application host path.
    - baseUrl
```
String baseUrl
```
      The base url. e.g. for "http://localhost:1234/bar/something?a=b", it would be "http://localhost/bar".
    - hostFreeBaseUrl
```
String hostFreeBaseUrl
```
      The host free part of the base url. e.g. for "http://localhost:1234/bar/something?a=b", it would be "bar".
    - appId
```
String appId
```
      The application id, used for namespacing component IDs in the UI.
    - sessionToken
```
String sessionToken
```
      The session token, used for ensuring requests are for the correct session.
    - step
```
int step
```
      The step counter, used for ensuring requests are not processed out of order or multiple times.
    - actionStep
```
int actionStep
```
      The action step counter, used for the request being processed is current.
    - formEncType
```
String formEncType
```
      An optional form encoding type, for example "multipart/form-data" if files need to be uploaded.
    - userAgentInfo
```
UserAgentInfo userAgentInfo
```
      The user-agent information passed by the client's browser.
- Class com.github.bordertech.wcomponents.AbstractInput extends WBeanComponent implements Serializable
- Class com.github.bordertech.wcomponents.AbstractInput.InputModel extends BeanAndProviderBoundComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.AbstractMutableContainer extends AbstractNamingContextContainer implements Serializable
- Class com.github.bordertech.wcomponents.AbstractNamingContextContainer extends AbstractContainer implements Serializable
- Class com.github.bordertech.wcomponents.AbstractTableDataModel extends Object implements Serializable
- Class com.github.bordertech.wcomponents.AbstractTableModel extends Object implements Serializable
- Class com.github.bordertech.wcomponents.AbstractTransientDataContainer extends AbstractMutableContainer implements Serializable
- Class com.github.bordertech.wcomponents.AbstractTreeItemModel extends Object implements Serializable
- Class com.github.bordertech.wcomponents.AbstractTreeTableDataModel extends Object implements Serializable
  - Serialized Fields
    - root
```
TableTreeNode root
```
      Deprecated.
      
      The root node for this model.
- Class com.github.bordertech.wcomponents.AbstractWComponent extends Object implements Serializable
  - Serialization Methods
    - writeReplace
```
protected Object writeReplace()
                       throws ObjectStreamException
```
      Implement writeReplace so that on serialization, WComponents that are registered in the UIRegistry write a reference to the registered component rather than the component itself. This ensures that, on deserialization, only one copy of the registered component will be present in the VM.
      
      Throws:
      
      ObjectStreamException - never, but Serializable requires this method signature to declare it.
      
      See Also:
      
      Serializable
  - Serialized Fields
    - locked
```
boolean locked
```
      Indicates whether this component is locked. Trying to update a shared value will result in a runtime exception when a component is locked.
    - sharedModel
```
ComponentModel sharedModel
```
      The shared model for this component.
- Class com.github.bordertech.wcomponents.AbstractWComponent.WComponentRef extends AbstractWComponent implements Serializable
  - Serialization Methods
    - readObject
```
private void readObject(ObjectInputStream in)
                 throws IOException,
                        ClassNotFoundException
```
      Implement readObject to only read in the repositoryKey and nodeLocation fields.
      
      Throws:
      
      IOException - if there is an error reading from the stream.
      
      ClassNotFoundException - if the class can't be found.
      
      See Also:
      
      Serializable
    - writeObject
```
private void writeObject(ObjectOutputStream out)
                  throws IOException
```
      Implement writeObject to only write out the repositoryKey and nodeLocation fields.
      
      Throws:
      
      IOException - if there is an error writing to the stream.
      
      See Also:
      
      Serializable
    - readResolve
```
private Object readResolve()
                    throws ObjectStreamException
```
      Implement readResolve so that on deserialization, the WComponent that is referred to by this WComponentRef is returned. The WComponent
      
      Throws:
      
      ObjectStreamException - never, but Serializable requires this method signature to declare it.
      
      See Also:
      
      Serializable
  - Serialized Fields
    - repositoryKey
```
String repositoryKey
```
      The UIRegistry key under which the UI root component is registered. This is assumed to be the fully qualified class name of the root component.
    - nodeLocation
```
int[] nodeLocation
```
      The location path of the component in the UI tree, specified as child indices.
- Class com.github.bordertech.wcomponents.AbstractWMultiSelectList extends AbstractWSelectList implements Serializable
- Class com.github.bordertech.wcomponents.AbstractWMultiSelectList.MultiSelectionModel extends AbstractWSelectList.SelectionModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.AbstractWSelectList extends AbstractInput implements Serializable
  - Serialized Fields
    - allowNoSelection
```
boolean allowNoSelection
```
      Indicates whether having no selection is allowed.
- Class com.github.bordertech.wcomponents.AbstractWSelectList.SelectionModel extends AbstractInput.InputModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.AbstractWSingleSelectList extends AbstractWSelectList implements Serializable
- Class com.github.bordertech.wcomponents.ActionEscape extends Escape implements Serializable
- Class com.github.bordertech.wcomponents.ActionEvent extends EventObject implements Serializable
  - Serialized Fields
    - actionCommand
```
String actionCommand
```
      A string that specifies a command associated with the event.
    - actionObject
```
Object actionObject
```
      A data object that contains information related to the event.
- Class com.github.bordertech.wcomponents.AdapterBasicTableModel extends Object implements Serializable
  - Serialized Fields
    - model
```
AdapterBasicTableModel.BasicTableModel model
```
      The basic table model to adapt for the WTable.
- Class com.github.bordertech.wcomponents.AjaxOperation extends Object implements Serializable
  - Serialized Fields
    - triggerId
```
String triggerId
```
      The AJAX trigger id (present in the HTTP servlet request) that will trigger this operation.
    - targetIds
```
List<E> targetIds
```
      The list of target components to repaint when this trigger occurs. They do not necessarily need to be contained within one section of the UI, but if containerId is set, they should be.
    - targetContainerId
```
String targetContainerId
```
      Id of a container target.
    - action
```
AjaxOperation.AjaxAction action
```
      The AJAX Action. Defaults to REPLACE.
    - internalAjaxRequest
```
boolean internalAjaxRequest
```
      Flag if AJAX operation is an internal AJAX operation.
- Class com.github.bordertech.wcomponents.AudioResource extends InternalResource implements Serializable
  - Serialized Fields
    - duration
```
int duration
```
      The audio length, if known.
- Class com.github.bordertech.wcomponents.BeanAndProviderBoundComponentModel extends DataBoundComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.BeanBoundComponentModel extends DataBoundComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.BeanProviderBoundComponentModel extends DataBoundComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.CollapsibleGroup extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - collapsibleList
```
List<E> collapsibleList
```
      The list of collapsibles in this group.
    - collapsibleToggle
```
WCollapsibleToggle collapsibleToggle
```
      The Collapsible toggle for this group.
- Class com.github.bordertech.wcomponents.ComponentModel extends Object implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.ComponentWithContext extends Object implements Serializable
  - Serialized Fields
    - component
```
WComponent component
```
      The component.
    - context
```
UIContext context
```
      The context which the component is in.
- Class com.github.bordertech.wcomponents.ContentEscape extends ActionEscape implements Serializable
  - Serialized Fields
    - contentAccess
```
ContentAccess contentAccess
```
      The ContentAccess which will provide the content.
    - cacheable
```
boolean cacheable
```
      A flag if the content can be cached.
    - displayInline
```
boolean displayInline
```
      A flag if the content should be displayed inline, or downloaded.
- Class com.github.bordertech.wcomponents.DataBoundComponentModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.DefaultTransientDataContainer extends AbstractTransientDataContainer implements Serializable
- Class com.github.bordertech.wcomponents.DefaultWComponent extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.EmptyTableDataModel extends AbstractTableDataModel implements Serializable
- Class com.github.bordertech.wcomponents.EmptyTableModel extends AbstractTableModel implements Serializable
- Class com.github.bordertech.wcomponents.EmptyTreeItemModel extends AbstractTreeItemModel implements Serializable
- Class com.github.bordertech.wcomponents.ErrorCodeEscape extends ActionEscape implements Serializable
  - Serialized Fields
    - code
```
int code
```
      Error code to send in the response.
- Class com.github.bordertech.wcomponents.Escape extends RuntimeException implements Serializable
  - Serialized Fields
    - request
```
Request request
```
      The request being responded to.
    - response
```
Response response
```
      The response to the client.
- Class com.github.bordertech.wcomponents.FatalErrorPage extends AbstractWComponent implements Serializable
  - Serialized Fields
    - developerFriendly
```
boolean developerFriendly
```
      Indicates whether additional developer details should be included on the error page.
    - error
```
Throwable error
```
      The unhandled error which caused this component to display.
- Class com.github.bordertech.wcomponents.ForwardException extends ActionEscape implements Serializable
  - Serialized Fields
    - forwardTo
```
String forwardTo
```
      The URL to forward to.
- Class com.github.bordertech.wcomponents.ImageResource extends InternalResource implements Serializable
  - Serialized Fields
    - size
```
Dimension size
```
      The image size, if known.
- Class com.github.bordertech.wcomponents.InitialisationException extends SystemException implements Serializable
- Class com.github.bordertech.wcomponents.IntegrityException extends IllegalStateException implements Serializable
- Class com.github.bordertech.wcomponents.InternalResource extends Object implements Serializable
  - Serialized Fields
    - resourceName
```
String resourceName
```
      The resource name.
    - description
```
String description
```
      The description of the resource.
- Class com.github.bordertech.wcomponents.Margin extends Object implements Serializable
  - Serialized Fields
    - all
```
Size all
```
      The size of the margins on all sides of the panel.
    - top
```
Size top
```
      The size of the north margin.
    - right
```
Size right
```
      The size of the east margin.
    - bottom
```
Size bottom
```
      The size of the south margin.
    - left
```
Size left
```
      The size of the west margin.
    - oldAll
```
int oldAll
```
      Deprecated.
      
      For temporary backwards compatibility only.
    - north
```
int north
```
      Deprecated.
      
      For temporary backwards compatibility only.
    - east
```
int east
```
      Deprecated.
      
      For temporary backwards compatibility only.
    - south
```
int south
```
      Deprecated.
      
      For temporary backwards compatibility only.
    - west
```
int west
```
      Deprecated.
      
      For temporary backwards compatibility only.
- Class com.github.bordertech.wcomponents.Message extends Object implements Serializable
  - Serialized Fields
    - message
```
String message
```
      The content of this message.
    - args
```
Serializable[] args
```
      The message arguments, if applicable.
    - type
```
int type
```
      The type of this message. One of (Message.SUCCESS_MESSAGE, Message.INFO_MESSAGE, Message.WARNING_MESSAGE or Message.ERROR_MESSAGE).
- Class com.github.bordertech.wcomponents.OptionGroup extends Object implements Serializable
  - Serialized Fields
    - options
```
List<E> options
```
      The options contained in this group.
    - description
```
String description
```
      The textual description of this group.
- Class com.github.bordertech.wcomponents.RadioButtonGroup extends AbstractInput implements Serializable
- Class com.github.bordertech.wcomponents.SimpleBeanBoundTableDataModel extends AbstractBeanTableDataModel implements Serializable
  - Serialized Fields
    - comparators
```
Map<K,V> comparators
```
      Deprecated.
      
      The comparators used for sorting, keyed by column index.
    - editable
```
boolean editable
```
      Deprecated.
      
      Indicates whether this model is globally editable.
    - properties
```
String[] properties
```
      Deprecated.
      
      The bean properties for each column.
- Class com.github.bordertech.wcomponents.SimpleBeanBoundTableModel extends AbstractBeanBoundTableModel implements Serializable
  - Serialized Fields
    - comparators
```
Map<K,V> comparators
```
      The comparators used for sorting, keyed by column index.
    - editable
```
boolean editable
```
      Indicates whether this model is globally editable.
    - selectable
```
boolean selectable
```
      Indicates whether rows are globally selectable.
    - levels
```
List<E> levels
```
      Defined levels.
    - iterateFirstLevel
```
boolean iterateFirstLevel
```
      Iterate on the first expandable level.
    - maxIterations
```
int maxIterations
```
      Maximum iterations.
- Class com.github.bordertech.wcomponents.SimpleBeanBoundTableModel.LevelDetails extends Object implements Serializable
  - Serialized Fields
    - levelBeanProperty
```
String levelBeanProperty
```
      The bean property for this level's data (usually a list of beans).
    - columnBeanProperties
```
String[] columnBeanProperties
```
      The column bean properties for the level.
    - renderer
```
Class<T> renderer
```
      The custom renderer for this row.
    - rowPerListItem
```
boolean rowPerListItem
```
      Indicate if the level has as a row per item in the list.
- Class com.github.bordertech.wcomponents.SimpleBeanListTableDataModel extends AbstractTableDataModel implements Serializable
  - Serialized Fields
    - comparators
```
Map<K,V> comparators
```
      The comparators used for sorting, keyed by column index.
    - editable
```
boolean editable
```
      Indicates whether this model is globally editable.
    - data
```
Serializable[] data
```
      The model's data.
    - properties
```
String[] properties
```
      The bean properties for each column.
- Class com.github.bordertech.wcomponents.SimpleBeanTreeTableDataModel extends AbstractTreeTableDataModel implements Serializable
  - Serialized Fields
    - comparators
```
Map<K,V> comparators
```
      Deprecated.
      
      The comparators used for sorting, keyed by column index.
    - editable
```
boolean editable
```
      Deprecated.
      
      Indicates whether this model is globally editable.
    - properties
```
String[] properties
```
      Deprecated.
      
      The bean properties for each column.
- Class com.github.bordertech.wcomponents.SimpleTableDataModel extends AbstractTableDataModel implements Serializable
  - Serialized Fields
    - comparators
```
Map<K,V> comparators
```
      Deprecated.
      
      The comparators used for sorting, keyed by column index.
    - editable
```
boolean editable
```
      Deprecated.
      
      Indicates whether this model is globally editable.
    - data
```
Serializable[][] data
```
      Deprecated.
      
      The model's data.
- Class com.github.bordertech.wcomponents.SimpleTableModel extends AbstractBasicTableModel implements Serializable
  - Serialized Fields
    - comparators
```
Map<K,V> comparators
```
      The comparators used for sorting, keyed by column index.
    - editable
```
boolean editable
```
      Indicates whether this model is globally editable.
    - data
```
Serializable[][] data
```
      The model's data.
- Class com.github.bordertech.wcomponents.TableTreeNode extends AbstractTreeNode implements Serializable
  - Serialized Fields
    - expanded
```
boolean expanded
```
      Deprecated.
      
      Indicates whether this node is in the expanded state.
    - data
```
Serializable data
```
      Deprecated.
      
      This node's data.
    - rendererClass
```
Class<T> rendererClass
```
      Deprecated.
      
      The renderer class for this row.
    - rendererSpansAllCols
```
boolean rendererSpansAllCols
```
      Deprecated.
      
      Indicates whether the custom renderer spans the entire row.
    - nodeCount
```
int nodeCount
```
      Deprecated.
      
      For quick counting of nodes.
- Class com.github.bordertech.wcomponents.TreeItemIdNode extends Object implements Serializable
  - Serialized Fields
    - itemId
```
String itemId
```
      The tree item id.
    - children
```
List<E> children
```
      The list of this nodes children.
    - hasChildren
```
boolean hasChildren
```
      True if this node has children. Allows it be set true with out actually loading the children.
- Class com.github.bordertech.wcomponents.TreeItemImage extends Object implements Serializable
  - Serialized Fields
    - url
```
String url
```
      The URL for an image.
    - image
```
Image image
```
      The image content.
    - imageCacheKey
```
String imageCacheKey
```
      The image cache key.
- Class com.github.bordertech.wcomponents.UIContextDelegate extends Object implements Serializable
  - Serialized Fields
    - backing
```
UIContext backing
```
      The backing context.
- Class com.github.bordertech.wcomponents.UIContextImpl extends Object implements Serializable
  - Serialized Fields
    - ui
```
WComponent ui
```
      The root component for this context.
    - creationTime
```
long creationTime
```
      The UIContext's creation time.
    - map
```
Map<K,V> map
```
      A map of component models, keyed by the component that they belong to.
    - attribMap
```
Map<K,V> attribMap
```
      The framework attribute map.
    - environment
```
Environment environment
```
      The environment which this context is running in.
    - locale
```
Locale locale
```
      The locale for this context.
- Class com.github.bordertech.wcomponents.UicProfileButton extends WButton implements Serializable
- Class com.github.bordertech.wcomponents.UserAgentInfo extends Object implements Serializable
  - Serialized Fields
    - browserVersion
```
byte browserVersion
```
      The browser version.
- Class com.github.bordertech.wcomponents.VideoResource extends InternalResource implements Serializable
  - Serialized Fields
    - size
```
Dimension size
```
      The video size, if known.
    - duration
```
int duration
```
      The video length, if known.
- Class com.github.bordertech.wcomponents.WAbbrText extends WText implements Serializable
- Class com.github.bordertech.wcomponents.WAjaxControl extends AbstractWComponent implements Serializable
  - Serialized Fields
    - trigger
```
AjaxTrigger trigger
```
      The component that will trigger the AJAX request.
- Class com.github.bordertech.wcomponents.WAjaxControl.AjaxControlModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WAjaxPollingRegion extends WPanel implements Serializable
  - Serialized Fields
    - control
```
WAjaxControl control
```
      Deprecated.
      
      The WAjaxControl control to perform polling.
- Class com.github.bordertech.wcomponents.WApplication extends AbstractMutableContainer implements Serializable
- Class com.github.bordertech.wcomponents.WApplication.ApplicationResource extends Object implements Serializable
  - Serialized Fields
    - resourceId
```
String resourceId
```
      Unique resource id.
    - url
```
String url
```
      Resource URL.
    - resource
```
InternalResource resource
```
      Internal resource.
- Class com.github.bordertech.wcomponents.WApplication.WApplicationModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WAudio extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.WAudio.AudioModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WBeanComponent extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.WBeanContainer extends WContainer implements Serializable
- Class com.github.bordertech.wcomponents.WButton extends WBeanComponent implements Serializable
  - Serialized Fields
    - buttonImage
```
com.github.bordertech.wcomponents.WButton.ButtonImage buttonImage
```
      A holder for a button image, if set.
- Class com.github.bordertech.wcomponents.WButton.ButtonModel extends BeanAndProviderBoundComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WCancelButton extends WButton implements Serializable
- Class com.github.bordertech.wcomponents.WCardManager extends AbstractMutableContainer implements Serializable
  - Serialized Fields
    - cardContainer
```
WInvisibleContainer cardContainer
```
      Cards are added to this container to exclude them from standard processing.
- Class com.github.bordertech.wcomponents.WCardManager.CardManagerModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WCheckBox extends AbstractInput implements Serializable
- Class com.github.bordertech.wcomponents.WCheckBox.CheckBoxModel extends AbstractInput.InputModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WCheckBoxSelect extends AbstractWMultiSelectList implements Serializable
- Class com.github.bordertech.wcomponents.WCheckBoxSelect.CheckBoxSelectModel extends AbstractWMultiSelectList.MultiSelectionModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WCollapsible extends AbstractNamingContextContainer implements Serializable
  - Serialized Fields
    - content
```
WComponent content
```
      The content to display inside the collapsible.
    - label
```
WDecoratedLabel label
```
      The label for the collapsible's heading.
- Class com.github.bordertech.wcomponents.WCollapsible.CollapsibleModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WCollapsibleToggle extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.WCollapsibleToggle.CollapsibleModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WColumn extends AbstractMutableContainer implements Serializable
- Class com.github.bordertech.wcomponents.WColumn.ColumnModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WColumnLayout extends AbstractNamingContextContainer implements Serializable
  - Serialized Fields
    - row
```
WRow row
```
      The row which contains the columns.
    - leftColumn
```
WColumn leftColumn
```
      The left column.
    - rightColumn
```
WColumn rightColumn
```
      The right column.
- Class com.github.bordertech.wcomponents.WComponentGroup extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.WComponentGroup.ComponentGroupModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WConfirmationButton extends WButton implements Serializable
- Class com.github.bordertech.wcomponents.WContainer extends WBeanComponent implements Serializable
- Class com.github.bordertech.wcomponents.WContent extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.WContent.ContentModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WContentLink extends AbstractContainer implements Serializable
  - Serialized Fields
    - content
```
WContent content
```
      The content to be displayed in the window.
    - link
```
WLink link
```
      The link used to open the window containing the content.
- Class com.github.bordertech.wcomponents.WDataRenderer extends WContainer implements Serializable
- Class com.github.bordertech.wcomponents.WDataTable extends WBeanComponent implements Serializable
  - Serialized Fields
    - columns
```
WContainer columns
```
      Deprecated.
      
      For easy access to the columns, including the ability to hide them all at once.
    - repeater
```
WRepeater repeater
```
      Deprecated.
      
      The repeater that is used to handle the repeated (row) content.
    - actions
```
WContainer actions
```
      Deprecated.
      
      Table actions, which are normally visible at the bottom of the table.
    - rowHeaderColumn
```
WTableColumn rowHeaderColumn
```
      Deprecated.
      
      The table column for the row headers.
- Class com.github.bordertech.wcomponents.WDataTable.ActionConstraint extends Object implements Serializable
  - Serialized Fields
    - minSelectedRowCount
```
int minSelectedRowCount
```
      The minimum number of rows which must be selected to fulfil the constraint.
    - maxSelectedRowCount
```
int maxSelectedRowCount
```
      The maximum number of rows which must be selected to fulfil the constraint.
    - error
```
boolean error
```
      True if the constaint is an error, false for a warning.
    - message
```
String message
```
      The message to display when the constraint is not met.
- Class com.github.bordertech.wcomponents.WDataTable.TableModel extends BeanAndProviderBoundComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WDataTableRowRenderer extends WDataRenderer implements Serializable
  - Serialized Fields
    - table
```
WDataTable table
```
      Deprecated.
      
      The table that this renderer belongs to.
    - rowHeader
```
WDecoratedLabel rowHeader
```
      Deprecated.
      
      The row header.
    - expandedRenderers
```
Map<K,V> expandedRenderers
```
      Deprecated.
      
      A Map of expanded renderers.
- Class com.github.bordertech.wcomponents.WDateField extends AbstractInput implements Serializable
  - Serialized Fields
    - lenient
```
boolean lenient
```
      Indicates whether date parsing is lenient.
- Class com.github.bordertech.wcomponents.WDateField.DateFieldModel extends AbstractInput.InputModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WDecoratedLabel extends AbstractMutableContainer implements Serializable
- Class com.github.bordertech.wcomponents.WDecoratedLabel.DecoratedLabelModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WDefinitionList extends AbstractNamingContextContainer implements Serializable
  - Serialized Fields
    - content
```
WContainer content
```
      Content is added to this hidden container, so nothing can be added to the definition list directly.
- Class com.github.bordertech.wcomponents.WDefinitionList.DefinitionListModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WDialog extends AbstractWComponent implements Serializable
  - Serialized Fields
    - holder
```
WNamingContext holder
```
      The content holder exists to keep the content hidden from normal requests, yet still have the content attached to the wcomponent tree. Being part of the tree enables embedded targetables and other components to be found.
      The holder is a naming context to make the ids in the dialog all unique and have the same prefix.
- Class com.github.bordertech.wcomponents.WDialog.DialogModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WDropdown extends AbstractWSingleSelectList implements Serializable
- Class com.github.bordertech.wcomponents.WDropdown.DropdownModel extends AbstractWSelectList.SelectionModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WEditableImage extends WImage implements Serializable
- Class com.github.bordertech.wcomponents.WEditableImage.EditableImageModel extends WImage.ImageModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WEmailField extends AbstractInput implements Serializable
- Class com.github.bordertech.wcomponents.WEmailField.EmailFieldModel extends AbstractInput.InputModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WField extends AbstractContainer implements Serializable
  - Serialized Fields
    - label
```
WLabel label
```
      The label for the field.
    - field
```
WComponent field
```
      The component for the field.
    - warningIndicator
```
WFieldWarningIndicator warningIndicator
```
      The warning indicator for the field.
    - errorIndicator
```
WFieldErrorIndicator errorIndicator
```
      The error indicator for the field.
- Class com.github.bordertech.wcomponents.WField.FieldModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WFieldLayout extends AbstractNamingContextContainer implements Serializable
- Class com.github.bordertech.wcomponents.WFieldLayout.FieldLayoutModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WFieldSet extends AbstractMutableContainer implements Serializable
  - Serialized Fields
    - title
```
WDecoratedLabel title
```
      The frameset title.
- Class com.github.bordertech.wcomponents.WFieldSet.FieldSetModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WFigure extends AbstractNamingContextContainer implements Serializable
  - Serialized Fields
    - label
```
WDecoratedLabel label
```
      The label for the figure.
    - content
```
WComponent content
```
      The content for the figure.
- Class com.github.bordertech.wcomponents.WFigure.FigureModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WFileWidget extends AbstractInput implements Serializable
- Class com.github.bordertech.wcomponents.WFileWidget.FileWidgetModel extends AbstractInput.InputModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WFilterText extends WText implements Serializable
- Class com.github.bordertech.wcomponents.WFilterText.FilterTextModel extends WText.TextModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WHeading extends WText implements Serializable
  - Serialized Fields
    - label
```
WDecoratedLabel label
```
      The label for the heading.
- Class com.github.bordertech.wcomponents.WHeading.HeadingModel extends WText.TextModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WHiddenComment extends WBeanComponent implements Serializable
- Class com.github.bordertech.wcomponents.WHorizontalRule extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.WImage extends WBeanComponent implements Serializable
- Class com.github.bordertech.wcomponents.WImage.ImageModel extends BeanAndProviderBoundComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WImageEditor extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.WImageEditor.ImageEditModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WInternalLink extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.WInternalLink.InternalLinkModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WInvisibleContainer extends AbstractMutableContainer implements Serializable
- Class com.github.bordertech.wcomponents.WLabel extends AbstractMutableContainer implements Serializable
- Class com.github.bordertech.wcomponents.WLabel.LabelModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WLink extends WBeanComponent implements Serializable
  - Serialized Fields
    - linkImage
```
com.github.bordertech.wcomponents.WLink.LinkImage linkImage
```
      A holder for a link image, if set.
- Class com.github.bordertech.wcomponents.WLink.LinkModel extends BeanAndProviderBoundComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WLink.WindowAttributes extends Object implements Serializable
  - Serialized Fields
    - link
```
WLink link
```
      The link which these window attributes belong to. Used to enforce locking.
    - windowName
```
String windowName
```
      The name of the window to open.
    - resizable
```
boolean resizable
```
      Indicates whether the new window should be resizable.
    - scrollbars
```
boolean scrollbars
```
      Indicates whether the new window should have scrollbars.
    - toolbars
```
boolean toolbars
```
      Indicates whether the new window should have toolbars.
    - location
```
boolean location
```
      Indicates whether the new window should have the location bar.
    - directories
```
boolean directories
```
      Indicates whether the new window should show directory buttons.
    - status
```
boolean status
```
      Indicates whether the new window should show the status bar.
    - menubar
```
boolean menubar
```
      Indicates whether the new window should show a menu bar.
    - left
```
int left
```
      The x-coordinate of the new window.
    - top
```
int top
```
      The y-coordinate of the new window.
    - width
```
int width
```
      The width of the new window.
    - height
```
int height
```
      The height of the new window.
- Class com.github.bordertech.wcomponents.WList extends WRepeater implements Serializable
  - Serialized Fields
    - space
```
Size space
```
      The space between the components in the list.
    - gap
```
int gap
```
      Deprecated.
      
      For temporary backwards compatibility only.
- Class com.github.bordertech.wcomponents.WList.ListModel extends WRepeater.RepeaterModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WMenu extends AbstractNamingContextContainer implements Serializable
  - Serialized Fields
    - type
```
WMenu.MenuType type
```
      The type of menu.
    - content
```
WContainer content
```
      Hold the menu's items.
- Class com.github.bordertech.wcomponents.WMenu.MenuModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WMenuItem extends AbstractContainer implements Serializable
  - Serialized Fields
    - label
```
WDecoratedLabel label
```
      The decorated label which holds the menu item's text/icon etc.
- Class com.github.bordertech.wcomponents.WMenuItem.MenuItemModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WMenuItemGroup extends AbstractContainer implements Serializable
  - Serialized Fields
    - label
```
WDecoratedLabel label
```
      Deprecated.
      
      Menu item group label.
    - content
```
WContainer content
```
      Deprecated.
      
      Menu group items.
- Class com.github.bordertech.wcomponents.WMessageBox extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.WMessageBox.MessageModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WMessages extends WPanel implements Serializable
  - Serialized Fields
    - successMessages
```
WMessageBox successMessages
```
      The message box used to display "success" messages.
    - infoMessages
```
WMessageBox infoMessages
```
      The message box used to display "information" messages.
    - warningMessages
```
WMessageBox warningMessages
```
      The message box used to display "warning" messages.
    - errorMessages
```
WMessageBox errorMessages
```
      The message box used to display "error" messages.
    - validationErrors
```
WValidationErrors validationErrors
```
      The message box used to display validation errors.
- Class com.github.bordertech.wcomponents.WMessagesValidatingAction extends ValidatingAction implements Serializable
- Class com.github.bordertech.wcomponents.WMultiDropdown extends AbstractWMultiSelectList implements Serializable
- Class com.github.bordertech.wcomponents.WMultiFileWidget extends AbstractInput implements Serializable
- Class com.github.bordertech.wcomponents.WMultiFileWidget.FileWidgetUpload extends Object implements Serializable
  - Serialized Fields
    - fileId
```
String fileId
```
      File identifier.
    - file
```
File file
```
      The file content.
    - thumbnail
```
Image thumbnail
```
      Thumbnail image.
    - fileCacheKey
```
String fileCacheKey
```
      File cache key.
    - thumbnailCacheKey
```
String thumbnailCacheKey
```
      Thumbnail cache key.
- Class com.github.bordertech.wcomponents.WMultiFileWidget.MultiFileWidgetModel extends AbstractInput.InputModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WMultiSelect extends AbstractWMultiSelectList implements Serializable
- Class com.github.bordertech.wcomponents.WMultiSelect.MultiSelectModel extends AbstractWMultiSelectList.MultiSelectionModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WMultiSelectPair extends WMultiSelect implements Serializable
- Class com.github.bordertech.wcomponents.WMultiSelectPair.MultiSelectPairModel extends WMultiSelect.MultiSelectModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WMultiTextField extends AbstractInput implements Serializable
- Class com.github.bordertech.wcomponents.WMultiTextField.MultiTextFieldModel extends AbstractInput.InputModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WNamingContext extends WContainer implements Serializable
- Class com.github.bordertech.wcomponents.WNumberField extends AbstractInput implements Serializable
- Class com.github.bordertech.wcomponents.WNumberField.NumberFieldModel extends AbstractInput.InputModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WPanel extends WContainer implements Serializable
- Class com.github.bordertech.wcomponents.WPanel.PanelModel extends BeanAndProviderBoundComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WPartialDateField extends AbstractInput implements Serializable
- Class com.github.bordertech.wcomponents.WPartialDateField.PartialDateFieldModel extends AbstractInput.InputModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WPasswordField extends AbstractInput implements Serializable
- Class com.github.bordertech.wcomponents.WPasswordField.PasswordFieldModel extends AbstractInput.InputModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WPhoneNumberField extends AbstractInput implements Serializable
- Class com.github.bordertech.wcomponents.WPhoneNumberField.PhoneFieldModel extends AbstractInput.InputModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WPopup extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.WPopup.PopupModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WPrintButton extends WButton implements Serializable
- Class com.github.bordertech.wcomponents.WProgressBar extends WBeanComponent implements Serializable
- Class com.github.bordertech.wcomponents.WProgressBar.WProgressBarModel extends BeanAndProviderBoundComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WRadioButton extends WBeanComponent implements Serializable
  - Serialized Fields
    - group
```
RadioButtonGroup group
```
      The RadioButtonGroup the button belongs to.
- Class com.github.bordertech.wcomponents.WRadioButtonSelect extends AbstractWSingleSelectList implements Serializable
- Class com.github.bordertech.wcomponents.WRadioButtonSelect.RadioButtonSelectModel extends WSingleSelect.SingleSelectModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WRepeater extends WBeanComponent implements Serializable
- Class com.github.bordertech.wcomponents.WRepeater.RepeaterModel extends BeanAndProviderBoundComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WRepeater.SubUIContext extends UIContextDelegate implements Serializable
  - Serialized Fields
    - rowIndex
```
int rowIndex
```
      The row index in the repeater.
    - rowRenderId
```
String rowRenderId
```
      The row render id to keep the ids unique for each sub context and process handle request correctly.
    - rowId
```
Object rowId
```
      The row bean in the repeater.
    - repeatRoot
```
WRepeater.WRepeatRoot repeatRoot
```
      The repeater's repeat root.
    - contextId
```
int contextId
```
      The context id.
    - componentModels
```
Map<K,V> componentModels
```
      A map of Component models, keyed by the component which they belong to.
- Class com.github.bordertech.wcomponents.WRepeater.WRepeatRoot extends WBeanComponent implements Serializable
  - Serialized Fields
    - repeater
```
WRepeater repeater
```
      Parent repeater.
- Class com.github.bordertech.wcomponents.WRow extends AbstractNamingContextContainer implements Serializable
  - Serialized Fields
    - space
```
Size space
```
      The horizontal space between the columns in the row, measured in pixels.
    - gap
```
int gap
```
      Deprecated.
      
      For temporary backwards compatibility only.
- Class com.github.bordertech.wcomponents.WRow.RowModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WSection extends AbstractNamingContextContainer implements Serializable
  - Serialized Fields
    - label
```
WDecoratedLabel label
```
      The label for the section.
    - content
```
WPanel content
```
      The content for the section.
- Class com.github.bordertech.wcomponents.WSection.SectionModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WSelectToggle extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.WSelectToggle.SelectToggleModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WSeparator extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.WShuffler extends AbstractInput implements Serializable
- Class com.github.bordertech.wcomponents.WShuffler.ShufflerModel extends AbstractInput.InputModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WSingleSelect extends AbstractWSingleSelectList implements Serializable
- Class com.github.bordertech.wcomponents.WSingleSelect.SingleSelectModel extends AbstractWSelectList.SelectionModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WSkipLinks extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.WStyledText extends WText implements Serializable
- Class com.github.bordertech.wcomponents.WStyledText.StyledTextModel extends WText.TextModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WSubMenu extends AbstractNamingContextContainer implements Serializable
  - Serialized Fields
    - label
```
WDecoratedLabel label
```
      The submenu's text label.
    - content
```
WContainer content
```
      Hold the submenu's items.
- Class com.github.bordertech.wcomponents.WSubMenu.SubMenuModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WSuggestions extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.WSuggestions.SuggestionsModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WTab extends AbstractNamingContextContainer implements Serializable
  - Serialized Fields
    - label
```
WDecoratedLabel label
```
      The tab label.
- Class com.github.bordertech.wcomponents.WTab.TabModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WTabGroup extends AbstractContainer implements Serializable
- Class com.github.bordertech.wcomponents.WTable extends WBeanComponent implements Serializable
  - Serialized Fields
    - columns
```
WContainer columns
```
      Hold columns.
    - footers
```
WContainer footers
```
      Hold column footers.
    - repeater
```
WTable.TableRepeater repeater
```
      The repeater that is used to handle the repeated (row) content.
    - actions
```
WContainer actions
```
      Table actions, which are normally visible at the bottom of the table.
- Class com.github.bordertech.wcomponents.WTable.ActionConstraint extends Object implements Serializable
  - Serialized Fields
    - minSelectedRowCount
```
int minSelectedRowCount
```
      The minimum number of rows which must be selected to fulfil the constraint.
    - maxSelectedRowCount
```
int maxSelectedRowCount
```
      The maximum number of rows which must be selected to fulfil the constraint.
    - error
```
boolean error
```
      True if the constraint is an error, false for a warning.
    - message
```
String message
```
      The message to display when the constraint is not met.
- Class com.github.bordertech.wcomponents.WTable.RowIdWrapper extends Object implements Serializable
  - Serialized Fields
    - rowIndex
```
List<E> rowIndex
```
      The row index.
    - rowKey
```
Object rowKey
```
      The row key.
    - children
```
List<E> children
```
      The children of the row.
    - hasChildrenFlag
```
boolean hasChildrenFlag
```
      Flag if row has children.
    - parent
```
WTable.RowIdWrapper parent
```
      Parent of the row.
    - position
```
int position
```
      Hold its position in the list.
- Class com.github.bordertech.wcomponents.WTable.TableRepeater extends WRepeater implements Serializable
  - Serialized Fields
    - table
```
WTable table
```
      Parent table.
- Class com.github.bordertech.wcomponents.WTable.WTableComponentModel extends BeanAndProviderBoundComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WTableColumn extends AbstractContainer implements Serializable
  - Serialized Fields
    - rendererClass
```
Class<T> rendererClass
```
      The renderer class that will be used to render row data for this column.
    - renderer
```
WComponent renderer
```
      The renderer that will be used to render row data for this column.
    - label
```
WDecoratedLabel label
```
      The table column heading, which may contain complex content.
    - footerRender
```
WComponent footerRender
```
      The renderer that will be used to render the footer for this column.
- Class com.github.bordertech.wcomponents.WTableColumn.WTableColumnModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WTableRepeater extends WRepeater implements Serializable
  - Serialized Fields
    - table
```
WDataTable table
```
      Deprecated.
      
      Parent table.
- Class com.github.bordertech.wcomponents.WTableRowRenderer extends WDataRenderer implements Serializable
  - Serialized Fields
    - table
```
WTable table
```
      The table that this renderer belongs to.
    - expandedRenderers
```
Map<K,V> expandedRenderers
```
      A Map of expanded renderers.
- Class com.github.bordertech.wcomponents.WTabSet extends AbstractNamingContextContainer implements Serializable
- Class com.github.bordertech.wcomponents.WTabSet.TabSetModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WTemplate extends WBeanComponent implements Serializable
- Class com.github.bordertech.wcomponents.WTemplate.TemplateModel extends BeanAndProviderBoundComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WText extends WBeanComponent implements Serializable
- Class com.github.bordertech.wcomponents.WText.TextModel extends BeanAndProviderBoundComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WTextArea extends WTextField implements Serializable
- Class com.github.bordertech.wcomponents.WTextArea.TextAreaModel extends WTextField.TextFieldModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WTextField extends AbstractInput implements Serializable
- Class com.github.bordertech.wcomponents.WTextField.TextFieldModel extends AbstractInput.InputModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WTimeoutWarning extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.WTimeoutWarning.TimeoutWarningModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WToggleButton extends WCheckBox implements Serializable
- Class com.github.bordertech.wcomponents.WToggleButton.ToggleButtonModel extends WCheckBox.CheckBoxModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WTree extends AbstractInput implements Serializable
- Class com.github.bordertech.wcomponents.WTree.WTreeComponentModel extends AbstractInput.InputModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WVideo extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.WVideo.VideoModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.WWindow extends AbstractWComponent implements Serializable
  - Serialized Fields
    - holderNamingContext
```
WNamingContext holderNamingContext
```
      Holder naming context.
    - holder
```
WInvisibleContainer holder
```
      The content holder exists to keep the content hidden from normal requests, yet still have the content attached to the wcomponent tree. Being part of the tree enables embedded targetables and other components to be found.
- Class com.github.bordertech.wcomponents.WWindow.WindowModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
Package com.github.bordertech.wcomponents.autocomplete
Package com.github.bordertech.wcomponents.container
- Class com.github.bordertech.wcomponents.container.AbstractContainerHelper.UIContextWrap extends UIContextDelegate implements Serializable
- Class com.github.bordertech.wcomponents.container.AjaxCleanupInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.AjaxDebugStructureInterceptor extends DebugStructureInterceptor implements Serializable
- Class com.github.bordertech.wcomponents.container.AjaxErrorInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.AjaxInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.AjaxPageShellInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.AjaxSetupInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.AjaxTriggerException extends SystemException implements Serializable
- Class com.github.bordertech.wcomponents.container.ContextCleanupInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.DataListInterceptor extends InterceptorComponent implements Serializable
  - Serialized Fields
    - key
```
String key
```
      The data list key is stored for use during the paint phase.
- Class com.github.bordertech.wcomponents.container.DebugStructureInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.FormInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.HeadLineInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.InterceptorComponent extends Object implements Serializable
  - Serialized Fields
    - backing
```
WebComponent backing
```
      The top-level WComponent for the UI that is being served.
    - response
```
Response response
```
      The response that can be used by the interceptor, if required.
- Class com.github.bordertech.wcomponents.container.PageShellInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.ResponseCacheInterceptor extends InterceptorComponent implements Serializable
  - Serialized Fields
    - type
```
ResponseCacheInterceptor.CacheType type
```
      Caching type.
- Class com.github.bordertech.wcomponents.container.SessionTokenAjaxInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.SessionTokenContentInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.SessionTokenException extends SystemException implements Serializable
- Class com.github.bordertech.wcomponents.container.SessionTokenInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.SubordinateControlInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.TargetableErrorInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.TargetableIdException extends SystemException implements Serializable
- Class com.github.bordertech.wcomponents.container.TargetableInterceptor extends InterceptorComponent implements Serializable
  - Serialized Fields
    - targetId
```
String targetId
```
      The id of the targeted component.
- Class com.github.bordertech.wcomponents.container.TemplateRenderInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.TransformXMLInterceptor extends InterceptorComponent implements Serializable
  - Serialized Fields
    - doTransform
```
boolean doTransform
```
      If true then server side XSLT will be ignored regardless of the configuration property. This is to account for user agents that cannot handle HTML, yes such a thing exists.
    - debugRequested
```
boolean debugRequested
```
      If true then we will inject the debug parameter into the XSLT. Note that the debug version of the XSLT itself will not be used, nor will backend debug mode be enabled. This is purely to facilitate debugging client side issues.
- Class com.github.bordertech.wcomponents.container.UIContextDumpInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.ValidateXMLInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.VelocityInterceptor extends InterceptorComponent implements Serializable
  - Serialized Fields
    - templateUrl
```
String templateUrl
```
      Deprecated.
      
      The velocity template's URL.
- Class com.github.bordertech.wcomponents.container.WhitespaceFilterInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.WrongStepAjaxInterceptor extends InterceptorComponent implements Serializable
  - Serialized Fields
    - triggerId
```
String triggerId
```
      The AJAX trigger ID.
    - redirectUrl
```
String redirectUrl
```
      The redirect url if a step error occurred.
- Class com.github.bordertech.wcomponents.container.WrongStepContentInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.WrongStepServerInterceptor extends InterceptorComponent implements Serializable
- Class com.github.bordertech.wcomponents.container.WWindowInterceptor extends InterceptorComponent implements Serializable
  - Serialized Fields
    - windowId
```
String windowId
```
      The ID of the component being targeted by the content helper servlet.
    - attachWindow
```
boolean attachWindow
```
      Flag if window should be attached to chain.
Package com.github.bordertech.wcomponents.file
- Class com.github.bordertech.wcomponents.file.FileItemWrap extends Object implements Serializable
  - Serialized Fields
    - backing
```
org.apache.commons.fileupload.FileItem backing
```
      The file item backing this instance.
Package com.github.bordertech.wcomponents.layout
- Class com.github.bordertech.wcomponents.layout.BorderLayout extends Object implements Serializable
  - Serialized Fields
    - hSpace
```
Size hSpace
```
      Deprecated.
      
      The horizontal gap between the west, center and east cells, measured in pixels.
    - vSpace
```
Size vSpace
```
      Deprecated.
      
      The vertical gap between the north cell, middle row and south cell, measured in pixels.
    - hgap
```
int hgap
```
      Deprecated.
      
      For temporary backwards compatibility only.
    - vgap
```
int vgap
```
      Deprecated.
      
      For temporary backwards compatibility only.
- Class com.github.bordertech.wcomponents.layout.ColumnLayout extends Object implements Serializable
  - Serialized Fields
    - columnWidths
```
int[] columnWidths
```
      The column widths.
    - columnAlignments
```
ColumnLayout.Alignment[] columnAlignments
```
      The column alignments.
    - hSpace
```
Size hSpace
```
      The horizontal gap between the columns.
    - vSpace
```
Size vSpace
```
      The vertical gap between the rows.
    - hgap
```
int hgap
```
      Deprecated.
      
      For temporary backwards compatibility only.
    - vgap
```
int vgap
```
      Deprecated.
      
      For temporary backwards compatibility only.
- Class com.github.bordertech.wcomponents.layout.FlowLayout extends Object implements Serializable
  - Serialized Fields
    - alignment
```
FlowLayout.Alignment alignment
```
      The alignment of components added to the FlowLayout.
    - space
```
Size space
```
      The space between components added to the FlowLayout. The direction of the space is determined by the Alignment.
    - gap
```
int gap
```
      Deprecated.
      
      For temporary backwards compatibility only.
    - contentAlignment
```
FlowLayout.ContentAlignment contentAlignment
```
      The relative vertical alignment of content in each cell.
- Class com.github.bordertech.wcomponents.layout.GridLayout extends Object implements Serializable
  - Serialized Fields
    - rows
```
int rows
```
      The number of rows, or 0 for a dynamic number of rows based on the number of components and columns.
    - cols
```
int cols
```
      The number of columns, or 0 for a dynamic number of columns based on the number of components and columns.
    - hSpace
```
Size hSpace
```
      The horizontal space between the columns.
    - vSpace
```
Size vSpace
```
      The vertical space between the rows.
    - hgap
```
int hgap
```
      Deprecated.
      
      For temporary backwards compatibility only.
    - vgap
```
int vgap
```
      Deprecated.
      
      For temporary backwards compatibility only.
- Class com.github.bordertech.wcomponents.layout.ListLayout extends Object implements Serializable
  - Serialized Fields
    - alignment
```
ListLayout.Alignment alignment
```
      The list alignment.
    - type
```
ListLayout.Type type
```
      The list type.
    - separator
```
ListLayout.Separator separator
```
      The list separator.
    - ordered
```
boolean ordered
```
      The list alignment.
    - space
```
Size space
```
      The space between the components added to the layout.
    - gap
```
int gap
```
      Deprecated.
      
      For temporary backwards compatibility only.
Package com.github.bordertech.wcomponents.monitor
- Class com.github.bordertech.wcomponents.monitor.ProfileContainer extends AbstractMutableContainer implements Serializable
Package com.github.bordertech.wcomponents.render.webxml
- Class com.github.bordertech.wcomponents.render.webxml.AbstractWebXmlRenderer extends Object implements Serializable
- Class com.github.bordertech.wcomponents.render.webxml.VelocityRenderer extends Object implements Serializable
  - Serialized Fields
    - url
```
String url
```
      Deprecated.
      
      The URL of the velocity template to use when rendering.
Package com.github.bordertech.wcomponents.servlet
- Class com.github.bordertech.wcomponents.servlet.HttpServletHelper.HttpServletEnvironment extends AbstractEnvironment implements Serializable
  - Serialized Fields
    - subsessionId
```
int subsessionId
```
      The subsession id for this environment.
- Class com.github.bordertech.wcomponents.servlet.NoContextException extends SystemException implements Serializable
- Class com.github.bordertech.wcomponents.servlet.SubSessionHttpServletRequestWrapper.HttpSubSession extends Object implements Serializable
  - Serialized Fields
    - attributes
```
Map<K,V> attributes
```
      The map which stores the session attributes.
    - maxInactiveInterval
```
int maxInactiveInterval
```
      The maximum interval before a sub-session can be invalidated due to inactivity, specified in milliseconds.
    - creationTime
```
long creationTime
```
      The timestamp when the sub-session was created.
    - lastAccessedTime
```
long lastAccessedTime
```
      The timestamp when the sub-session was last accessed by the user.
    - sessionId
```
int sessionId
```
      The subsession id, unique per user HTTP session.
    - invalid
```
boolean invalid
```
      A flag indicating whether this sub-session has been invalidated.
    - backing
```
javax.servlet.http.HttpSession backing
```
      The backing HTTP session.
- Class com.github.bordertech.wcomponents.servlet.ThemeServlet extends javax.servlet.http.HttpServlet implements Serializable
- Class com.github.bordertech.wcomponents.servlet.WServlet extends javax.servlet.http.HttpServlet implements Serializable
  - Serialized Fields
    - noUI
```
WComponent noUI
```
      The component to serve up when no UI has been specified.
- Class com.github.bordertech.wcomponents.servlet.WServlet.WServletEnvironment extends HttpServletHelper.HttpServletEnvironment implements Serializable
Package com.github.bordertech.wcomponents.subordinate
- Class com.github.bordertech.wcomponents.subordinate.AbstractAction extends Object implements Serializable
  - Serialized Fields
    - target
```
SubordinateTarget target
```
      The target of the action.
    - value
```
Object value
```
      The value to be used in the action.
    - targetInGroup
```
SubordinateTarget targetInGroup
```
      The single component within a group that will be act upon.
- Class com.github.bordertech.wcomponents.subordinate.AbstractCompare extends AbstractCondition implements Serializable
  - Serialized Fields
    - trigger
```
SubordinateTrigger trigger
```
      The first argument (trigger).
    - value
```
Object value
```
      The second argument (compare value).
- Class com.github.bordertech.wcomponents.subordinate.AbstractCondition extends Object implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.AbstractSetEnable extends AbstractAction implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.AbstractSetMandatory extends AbstractAction implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.AbstractSetVisible extends AbstractAction implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.And extends AbstractCondition implements Serializable
  - Serialized Fields
    - conditions
```
List<E> conditions
```
      The list of conditions.
- Class com.github.bordertech.wcomponents.subordinate.Disable extends AbstractSetEnable implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.DisableInGroup extends AbstractSetEnable implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.Enable extends AbstractSetEnable implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.EnableInGroup extends AbstractSetEnable implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.Equal extends AbstractCompare implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.GreaterThan extends AbstractCompare implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.GreaterThanOrEqual extends AbstractCompare implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.Hide extends AbstractSetVisible implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.HideInGroup extends AbstractSetVisible implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.LessThan extends AbstractCompare implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.LessThanOrEqual extends AbstractCompare implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.Mandatory extends AbstractSetMandatory implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.Match extends AbstractCompare implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.Not extends AbstractCondition implements Serializable
  - Serialized Fields
    - condition
```
Condition condition
```
      The list of conditions.
- Class com.github.bordertech.wcomponents.subordinate.NotEqual extends AbstractCompare implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.Optional extends AbstractSetMandatory implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.Or extends AbstractCondition implements Serializable
  - Serialized Fields
    - conditions
```
List<E> conditions
```
      The list of conditions.
- Class com.github.bordertech.wcomponents.subordinate.Rule extends Object implements Serializable
  - Serialized Fields
    - condition
```
Condition condition
```
      The condition to determine which actions to execute (the IF).
    - onTrue
```
List<E> onTrue
```
      The actions to execute if the condition is true (the THEN).
    - onFalse
```
List<E> onFalse
```
      The actions to execute if the condition is false (the ELSE).
- Class com.github.bordertech.wcomponents.subordinate.Show extends AbstractSetVisible implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.ShowInGroup extends AbstractSetVisible implements Serializable
- Class com.github.bordertech.wcomponents.subordinate.WSubordinateControl extends AbstractWComponent implements Serializable
  - Serialized Fields
    - rules
```
List<E> rules
```
      The list of rules to execute.
Package com.github.bordertech.wcomponents.subordinate.builder
- Class com.github.bordertech.wcomponents.subordinate.builder.CompareExpression extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - type
```
AbstractCompare.CompareType type
```
      The compare type for the expression.
    - trigger
```
SubordinateTrigger trigger
```
      The trigger for the expression.
    - value
```
Object value
```
      The compare value for the expression.
- Class com.github.bordertech.wcomponents.subordinate.builder.GroupExpression extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - operands
```
List<E> operands
```
      The list of operands in this expression.
    - type
```
GroupExpression.Type type
```
      The type of expression.
Package com.github.bordertech.wcomponents.util
- Class com.github.bordertech.wcomponents.util.AbstractComparator extends Object implements Serializable
- Class com.github.bordertech.wcomponents.util.AbstractTreeNode extends Object implements Serializable
  - Serialized Fields
    - parent
```
TreeNode parent
```
      The parent node.
    - children
```
List<E> children
```
      The child list, lazily initialised.
- Class com.github.bordertech.wcomponents.util.ComparableComparator extends Object implements Serializable
- Class com.github.bordertech.wcomponents.util.Duplet extends Object implements Serializable
  - Serialized Fields
    - first
```
Serializable first
```
      The first item.
    - second
```
Serializable second
```
      The second item.
- Class com.github.bordertech.wcomponents.util.EmptyIterator extends Object implements Serializable
- Class com.github.bordertech.wcomponents.util.ObjectGraphNode extends AbstractTreeNode implements Serializable
  - Serialized Fields
    - fieldName
```
String fieldName
```
      The name of the field that this object is stored under in its parent object.
    - type
```
String type
```
      The fully qualified java type of the field. Not necessarily the same as the ObjectGraphNode.value's class.
    - value
```
Object value
```
      The value of this node.
    - size
```
int size
```
      The size of this node, in bytes.
    - id
```
int id
```
      This node's id.
    - refNode
```
ObjectGraphNode refNode
```
      If non-zero, this node is a reference to another node, using the other node's id.
- Class com.github.bordertech.wcomponents.util.RowIdList extends Object implements Serializable
  - Serialized Fields
    - startIndex
```
int startIndex
```
      Deprecated.
      
      The first row id.
    - endIndex
```
int endIndex
```
      Deprecated.
      
      The last row id.
- Class com.github.bordertech.wcomponents.util.SystemException extends RuntimeException implements Serializable
Package com.github.bordertech.wcomponents.util.thumbnail
- Class com.github.bordertech.wcomponents.util.thumbnail.BytesImage extends Object implements Serializable
  
  serialVersionUID:
  
  1494492251228372708L
  - Serialized Fields
    - bytes
```
byte[] bytes
```
      The bytes which make up the image.
    - mimeType
```
String mimeType
```
      The MIME type of the Image. (i.e. "image/jpeg").
    - description
```
String description
```
      A Textural description of the image.
    - size
```
Dimension size
```
      The x-y dimensions of the image.
Package com.github.bordertech.wcomponents.validation
- Class com.github.bordertech.wcomponents.validation.AbstractWFieldIndicator extends AbstractWComponent implements Serializable
  - Serialized Fields
    - relatedField
```
WComponent relatedField
```
      The field that this indicator is related to.
- Class com.github.bordertech.wcomponents.validation.AbstractWFieldIndicator.FieldIndicatorModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
- Class com.github.bordertech.wcomponents.validation.DiagnosticImpl extends Object implements Serializable
  - Serialized Fields
    - severity
```
int severity
```
      The severity of the diagnostic. One of Diagnostic.INFO, Diagnostic.WARNING or Diagnostic.ERROR.
    - uic
```
UIContext uic
```
      The UIContext in which the diagnostic occurred.
    - component
```
WComponent component
```
      The field is the source of the diagnostic, or null if there is no appropriate field. Preferably a Input.
    - message
```
String message
```
      The message pattern. This must use MessageFormat syntax if args are present.
    - args
```
Object[] args
```
      The message format arguments.
- Class com.github.bordertech.wcomponents.validation.ValidatingAction extends Object implements Serializable
  - Serialized Fields
    - errorsBox
```
WValidationErrors errorsBox
```
      The validation errors box which will display the errors.
    - componentToValidate
```
WComponent componentToValidate
```
      The component to be validated for this action.
- Class com.github.bordertech.wcomponents.validation.WFieldErrorIndicator extends AbstractWFieldIndicator implements Serializable
- Class com.github.bordertech.wcomponents.validation.WFieldWarningIndicator extends AbstractWFieldIndicator implements Serializable
- Class com.github.bordertech.wcomponents.validation.WValidationErrors extends AbstractWComponent implements Serializable
- Class com.github.bordertech.wcomponents.validation.WValidationErrors.ValidationErrorsModel extends ComponentModel implements Serializable
  - Serialization Methods
    - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      After the ComponentModel data is read in, some fields may be in a "unset" state. The static model needs to be supplied using ComponentModel.setSharedModel(ComponentModel)
      
      Throws:
      
      IOException - if there is an error reading from the ObjectInput
      
      ClassNotFoundException - If the class of a serialized object cannot be found.
    - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
      Implementation of the Externalizable interface to ensure that we don't serialize redundant data (anything contained by the ComponentModel.sharedModel.
      
      Data is obtained using reflection so that subclasses don't need concern themselves with the ComponentModel serialization mechanism.
      
      Throws:
      
      IOException - if there is an error writing to the ObjectOutput
Package com.github.bordertech.wcomponents.validator
- Class com.github.bordertech.wcomponents.validator.AbstractFieldValidator extends Object implements Serializable
  - Serialized Fields
    - input
```
Input input
```
      The input field to validate.
    - errorMessage
```
String errorMessage
```
      The error message to display on validation failure.
- Class com.github.bordertech.wcomponents.validator.DateFieldPivotValidator extends AbstractFieldValidator implements Serializable
  - Serialized Fields
    - fixedPivot
```
Date fixedPivot
```
      A fixed point in time around which the date field will be compared.
    - variablePivot
```
WDateField variablePivot
```
      A date field which supplies a variable point in time around which the date field will be compared.
    - operator
```
int operator
```
      The chosen comparison operation.
- Class com.github.bordertech.wcomponents.validator.RegExFieldValidator extends AbstractFieldValidator implements Serializable
  - Serialized Fields
    - pattern
```
Pattern pattern
```
      The regular expression to validate against.

Serialized Form

Package com.github.bordertech.wcomponents

Class com.github.bordertech.wcomponents.AbstractBasicTableModel extends Object implements Serializable

Class com.github.bordertech.wcomponents.AbstractBeanBoundTableModel extends AbstractTableModel implements Serializable

Serialized Fields

beanProvider

beanId

beanProperty

Class com.github.bordertech.wcomponents.AbstractBeanTableDataModel extends AbstractTableDataModel implements Serializable

Serialized Fields

beanProvider

beanId

beanProperty

Class com.github.bordertech.wcomponents.AbstractContainer extends AbstractWComponent implements Serializable

Class com.github.bordertech.wcomponents.AbstractEnvironment extends Object implements Serializable

Serialized Fields

postPath

appHostPath

baseUrl

hostFreeBaseUrl

appId

sessionToken

step

actionStep

formEncType

userAgentInfo

Class com.github.bordertech.wcomponents.AbstractInput extends WBeanComponent implements Serializable

Class com.github.bordertech.wcomponents.AbstractInput.InputModel extends BeanAndProviderBoundComponentModel implements Serializable

Serialization Methods

readExternal

writeExternal

Class com.github.bordertech.wcomponents.AbstractMutableContainer extends AbstractNamingContextContainer implements Serializable

Class com.github.bordertech.wcomponents.AbstractNamingContextContainer extends AbstractContainer implements Serializable

Class com.github.bordertech.wcomponents.AbstractTableDataModel extends Object implements Serializable

Class com.github.bordertech.wcomponents.AbstractTableModel extends Object implements Serializable

Class com.github.bordertech.wcomponents.AbstractTransientDataContainer extends AbstractMutableContainer implements Serializable

Class com.github.bordertech.wcomponents.AbstractTreeItemModel extends Object implements Serializable

Class com.github.bordertech.wcomponents.AbstractTreeTableDataModel extends Object implements Serializable

Serialized Fields

root

Class com.github.bordertech.wcomponents.AbstractWComponent extends Object implements Serializable

Serialization Methods

writeReplace

Serialized Fields

locked

sharedModel

Class com.github.bordertech.wcomponents.AbstractWComponent.WComponentRef extends AbstractWComponent implements Serializable

Serialization Methods

readObject

writeObject

readResolve

Serialized Fields

repositoryKey

nodeLocation

Class com.github.bordertech.wcomponents.AbstractWMultiSelectList extends AbstractWSelectList implements Serializable

Class com.github.bordertech.wcomponents.AbstractWMultiSelectList.MultiSelectionModel extends AbstractWSelectList.SelectionModel implements Serializable

Serialization Methods

readExternal

writeExternal

Class com.github.bordertech.wcomponents.AbstractWSelectList extends AbstractInput implements Serializable

Serialized Fields

allowNoSelection

Class com.github.bordertech.wcomponents.AbstractWSelectList.SelectionModel extends AbstractInput.InputModel implements Serializable

Serialization Methods

readExternal

writeExternal

Class com.github.bordertech.wcomponents.AbstractWSingleSelectList extends AbstractWSelectList implements Serializable

Class com.github.bordertech.wcomponents.ActionEscape extends Escape implements Serializable

Class com.github.bordertech.wcomponents.ActionEvent extends EventObject implements Serializable

Serialized Fields

actionCommand

actionObject

Class com.github.bordertech.wcomponents.AdapterBasicTableModel extends Object implements Serializable

Serialized Fields

model

Class com.github.bordertech.wcomponents.AjaxOperation extends Object implements Serializable

Serialized Fields

triggerId

targetIds

targetContainerId