borland Packages Class Hierarchy dx.dataset Package
java.lang.Object +----com.borland.dx.dataset.ReadRow +----com.borland.dx.dataset.ReadWriteRow +----com.borland.dx.dataset.DataSet +----com.borland.dx.dataset.StorageDataSet +----com.borland.dx.dataset.TableDataSet +----com.borland.dx.sql.dataset.ProcedureDataSet +----com.borland.dx.sql.dataset.QueryDataSet
Constructors Properties Methods Event Listeners
Implements AccessListener, ColumnDesigner, Designable, MasterNavigateListener, StatusListener, Serializable, EventListener
This class provides the core StorageDataSet
functionality. See also the TableDataSet
, QueryDataSet
, ProcedureDataSet
components.
StorageDataSet
manages a 2-dimensional array of data. Column
data types are specified through Column
components. A StorageDataSet
has a Column
component for each data column that it contains. Column
components contain type information for the data columns in a StorageDataSet
.
The StorageDataSet
component extends the basic cursor functionality provided by its superclass DataSet
with the:
MemoryStore
or DataStore
).
Column
) changes to the StorageDataSet
.
provider
and resolver
properties.
DataSetView
components.
The StorageDataSet
component is extended by QueryDataSet
, ProcedureDataSet
,
and TableDataSet
components. The
QueryDataSet
and ProcedureDataSet
work with a Database
component to
obtain data from a remote server through the execution of a query or stored procedure. You can also load
data stored in a text file into a TableDataSet
object. Once data is loaded (provided) into a
StorageDataSet
object, you handle the data in a common way, regardless of how the data
was obtained or which StorageDataSet
extension you use.
When making structure changes to the StorageDataSet
, such as setting the store
property to use a DataStore
, use the addColumn
, changeColumn
, dropColumn
, and moveColumn
methods as these methods allow for better before and after mapping. Otherwise, when the StorageDataSet
is restructured, Column
names are used for mapping, which may not always work as anticipated. The Column
component's preferredOrdinal
property is retained when calling these StorageDataSet
methods.
If your application involves a master-detail relationship, the resolveOrder
property indicates the order in which changes made to the DataSets
are resolved back to the data source.
public StorageDataSet()Constructs a
StorageDataSet
component, generates a StatusEvent
of StatusEvent.LOADING_DATA
and sets the following properties:
maxRows
to -1
maxDesignRows
to 50
metaDataUpdate
to MetaDataUpdate.ALL
public final synchronized void setAllRowIds(boolean setting)Sets all
Column
components as being unique row identifiers.
public final CalcAggFieldsListener getCalcAggFieldsListener()Read-only property that returns the
CalcAggFieldsListener
of the StorageDataSet
.
public final CalcFieldsListener getCalcFieldsListener()Read-only property that returns the
CalcFieldsListener
of the StorageDataSet
.
public synchronized void setColumns(Column[] columns)Specifies the
Column
components in the StorageDataSet
and sets the persist
property to true for all specified columns. Any pre-existing columns are removed when this property is set.
public final DataFile getDataFile() public void setDataFile(DataFile dataFile)Specifies the
DataFile
implementation used for file import and export operations. See TextDataFile
for an implementation of DataFile
.
public final int getDeletedRowCount()Read-only property that returns the number of deleted rows not visible to this
StorageDataSet
public final StorageDataSet getDuplicates()
When a unique sort property is applied for the first time, rows that violate the unique constraint will be copied off to a separate duplicates DataSet
. The duplicates DataSet
can be retrieved by calling getDuplicates().
For more discussion of using the unique constraint, see "Sorting data" in the Database Application Developer's Guide.
public final int getInsertedRowCount()Read-only property that returns the number of inserted rows visible to this
StorageDataSet
public Locale getLocale() public synchronized void setLocale(Locale locale)Used for formatting the data stored in the
StorageDataSet
. Locale contains country or area-specific formatting specifications such as date format (MM/DD/YY, DD/MM/YY, YY/MM/DD), currency symbol, and so on.
When set at the StorageDataSet
level, this property is the default locale
for all Column
components in the StorageDataSet
. If the StorageDataSet's
locale
property is null, and the store
property is set to a DataStore
component, the locale
property of the DataStore
will be used if set.
If not set any level, it defaults to the locale of the Java environment.
public final int getMaxDesignRows() public final void setMaxDesignRows(int maxDesignRows)Limits the number of rows that can be initially loaded into a
DataSet
in the UI Designer. The default is to load 50 rows. If the limit is reached, only that number of rows is displayed; no message is displayed nor is any Exception
thrown.
public final int getMaxResolveErrors() public final void setMaxResolveErrors(int maxResolveErrors)The maximum number of errors that can be logged in an error
DataSet
before a ResolutionException
of type RESOLVE_FAILED
is thrown.
If this property is set to 0, no errors will be logged. If set to -1, all errors will be logged.
ResolveError
public final int getMaxRows() public final void setMaxRows(int maxRows)Limits the number of rows that can initially be loaded into the
DataSet
when running
the application or applet. Also called a governor. The setMaxRows()
method has no
effect on rows added after the initial loading of data, for example, from a query or import
specification.
This property defaults to -1 which indicates that there is no limit to the number of
rows that can be initially loaded into a DataSet
. No message is displayed nor
is any Exception
thrown when the limit is reached, however, only that number of
rows is included in the DataSet
when it is loaded with data. With long running
queries that can possibly return large result sets, it is advisable to set the
maxRows
property since the maximum number of rows defaults to unlimited.
Load.AS_NEEDED
public final int getMetaDataUpdate() public final synchronized void setMetaDataUpdate(int metaDataUpdate)Determines what kind of metadata discovery is performed when executing a query or a stored procedure against a SQL server database. Valid values for this property are defined in the
MetaDataUpdate
interface.
To prevent the addition of row ID columns and various metadata related properties on DataSet
and Column
components, set this property to MetaDataUpdate.NONE
.
For more information on metadata, see "Obtaining Metadata" in the Database Application Developer's Guide.
public final boolean getNeedsRestructure()Returns true for
StorageDataSet
components when structural changes have occurred (add, drop, move, change column) and the store
being used requires a restructure. To cause the restructure to happen, call the restructure()
method or click the Restructure button in the JBuilder Column Designer. After a successful restructure, getNeedsRestructure()
returns false.
A StorageDataSet
that uses a MemoryStore
always returns false. Currently, this method is meaningful only with DataStore
use.
A StorageDataSet
with pending structural changes can still be used. Moved columns can be read and written to. Deleted columns are not visible, inserted columns can be read, but not written, changed data type columns can be read but not written to.
public Provider getProvider() public void setProvider(Provider provider)Specifies the
Provider
component that controls how the data is fetched from the database when the
StorageDataSet
is opened.
DataExpress includes these provider components:
public final boolean isReadOnly() public final void setReadOnly(boolean readOnly)Specifies whether edits to the
DataSet
are permitted. If true, edits to the DataSet
are not allowed, otherwise the DataSet
can be updated.
A StorageDataSet
can be internally marked readOnly
in some situations. These automatic readOnly
settings cannot be cleared by calling setReadOnly(false)
. The return value of DataSetException.getMessage()
explains why a StorageDataSet
is readOnly
.
A common reason for a StorageDataSet
to be automatically marked readOnly
is that a Provider
, such as QueryProvider
or ProcedureProvider
, could not determine which Column
s should have their rowId
property set to true. This readOnly
state can be cleared by calling Column.setRowId()
, StorageDataSet.setRowId()
, or StorageDataSet.setAllRowIds()
.
If a QueryProvider
or ProcedureProvider
cannot determine the tableName
property setting, the changes in the StorageDataSet
cannot be saved back. To save changes back, the StorageDataSet.setTableName
property must be explicitly set. If the query was the result of a join operation, and you would like to resolve the changes back, the Column.tableName
property will have to be set for each column. If this was not successfully accomplished by the Provider
, this property will have to be set for each Column
that is to have its values saved (resolved) back.
To prevent edits to the DataSet
through data-aware controls only (permitting programmatic edits), set the editable
property.
editable
property of the DataSet
class,
resolvable
property of this class
public final boolean isResolvable() public final synchronized void setResolvable(boolean resolvable)Specifies whether to allow changes made to this
DataSet
to be saved back to its data source (true) or not (false).
resolvable
is a user property that indicates an intent to resolve edits to
the StorageDataSet
. If set to false, inserts, updates, and deletes are not tracked. This will save space and improve performance for StorageDataSets
that are wired to a DataStore
when you have no intention of resolving.
editable
property of the DataSet
class, readOnly
property of this class
public final String[] getResolveOrder() public final void setResolveOrder(String[] resolveOrder)A
String
array that specifies the resolution order for multi-table resolution. Inserts and updates use the order of the String
array while deletes use the reverse order. The default order of the tables in the String
array is the order by which they appear in the query statement. The table names should include any necessary schema names. If a table is removed from the list, then the columns from that table will not be resolved.
If your application involves a master-detail relationship, the resolveOrder
property indicates the order in which changes made to the DataSet
s are resolved back to the data source.
public Resolver getResolver() public void setResolver(Resolver resolver)Specifies the
Resolver
object to use that defines resolver logic when saving data changes back to the data source.
public final String getSchemaName() public synchronized void setSchemaName(String schemaName)Write-only property for the table name of the data source for the
Column
components of this StorageDataSet
. If a DataSet
has any updateable Column
components, this property must reflect the table name of the data source.
public final Store getStore() public final void setStore(Store store)Sets the storage for the
DataSet
. Valid values for this property are MemoryStore
or DataStore
. The default is MemoryStore
.
With MemoryStore
, DataSet
data is stored in memory and released when an application closes. With DataStore
, storage is persistent and file-based so that when an application closes, it can be restarted in the same state as when it was closed.
public final StoreClassFactory getStoreClassFactory() public final void setStoreClassFactory(StoreClassFactory factory)Allows a
DataStore
table to be accessed only by a specific StorageDataSet
class or StorageDataSet
class extension. This allows an application to make sure that property and event settings are always activated when a DataStore
table is accessed.
Currently, this property is only meaningful when the StorageDataSet.store
property is set to a DataStoreConnection
or DataStore
component.
StoreClassFactory
public final String getStoreName() public synchronized void setStoreName(String name)If the
store
property component supports naming of a DataSet
components in the Store
, this can be set. The default store
is MemoryStore
, which does not support naming of DataSet
components. This property is meaningful to and used only by DataStore
.
When specified for a DataStore
component, the storeName
property must be unique. The value specified for storeName
is case insensitive, though it is stored internally in upper case. To force a storeName
to be case insensitive, enclose it in quotes, for example:
"\"name\""
public final String getTableName() public synchronized void setTableName(String tableName)Stores the name of the table from which the
DataSet
obtains its data.
If a DataSet
has any updateable columns, the name of the table for these columns is stored as tableName
.
The table name is normally retrieved automatically from the data source. Some stored procedures and queries however will not return the table name. If it doesn't, use setTableName()
to specify the table name so that changes made to the DataSet
can be resolved back to the data source, then set the rowId
and metadataupdate
properties (if not already set). The table name is also useful as a String
identifier of the data source.
public final int getUpdatedRowCount()Read-only property that returns the number of updated rows visible to this
StorageDataSet
public final int addColumn(String columnName, int datatype)Adds a
Column
to a DataSet
where columnName
indicates the String
name of the Column
and dataType
is the
data type of the Column
. The Column
is added at the end of all existing columns. The return value int
indicates the ordinal position of the newly-added Column
. Use the enableDataSetEvents
method to propagate changes to a control that is bound to this DataSet
.
To achieve similar results as when calling StorageDataSet.setColumns(...)
method, call the addColumn(...)
method followed by Column.setPersist(true)
.
If the store
property is set, StorageDataSet.restructure()
must be called before this column can be edited.
On error, this method throws a DataSetException
.
columnName
String
name of the Column
component to add to the StorageDataSet
.
datatype
Column
. Valid values for this parameter are defined in com.borland.dx.dataset.Variant
variables.
public final int addColumn(String columnName, String caption, int dataType)Adds a
Column
to the end of existing columns in a DataSet
. Row values for the added Column
are set to null. The return value int
indicates the ordinal position of the newly-added Column
. On error, this method throws a DataSetException
.
If the store
property is set, StorageDataSet.restructure()
must be called before this column can be edited.
columnName
String
name of the Column
by which you refer to it most of the time.
colLabel
Column
in a data-aware control. You may want to use a more descriptive name than columnName
.
dataType
com.borland.dx.dataset.Variant
variables.
public void addLoadRowListener(LoadRowListener listener)Adds the specified
LoadRowListener
object.
public final int addUniqueColumn(Column column)Adds a
Column
to the DataSet
only if it does not already exist. The specified column
is cloned before being added to the DataSet
. The return value int
indicates the ordinal position of the newly-added Column
.
On error, this method throws a DataSetException
of COLUMN_TYPE_CONFLICT
.
column
Column
component to add to this StorageDataSet
.
public final void cancelLoading()Cancels any long running load operations currently active on this
DataSet
.
For this have an effect, the long running loading operation must be executing on a different
thread than the thread that calls this method.
public final void cancelOperation()Cancels any long running operation currently active on this
DataSet
. This includes
loading a query result, restructure operations, and index building operations.
For this have an effect, the long running operation must be executing on a different
thread than the thread that calls this method.
public boolean changesPending()Returns true if there are any inserted, deleted, or updated rows to be resolved back to the data source. If true, one or more of the following methods
getUpdatedRowCount()
, getDeletedCount()
, or getInsertedCount()
return a value greater than 0.
public Column[] cloneColumns()Creates a copy of all
Columns
in the StorageDataSet
.
public final synchronized StorageDataSet cloneDataSetStructure()Creates a new empty
StorageDataSet
object with the identical structure as the current StorageDataSet
.
public void closeProvider(boolean loadRemainingRows)
This method can be used to terminate a provider that is currently still loading rows into the StorageDataSet
. If a load option such as Load.AS_NEEDED or Load.ASYNCHRONOUS is being used by a QueryProvider
or ProcedureProvider
, and closeProvider()
is called with loadRemainingRows
set to true, the remaining rows will be retrieved before the provider is closed. If loadRemainingRows
is false, the provide operation will be terminated and the remaining rows will not be retrieved.
public final void deleteDuplicates()
When a unique sort property is applied for the first time, rows that violate the unique constraint will be copied off to a separate duplicates DataSet
. The duplicates DataSet
can be retrieved by calling getDuplicates()
. Opening a DataSet
with a new sort
property setting that has a unique constraint will not succeed if a duplicates StorageDataSet
already exists. This restriction protects an application from accidentally losing valuable data in duplicate rows.
Call deleteDuplicates()
to delete the old set of duplicates.
For more information on using the unique constraint, see "Sorting data" in the Database Application Developer's Guide.
public final void dropAllIndexes()Drops all indexes used by this
StorageDataSet
. For MemoryStore
, this can
be used to save memory after viewing the data in different sort orders.
For DataStore
, this frees up maintained secondary indexes, releasing disk
storage. In both MemoryStore
and DataStore
, this can improve update performance.
public final synchronized void dropColumn(Column column)Deletes the specified
Column
object (and all the data it contains) from the DataSet
. If the Column
cannot be dropped, this method throws a DataSetException
. dropColumn
does not affect the relative order of columns but does cause a recalculation of column ordinal values.
If the store
property is set, StorageDataSet.restructure()
must be called before this column can be edited.
column
Column
component to drop from this StorageDataSet
.
public final boolean dropIndex(SortDescriptor descriptor, RowFilterListener listener)This method can be used to drop unneeded indexes used to maintain a sorted and filtered view of a
DataSet
. Dropping an index can save space and improve the performance of insert/add/delete operations.
descriptor
listener
RowFilterListener
used for filtering. Pass null if not a filtered index.
public final void empty()Empties all rows of the
DataSet
and resets the DataSet
to contain no rows. All change state information (inserted, deleted, changed) is lost and therefore, nothing remains in the DataSet
to be resolved back to the original data source. On error, this method generates a DataSetException
.
public final synchronized void endLoading()Stops the loading of data into the
StorageDataSet
.
startLoading(com.borland.dx.dataset.LoadCancel, int, boolean)
,
loadRow()
public final synchronized void getDeletedRows(DataSetView deleteDataSet)Initializes
deleteDataSet
to display only the deleted rows in the current DataSet
. On error, this method generates a DataSetException
.
deleteDataSet
DataSetView
initialized by this method to includes only deleted rows.
public final synchronized void getInsertedRows(DataSetView insertDataSet)Initializes the
DataSetView
to display only the inserted (new) rows in the current DataSet
. On error, this method generates a DataSetException
.
insertDataSet
DataSetView
initialized by this method to include only inserted rows.
public final void getOriginalRow(DataSet updateDataSet, ReadWriteRow originalRow)Given a
DataSet
with a changed record, this method initializes a dataRow
with the original values.
public final synchronized void getUpdatedRows(DataSetView updateDataSet)Initializes a
DataSetView
object to display only the updated rows in the current DataSet
. On error, this method generates a DataSetException
.
updateDataSet
DataSetView
that is initialized by this method to contain only updated rows.
public final synchronized boolean hasRowIds()Returns whether the
DataSet
has any unique row identifiers. If at least one exists, this method returns true.
public final boolean indexExists(SortDescriptor descriptor, RowFilterListener listener)
Returns true if a maintained index already exists for the given descriptor and listener.
descriptor
listener
RowFilterListener
used for filtering. Pass null if not a filtered index.
public final void loadRow()This method allows for faster loading of a
StorageDataSet
. It calls loadRow(loadStatus)
, where loadStatus
is the value of loadStatus
passed to startLoading()
.
startLoading(com.borland.dx.dataset.LoadCancel, int, boolean)
,
endLoading()
public final long loadRow(int status)
Allows for faster loading of a StorageDataSet
. You can also use this method to load rows as updated or deleted.
To load a row as deleted, set the variant values returned from startLoading()
and call loadRow(RowStatus.DELETED)
.
To load a row as updated, set the variant values returned from startLoading()
to the original row values and call loadRow(RowStatus.ORIGINAL)
. Then set the variant values returned form startLoading
to the updated row values and call
loadRow(RowStatus.UPDATED).
status
public final synchronized void moveColumn(int oldOrdinal, int newOrdinal)Moves a
Column
at the specified ordinal position to a new ordinal position. If either parameter is invalid, a DataSetException
of type INVALID_COLUMN_POSITION
is thrown.
If the store
property is set, StorageDataSet.restructure()
must be called before this column can be edited.
oldOrdinal
Column
component to move.
newOrdinal
Column
should be moved to.
public final void postAllDataSets()Attempts to post any unposted rows in the
DataSet
and DataSetView
components that share the same StorageDataSet
property. On error, this method throws a DataSetException
.
public boolean provideMoreData()
If a Provider
, such as QueryProvider
or ProcedureProvider
, has a load
property setting of Load.AS_NEEDED, calling this method retrieves the next batch of rows.
public final synchronized void recalc()Forces a recalculation of any calculated columns in the
StorageDataSet
.
public void refresh()Calls the
Provider
to refresh data from the data source of the StorageDataSet
.
public boolean refreshSupported()Returns true if the data source of the
StorageDataSet
supports refresh operations. Otherwise, this method returns false.
public synchronized void removeLoadRowListener(LoadRowListener listener)Removes the specified
LoadRowListener
object.
public final void reset()Resets the
StorageDataSet
with the original values it was loaded with. All insert, update, and delete operations performed by the application are backed out.
public final void resetPendingStatus(boolean resolved)Resets the status bits of the rows marked pending during resolution.
resolved
false if changes were rolled back and the changed rows should still be treated as changed rows.
public final void resetPendingStatus(long internalRow, boolean resolved)
Reset the status bits of a specific row.
internalRow
resolved
false if changes were rolled back and the changed rows should still be treated as changed rows.
public final void restructure()Restructures the
StorageDataSet
. Currently meaningful only for DataStore
after a move, delete, add, or change column method call.
The needsRestructure
property returns whether a restructure operation is pending. A StorageDataSet
with pending structural changes can still be used, and moved columns can be read and written to. Deleted columns are not visible, inserted columns can be read but not written and changed data type columns can be read but not written to.
You can perform a restructure operation through the JBuilder column designer by opening the StorageDataSet
and clicking the restructure button.
The restructure()
method can also be used to repair or compact a StorageDataSet
and its associated indexes even when there are no pending structural changes.
public void saveChanges(DataSet dataSet)Saves changes made to the data in the
StorageDataSet
back to its data source.
If the resolver
property is null, a DataSetException
of CANNOT_SAVE_CHANGES
is thrown.
To save changes back to a text file, see "Exporting data" in the Database Application Developer's Guide.
dataSet
DataSet
containing the updated data.
public boolean saveChangesSupported()Returns true if the data source supports resolving changes made to the
StorageDataSet
, false if not. Typically, file-based data sources do not support data resolution.
To save changes back to a text file, see "Exporting data" in the Database Application Developer's Guide.
public final synchronized void setRowId(String columnName, boolean setting)Specifies that the named
Column
component either uniquely identifies a row in the server table where changes made to this StorageDataSet
will be saved back to, or is one of a group of Column
components that uniquely identifies a row. A false value indicates that the specified Column
is not (part of) a unique row identifier.
columnName
Column
component.
setting
columnName
in the row identifier (true) or not (false).
public final Variant[] startLoading(LoadCancel loader, int loadStatus, boolean loadAsync)
This method calls startLoading(loader, loadStatus, loadAsync, false, false)
, where the last two parameters (loadUncached
and loadValidate
) are set to false. The following description is for the startLoading(loader, loadStatus, loadAsync, loadUncached, loadValidate)
method.
This method is used for high-speed loading of data into a StorageDataSet
.
It returns an array of Variant
objects for all columns in a DataSet
. You set the values in the array and
call loadRow()
or loadRow(int)
. When the load operation is complete, you must call endLoading
. Only one load operation may be active at one time.
This method may generate a DataSetException
of LOADING_NOT_STARTED
.
loader
loadStatus
loadAsync
StorageDataSet
using a separate
thread. This will cause periodic update notifications to be sent to any data aware controls and StatusListener
s.
loadUncached
When loadUncached
is True, attempts are made to navigate past the end of the DataSet
and have the following effect:
If the Provider
property is set, and it returns True for the Provider.hasMoreData(StorageDataSet)
,
Provider.ProvideMoreData(StorageDataSet)
will be called. The Provider.ProvideMoreData(StorageDataSet)
should call the StorageDataSet.loadRow()
to load one more row of data.
If loadUncached
is set to False (the default), the row is posted to the StorageDataSet
and retained until it is explicitly removed.
The intent of loadUncached
is to support batch processing where each row only needs to be accessed one time. Use this with QueryProvider
s and ProcedureProvider
s that use the Load.UNCACHED option.
loadValidate
DataRow.validate()
for each row before it is loaded.
loadRow()
,endLoading()
public final synchronized Variant[] startLoading(LoadCancel loader, int loadStatus, boolean loadAsync, boolean loadUncached)Calls
startLoading(loader, loadStatus, loadAsync, loadUncached, false)
. The last parameter, loadValidate
, is set to false.
public final synchronized Variant[] startLoading(LoadCancel loader, int loadStatus, boolean loadAsync, boolean loadUncached, boolean loadValidate)Used for high speed loading of data into a
StorageDataSet
.
loader
loadStatus
loadAsync
StorageDataSet
using a separate
thread. This will cause periodic update notifications to be sent to any data aware controls and StatusListener
s.
loadUncached
A single row of data is stored in the StorageDataSet
. If loadUncached
is True, attempts are made to navigate past the end of the DataSet
and have the following effect:
If the Provider
property is set, and it returns True for the Provider.hasMoreData(StorageDataSet)
,
Provider.ProvideMoreData(StorageDataSet)
will be called. The Provider.ProvideMoreData(StorageDataSet)
should call the StorageDataSet.loadRow()
to load one more row of data.
If loadUncached
is set to False (the default), the row is posted to the StorageDataSet
and retained until it is explicitly removed.
The intent of loadUncached
is to support batch processing where each row only needs to be accessed one time. Use this with QueryProvider
s and ProcedureProvider
s that use the Load.UNCACHED option.
loadValidate
DataRow.validate()
for each row before it is loaded.
loadValidate
DataRow.validate()
for each row before it is loaded.
public final void addAccessListener(AccessListener listener) public final void removeAccessListener(AccessListener listener)
public synchronized void addCalcAggFieldsListener(CalcAggFieldsListener listener) public synchronized void removeCalcAggFieldsListener(CalcAggFieldsListener listener)
public synchronized void addCalcFieldsListener(CalcFieldsListener listener) public synchronized void removeCalcFieldsListener(CalcFieldsListener listener)
public void addColumnChangeListener(ColumnChangeListener listener) public synchronized void removeColumnChangeListener(ColumnChangeListener listener)
public final void addDataChangeListener(DataChangeListener listener) public final void removeDataChangeListener(DataChangeListener listener)
public void addEditListener(EditListener listener) public synchronized void removeEditListener(EditListener listener)
public final synchronized void addLoadListener(LoadListener listener) public final synchronized void removeLoadListener(LoadListener listener)
public final void addMasterNavigateListener(MasterNavigateListener listener) public final void removeMasterNavigateListener(MasterNavigateListener listener)
public final void addNavigationListener(NavigationListener listener) public final void removeNavigationListener(NavigationListener listener)
public final void addOpenListener(OpenListener listener) public final void removeOpenListener(OpenListener listener)
public final void addRowFilterListener(RowFilterListener listener) public final void removeRowFilterListener(RowFilterListener listener)
public final void addStatusListener(StatusListener listener) public final void removeStatusListener(StatusListener listener)