A DisplayGroup collects a array of objects from a next.eo.DataSource and displays and edits properties of those objects.
allObjects | Returns all objects in the DisplayGroup. |
displayedObjects | Returns the subset of all objects made available for display. |
selectedObjects | Returns the selected objects. |
setQualifier | Sets a filter that limits the objects displayed. |
setSortOrdering | Sets the ordering used to sort the objects. |
updateDisplayedObjects | Filters, sorts, and redisplays the objects |
insert | Creates a new object and inserts it into the DataSource. |
A next.wo.DisplayGroup is the basic user interface manager for a WebObjects application that accesses a database. It collects objects from a next.eo.DataSource, filters and sorts them, and maintains a selection in the filtered subset. You bind WebObjects dynamic elements to DisplayGroup attributes and methods to display information from the database on your web page.
A DisplayGroup manipulates its DataSource by sending it fetchObjects, insertObject, and other messages, and registers itself as an editor and message handler of the DataSource's next.eo.EditingContext. The EditingContext then monitors the DisplayGroup for changes to objects.
Most of a DisplayGroup's interactions are with its DataSource and its EditingContext. See the next.eo.DataSource, and next.eo.EditingContext class specifications for more information on these interactions.
You create most DisplayGroups in one of these ways:
Most DisplayGroups operate independently of other DisplayGroups; however, you can set up a master-detail association between two DisplayGroups. You typically do this by dragging a to-many relationship from the EOModeler application to a component opened in the WebObjects Builder application. When you do this, the display group you create has a DetailDataSource as its data source, a detail key equal to the to-many relationship's key, and a master object equal to the entity from which you dragged the relationship.
To create a DisplayGroup programmatically, simply initialize it and set its DataSource:
import next.eo.*; import next.wo.*; ... DataSource myDataSource; /* Assume this exists. */ DisplayGroup myDisplayGroup; myDisplayGroup = DisplayGroup(); myDisplayGroup.setDataSource(myDataSource);
Since a DisplayGroup isn't much use without objects to manage, the first thing you do with a DisplayGroup is send it a fetch message. You can use the basic fetch method, or you can configure the DisplayGroup in WebObjects Builder to fetch automatically when its component is loaded. The fetch method asks the DisplayGroup's DataSource to fetch from its persistent store with a fetchObjects message.
A DisplayGroup's fetched objects are available through its allObjects method. These objects are treated only as candidates for display, however. The array of objects actually displayed is filtered and sorted by the DisplayGroup's delegate or by a qualifier and a sort ordering array. You set the qualifier and sort orderings using the setQualifier and setSortOrdering methods. The displayedObjects method returns this filtered and sorted array; index arguments to other DisplayGroup methods are defined in terms of this array.
If the DisplayGroup has a delegate that responds to displayArrayForObjects (defined in the next.wo.DisplayGroupDelegate interface), it invokes this method rather than using its own qualifier and sort ordering array. The delegate is then responsible for filtering the objects and returning a sorted array. If the delegate only needs to perform one of these steps, it can get the qualifier or sort orderings from the DisplayGroup and apply either itself using the next.eo.Qualifier method vectorByFilteringWithQualifier and the next.eo.SortOrdering method sortedVectorUsingKeyOrders.
If you change the qualifier or sort ordering, or alter the delegate in a way that changes how it filters and sorts the DisplayGroup's objects, you can send updateDisplayedObjects to the DisplayGroup to get it to refilter and resort its objects. Note that this doesn't cause the DisplayGroup to refetch.
Even after the output has been qualifier and sorted, there might be too many objects to display on a single HTML page. For this reason and to improve your application's performance, DisplayGroup supports batching the display. When batching is used, the HTML page shows only a certain number of objects at a time. If you create the DisplayGroup using Project Builder's Wizard, the default batch size is 10. Thus if there are one hundred objects to display, displayedObjects returns only the first ten of those objects when the page is drawn. If displayNextBatch is invoked, displayedObjects is updated to contain the next ten objects, and the page is redrawn.
You use displayNextBatch and displayPreviousBatch to move back and forth through the displayed objects. The setNumberOfObjectsPerBatch method changes the batch size. You can also change batch size using WebObjects Builder.
A DisplayGroup keeps a selection in terms of indexes into the array of displayed objects. Components that display values for multiple objects are responsible for updating the selection in their DisplayGroups according to user actions on their dynamic elements. This is typically done with the setSelectionIndexes method. Other methods available for indirect manipulation of the selection are the action methods selectNext and selectPrevious.
To get the selection, you can use the selectionIndexes method, which returns a array of Integers, or selectedObjects, which returns a array containing the selected objects themselves. Another method, selectedObject, returns the first selected object if there is one.
Note: The selection is a programmatical selection only. The selected objects don't actually appear highlighted on the web page.
The interface next.wo.DisplayGroupDelegate offers a number of methods for the DisplayGroup's delegate to implement; if the delegate does, DisplayGroup invokes them as appropriate. Besides the aforementioned displayArrayForObjects, there are methods that inform the delegate that the DisplayGroup has fetched, created an object (or failed to create one), inserted or deleted an object, changed the selection, or set a value for a property. There are also methods that request permission from the delegate to perform most of these same actions. The delegate can return true to permit the action or false to deny it. See each method's description in the next.wo.DisplayGroupDelegate interface specification for more information.
If you are building a component that allows users to perform database queries, you use a DisplayGroup to construct a qualifier that reflects the query.
To construct a qualifier, you bind dynamic elements in your component to keys in the queryMatch, queryMax, or queryMin dictionaries. The possible keys to these dictionaries are the properties of the entity managed by the DisplayGroup.
For simple queries, the queryMatch dictionary is often sufficient. The associated queryOperator dictionary tells how to match the values in queryMatch. When a qualifier is constructed from queryMatch, it works this way:
Tip: To ensure that value types are interpreted appropriately, use formatters on the WOTextField. That is, if the value is a number, use WOTextField's numberformat attribute to specify how the number should appear. If the value is a date, use the dateformat attribute.
Tip: You might find it convenient to use the array returned by allQualifierOperators as input to a WOPopUpButton element so that your users can choose how they want the matching to be performed.
To perform from-to queries, you can use queryMax and queryMin. For example, suppose you had a Movies database and wanted to build a query to return all movies released between two dates: January 1, 1994 and December 31, 1994. queryMax would contain one key, dateReleased, with the value December 31, 1994, and queryMin would contain the same key with the value January 1, 1994.
After you've provided the values for the query, you build the qualifier and perform the fetches using one of two methods: qualifyDataSource or qualifyDisplayGroup. qualifyDataSource fetches the items directly from the database. qualifyDisplayGroup filters the objects in memory after they are fetched. Both use qualifierFromQueryValues to construct the qualifier used to perform the fetch.
Returns a newly allocated DisplayGroup. The new DisplayGroup then needs to have a next.eo.DataSource set with setDataSource.
Returns all of the objects collected by the receiver.
See Also: displayedObjects, fetch
Returns an ImmutableVector containing all of the relational operators supported by next.eo.Qualifier: =, !=, <, <=, >, >=, "like" and "caseInsensitiveLike".
See Also: queryOperator, relationalQualifierOperators
The number of batches to display. For example, if the displayed objects array contains two hundred records and the batch size is ten, batchCount returns twenty (twenty batches of ten records each).
See Also: currentBatchIndex, displayNextBatch, displayPreviousBatch, numberOfObjectsPerBatch
Invokes setSelectionIndexes to clear the selection, returning true on success and false on failure.
Returns the index of the batch currently being displayed. The total batch count equals the number of displayed objects divided by the batch size. For example, if the DisplayGroup has one hundred objects to display and the batch size is twenty, there are five batches. The first batch has a batch index of 1.
See Also: batchCount, numberOfObjectsPerBatch, setCurrentBatchIndex
Returns the receiver's next.eo.DataSource.
See Also: setDataSource
Returns the receiver's delegate.
See Also: setDelegate, next.wo.DisplayGroupDelegate interface
Returns the format string that specifies how pattern matching will be performed on string values in the queryMatch dictionary. If a key in the queryMatch dictionary does not have an associated operator in the queryOperator dictionary, then its value is matched using pattern matching, and the format string returned by this method specifies how it will be matched.
See Also: defaultStringMatchOperator, setDefaultStringMatchFormat
Returns the operator used to perform pattern matching for string values in the queryMatch dictionary. If a key in the queryMatch dictionary does not have an associated operator in the queryOperator dictionary, then the operator returned by this method is used to perform pattern matching.
See Also: defaultStringMatchFormat, setDefaultStringMatchOperator
Uses deleteSelection to attempt to delete the selected objects and then causes the page to reload. Returns null to force reloading of the web page.
See Also: deleteObjectAtIndex
Attempts to delete the object at index, returning true if successful and false if not. Checks with the delegate using the method shouldDeleteObject (defined in the next.wo.DisplayGroupDelegate interface). If the delegate returns false, this method fails and returns false. If successful, it sends the delegate a didDeleteObject message.
This method performs the delete by sending deleteObject to the next.eo.DataSource. If that message raises an exception, this method fails and returns false.
See Also: delete, deleteSelection
Attempts to delete the selected objects, returning true if successful and false if not.
See Also: delete, deleteObjectAtIndex
For detail display groups, returns the key to the master object that specifies what this detail display group represents. That is, if you send the object returned by the masterObject method a valueForKey message with this key, you obtain the objects controlled by this display group.
This method returns null if the receiver is not a detail display group or if the detail key has not yet been set. You typically create a detail display group by dragging a to-many relationship from EOModeler to an open component in WebObjects Builder.
See Also: hasDetailDataSource, masterObject, setDetailKey
Displays the batch containing the selection and sets the current batch index to that batch's index. Returns null to force the page to reload.
See Also: displayNextBatch, displayPreviousBatch, setCurrentBatchIndex
Increments the current batch index, displays that batch of objects, and clears the selection. If the batch currently being displayed is the last batch, this method displays the first batch of objects. Returns null to force the page to reload.
See Also: batchCount, currentBatchIndex, displayBatchContainingSelectedObject, displayPreviousBatch
Decrements the current batch index, displays that batch of objects, and clears the selection. If the batch currently being displayed is the first batch, this method displays the last batch of objects. Returns null to force the page to reload.
See Also: batchCount, currentBatchIndex, displayBatchContainingSelectedObject, displayNextBatch
Returns the objects that should be displayed or otherwise made available to the user, as filtered by the receiver's delegate, by the receiver's qualifier and sort ordering.
If batching is in effect, displayedObjects returns the current batch of objects.
See Also: allObjects, updateDisplayedObjects, qualifier, sortOrdering, displayArrayForObjects (in next.wo.DisplayGroupDelegate interface)
Ends any editing taking place and returns true.
Attempts to fetch objects from the next.eo.DataSource.
Before fetching, invokes endEditing and sends displayGroupShouldFetch (defined in the next.wo.DisplayGroupDelegate interface) to the delegate. If both of those methods were successful, it then sends a fetchObjects message to the receiver's next.eo.DataSource to replace the object array, and if successful sends the delegate a didFetchObjects message.
This method returns null to force the page to reload.
See Also: allObjects, updateDisplayedObjects
Returns true if the receiver fetches automatically after being loaded, false if it must be told explicitly to fetch. The default is true. You can set this behavior in WebObjects Builder using the Display Group Options panel.
See Also: fetch, setFetchesOnLoad
Returns true if the display group's data source is a next.eo.DetailDataSource, and false otherwise. If you drag a to-many relationship from EOModeler to an open component in WebObjects Builder, you create a display group that has a next.eo.DetailDataSource. You can also set this up using the Display Group Options panel in WebObjects Builder.
See Also: detailKey, masterObject
Returns true if the batch count is greater than 1. A display group displays its objects in batches if the numberOfObjectsPerBatch method returns a number that is less than the number of objects in the displayedObjects array.
See Also: batchCount, setNumberOfObjectsPerBatch
Returns true to indicate that the receiver is in query mode, false otherwise. In query mode, controls in the user interface that normally display values become empty, allowing users to type queries directly into them (this is also known as a "Query by Example" interface). In effect, the receiver's "displayedObjects" are replaced with an empty queryMatch dictionary. When qualifyDisplayGroup or qualifyDataSource is subsequently invoked, the query is performed and the display reverts to displaying values-- this time, the objects returned by the query.
See Also: setInQueryMode
Invokes insertObjectAtIndex with an index just past the first index in the selection, or 0 if there's no selection.
This method returns null to force the page to reload.
Asks the receiver's next.eo.DataSource to create a new object by sending it a createObject message, then inserts the new object using insertObjectAtIndex. If a new object can't be created, this method sends the delegate a createObjectFailedForDataSource message (defined in the next.wo.DisplayGroupDelegate interface).
If the object is successfully created, this method then sets the default values specified by insertedObjectDefaultValues.
This method returns null to force the page to be reloaded.
See Also: insert
Inserts anObject into the receiver's DataSource and displayed objects at index, if possible. This method checks with the delegate before actually inserting, using shouldInsertObject. If the delegate refuses, anObject isn't inserted. After successfully inserting the object, this method informs the delegate with a didInsertObject message, and selects the newly inserted object.
Raises an exception if index is out of bounds.
See Also: insertNewObjectAtIndex, insert
Returns the default values to be used for newly inserted objects. The keys into the dictionary are the properties of the entity that the display group manages. If the dictionary returned by this method is empty, the insert method adds an object that is initially empty. Because the object is empty, the display group has no value to display on the HTML page for that object, meaning that there is nothing for the user to select and modify. Use the setInsertedObjectDefaultValues method to set up a default value so that there is something to display on the page.
Returns the additional keys that dynamic elements can be bound to. A DisplayGroup's basic keys are typically those of the attributes and relationships of its objects, as defined by their class descriptions through an entity in the model. Local keys are typically used to form associations with key paths, with arbitrary methods of objects, or with properties of objects not associated with an entity.
See Also: setLocalKeys
Returns the master object for a detail display group (a display group that represents a detail in a master-detail relationship). A detail display group is one that uses a next.eo.DetailDataSource. You create a detail display group by dragging a to-many relationship from EOModeler to an open component in WebObjects Builder. If the display group is not a detail display group or does not have a master object set, this method returns null.
See Also: detailKey, hasDetailDataSource, setMasterObject
Returns the batch size. You can set the batch size using setNumberOfObjectsPerBatch or using WebObjects Builder's Display Group Options panel.
See Also: setNumberOfObjectsPerBatch
Returns the receiver's qualifier, which it uses to filter its array of objects for display when the delegate doesn't do so itself.
See Also: displayedObjects, qualifierFromQueryValues, setQualifier, updateDisplayedObjects
Builds a qualifier constructed from entries in the three query dictionaries: queryMatch, queryMax, and queryMin.
See Also: qualifyDataSource, qualifyDisplayGroup
Takes the result of qualifierFromQueryValues and applies to the receiver's data source. The receiver then sends itself a fetch message. If the receiver is in query mode, query mode is exited. This method differs from qualifyDisplayGroup as follows: whereas qualifyDisplayGroup performs in-memory filtering of already fetched objects, qualifyDataSource triggers a new qualified fetch against the database.
See Also: queryMatch, queryMax, queryMin, queryOperator
Takes the result of the qualifierFromQueryValues and applies to the receiver using setQualifier. The method updateDisplayedObjects is invoked to refresh the display. If the receiver is in query mode, query mode is exited.
See Also: qualifyDataSource, queryMatch, queryMax, queryMin, queryOperator
Returns a dictionary of query values to match. The qualifierFromQueryValues method uses this dictionary along with the queryMax and queryMin dictionaries to construct qualifiers.
Use the queryOperator dictionary to specify the type of matching (=, <, >, like, and so on) for each key in the queryMatch dictionary.
If the queryOperator dictionary does not contain a key contained in the queryMatch dictionary, the default is to match the value exactly (=) if the value is a number or a date and to perform pattern matching if the value is a String. In the case of string values, the defaultStringMatchFormat and defaultStringMatchOperator specify exactly how the pattern matching will be performed.
See Also: allQualifierOperators , qualifyDataSource, qualifyDisplayGroup, relationalQualifierOperators s
Returns a dictionary of less than query values. The qualifierFromQueryValues method uses this dictionary along with the queryMatch and queryMin dictionaries to construct qualifiers.
See Also: qualifyDataSource, qualifyDisplayGroup, queryOperator
Returns a dictionary of greater than query values. The qualifierFromQueryValues method uses this dictionary along with the queryMatch and queryMin dictionaries to construct qualifiers.
See Also: qualifyDataSource, qualifyDisplayGroup, queryOperator
Returns a dictionary of operators to use on items in the queryMatch dictionary. If a key in the queryMatch dictionary also exists in queryOperator, that operator for that key is used. The allQualifierOperators method returns the operator strings you can use as values in this dictionary.
See Also: qualifierFromQueryValues, queryMax queryMin, relationalQualifierOperators
Sends out a contents changed notification.
Returns an array containing all of the relational operators supported by next.eo.Qualifier: =, !=, <, <=, >, and >=. In other words, returns all of the Qualifier operators except for the ones that work exclusively on strings: "like" and "caseInsensitiveLike".
See Also: allQualifierOperators , queryOperator
Attempts to select the object just after the currently selected one. The selection is altered in this way:
This method returns null to force the page to reload.
See Also: selectPrevious, setSelectionIndexes
Attempts to select the object equal to anObject in the receiver's displayed objects array, returning true if successful and false otherwise. anObject is equal to an object in the displayed objects array if its address is the same as the object in the array.
See Also: selectNext, selectPrevious
Attempts to select the objects in the receiver's displayed objects array whose addresses are equal to those of objects, returning true if successful and false otherwise.
See Also: setSelectionIndexes, selectObjectsIdenticalToAndSelectFirstOnNoMatch
Selects the objects in the receiver's displayed objects array whose ids are equal to those of objects, returning true if successful and false otherwise. If no objects in the displayed objects array match objects and flag is true, attempts to select the first object in the displayed objects array.
See Also: setSelectionIndexes, selectObjectsIdenticalTo
Attempts to select the object just before the presently selected one. The selection is altered in this way:
This method returns null to force the page to reload.
See Also: selectNext, redisplay
Returns the first selected object in the displayed objects array, or null if there's no such object.
See Also: displayedObjects, selectionIndexes, selectedObjects
Returns the objects selected in the receiver's displayed objects array.
See Also: displayedObjects, selectionIndexes, selectedObject
Returns the selection as an array of integers. The integers are indexes into the array returned by displayedObjects.
See Also: selectedObject, selectedObjects, setSelectionIndexes
Returns true if the receiver automatically selects its first displayed object after a fetch if there was no selection, false if it leaves an empty selection as-is.
DisplayGroups by default do select the first object after a fetch when there was no previous selection.
See Also: displayedObjects, fetch, setSelectsFirstObjectAfterFetch
Displays the anInt batch of objects. The total batch count equals the number of displayed objects divided by the batch size. For example, if the DisplayGroup has one hundred objects to display and the batch size is twenty, there are five batches. The first batch has a batch index of 1. setCurrentBatchIndex(3) would display the third batch of objects (objects 41 to 60 in this example).
If anInt is greater than the number of batches, this method displays the first batch.
See Also: batchCount, currentBatchIndex, displayBatchContainingSelectedObject, displayNextBatch, displayPreviousBatch, numberOfObjectsPerBatch
Sets the receiver's next.eo.DataSource to aDataSource. In the process, it performs these actions:
See Also: dataSource
Sets the receiver's delegate to anObject, without retaining it.
See Also: delegate, next.wo.DisplayGroupDelegate interface
Sets the detail key to detailKey for a detail display group. The detail key is the key that retrieves from the master object the objects that this display group manages. You must set a detail key before you set a master object.
If the receiver is not a detail display group, this method has no effect. A display group is a detail display group if its data source is an next.eo.DetailDataSource. You typically create a detail display group by dragging a to-many relationship from EOModeler to an open component in WebObjects Builder. Doing so sets the detail key and master object, so you rarely need to use this method.
See Also: hasDetailDataSource, detailKey, setMasterObject
Controls whether the receiver automatically fetches its objects after being loaded. If flag is true it does; if flag is false the receiver must be told explicitly to fetch. The default is false. You can also set this behavior in WebObjects Builder in the Display Group Options panel.
See Also: fetch, fetchesOnLoad
Sets according to flag whether the receiver is in query mode. In query mode, controls in the user interface that normally display values become empty, allowing users to type queries directly into them (this is also known as a "Query by Example" interface). In effect, the receiver's "displayedObjects" are replaced with an empty queryMatch dictionary. When qualifyDisplayGroup or qualifyDataSource is subsequently invoked, the query is performed and the display reverts to displaying values-- this time, the objects returned by the query.
See Also: inQueryMode
Sets default values to be used for newly inserted objects. When you use the insert method to add an object, that object is initially empty. Because the object is empty, there is no value to be displayed on the HTML page, meaning there is nothing for the user to select and modify. You use this method to provide at least one field that can be displayed for the newly inserted object. The possible keys into the dictionary are the properties of the entity managed by this display group. For example, a component that displays a list of movie titles and allows the user to insert new movie titles might contain these statements to ensure that all new objects have something to display as a movie title:
[defaultValues setObject:@"New title" forKey:@"title"]; [movies setInsertedObjectDefaultValues:defaultValues];
See Also: insertedObjectDefaultValues
Sets the additional keys to which dynamic elements can be bound to keys.
See Also: localKeys
Sets the master object to masterObject for detail display groups and then performs a fetch if the display group is set to fetch on load. The master object owns the objects controlled by this display group.
Before you use this method, you should use the setDetailKey to set the key to this relationship. You typically create a detail display group by dragging a to-Many relationship from Modeler to an open component in WebObjects Builder. Doing so sets the master object and detail key, so you typically do not have to use this method.
If the receiver is not a detail display group, this method has no effect.
See Also: hasDetailDataSource, masterObject
Sets the number of objects the receiver displays at a time. For example, suppose you are displaying one hundred records. Instead of displaying all of these at once, you can set the batch size so that the page displays a more manageable number (for example, 10). WebObjects Builder allows you to set the number of objects per batch on the Display Group Options panel.
See Also: batchCount, displayNextBatch, displayPreviousBatch, numberOfObjectsPerBatch
Sets the receiver's objects to objects, regardless of what its next.eo.DataSource provides. This method doesn't affect the DataSource's objects at all; specifically, it results in neither inserts nor deletes of objects in the DataSource. objects should contain objects with the same property names or methods as those accessed by the receiver. This method is used by fetch to set the array of fetched objects; you should rarely need to invoke it directly.
After setting the object array, this method restores as much of the original selection as possible. If there's no match and the receiver selects after fetching, then the first object is selected.
See Also: allObjects, displayedObjects, fetch, selectsFirstObjectAfterFetch
Sets the receiver's qualifier to aQualifier. This qualifier is used to filter the receiver's array of objects for display. Use updateDisplayedObjects to apply the qualifier.
If the receiver's delegate responds to displayArrayForObjects (defined in the next.wo.DisplayGroupDelegate interface), that method is used instead of the qualifier to filter the objects.
See Also: displayedObjects, qualifier
Selects the objects at indexes in the receiver's array if possible, returning true if successful and false if not (in which case the selection remains unaltered). indexes is a array of java.lang.Integers. This method is the primitive method for altering the selection; all other such methods invoke this one to make the change.
This method invokes endEditing to wrap up any changes being made by the user. If endEditing returns false, this method fails and returns false. This method then checks the delegate with a shouldChangeSelectionToIndexes message (defined in the next.wo.DisplayGroupDelegate interface). If the delegate returns false, this method also fails and returns false. If the receiver successfully changes the selection, its observers each receive a subjectChanged message and, if necessary, a displayGroupDidChangeSelectedObjects message.
Note: The selection set here is only a programmatic selection; the objects on the screen are not highlighted in any way.
See Also: allObjects
Controls whether the receiver automatically selects its first displayed object after a fetch when there were no selected objects before the fetch. If flag is true it does; if flag is false then no objects are selected.
DisplayGroups by default do select the first object after a fetch when there was no previous selection.
See Also: displayedObjects, fetch, selectsFirstObjectAfterFetch
Sets the next.eo.SortOrdering objects that updateDisplayedObjects uses to sort the displayed objects to orderings. Use updateDisplayedObjects to apply the sort orderings.You can also set this value using the WebObjects Builder Display Group Options panel.
If the receiver's delegate responds to displayArrayForObjects (defined in the next.wo.DisplayGroupDelegate interface), that method is used instead of the sort orderings to order the objects.
See Also: displayedObjects, sortOrdering, updateDisplayedObjects
Controls the receiver's behavior on encountering a validation error. In the Web context, this method has no effect.
DisplayGroups by default don't validate changes immediately.
See Also: saveChanges (in next.eo.EditingContext),
Returns an array of SortOrdering objects that updateDisplayedObjects uses to sort the displayed objects, as returned by the displayedObjects method.
See Also: setSortOrdering
Recalculates the receiver's displayed objects arrays and redisplays. If the delegate responds to displayArrayForObjects (defined in the next.wo.DisplayGroupDelegate interface), it's sent this message and the returned array is set as the DisplayGroup's displayed objects. Otherwise, the receiver applies its qualifier and sort ordering to its array of objects. In either case, any objects that were selected before remain selected in the new displayed object's array.
See Also: redisplay, allObjects, displayedObjects, qualifier, selectedObjects, sortOrdering
Returns true if the receiver immediately handles validation errors, or leaves them for the next.eo.EditingContext to handle when saving changes.
By default, DisplayGroups don't validate changes immediately.
See Also: setValidatesChangesImmediately