Class SimpleArrayPanel provides a panel that can
* hold one or more views of a given type with the number of such
* views under interactive user control.
The views are arranged in a 4-column vertical list with the * following structure in each row:
* *TypedView Class object.This 4-column vertical list is placed in a scroll pane. The * designer can determine how many rows will be visible at once.
* *The interactive controls that permit the user to change the * total number of views are placed in a panel underneath the scroll * pane.
* *To construct a SimpleArrayPanel, the user must
* supply its viewType which is an object of type
* Class that defines the view that will be repeated
* in the panel.
The following restrictions on the viewType must
* hold:
viewType must not be null.viewType must extend JComponent
* so a view may be directly inserted into its panel.viewType must implement TypedView
* so the model data can be extracted from a view by the standard
* methods of the TypedView interface.viewType class must have a default
* constructor.If the method createViewForRow is overridden, that
* method may use a different constructor for the viewType
* class and it is then not necessary to have a default constructor.
The most common way to obtain a viewType is to
* take the name of a class, say FooView, that extends
* JComponent, implements TypedView, and
* has a default constructor, and then to use
* FooView.class for the viewType. Later
* in this introduction, we will use this notation for examples.
The SimpleArrayPanel class has several constructors
* that take optional parameters. We gather here a description of
* these optional parameters and their default values.
initialIndex: Internally, rows are numbered from
* zero; for the user interface, rows will be labeled with
* index + initialIndex;
* the default value for initialIndex is 0.visibleViewCount: The visible view count is the
* number of views that should be visible in the scroll pane at
* one time; the minimum and the default value is 2.gap: The gap is the horizontal and vertical pixel
* gap to be used in the TablePanels made internally
* in the array panel; the minimum and the default value is 4.autoHalo: If true, then each view will be wrapped
* in a new Halo so that error highlighting will be
* localized around the view; the default is false since it may
* be the case that a view has its own error highlight strategy.By default, the interactive controls that permit the user to change
* the number of views show the length of the array, that is,
* the total number of views. For some applications, this value may not
* be the most meaningful. For example, for a classic polynomial, the
* meaningful number is the degree which is the highest coefficient that
* is available. In this case, the degree equals length - 1.
* To accomodate this, the SimpleArrayPanel class maintains
* an internal value lengthOffset that is added to the
* length before it is displayed in the user interface. The following 2
* calls would tweak the interface to make it suitable for polynomial
* coefficients:
setLengthOffset(-1);*
setLengthButtonName("Set Degree");
*
* The SimpleArrayPanel class smoothly handles the
* transition between the internal length and the number displayed
* in the interactive controls.
To obtain an object that collects all views into an array for
* internal manipulation, use the method getViews. This
* method returns an Object that is actually an array and
* that may be cast to an array of viewType.
For example, if viewType is FooView.class,
* then the return value of getViews may be cast to an array
* type FooView[].
Similarly, to obtain an object that uses the view states of the
* various views to create an array of corresponding data model objects,
* use either demandObjects or requestObjects.
* These methods return an Object that is actually an array
* that may be cast to an array of viewDataType.
For example, if viewType is FooView.class
* and its corresponding model data type is Foo, then the
* return value for either of the methods above may be cast to the array
* type Foo[].
Both demandObjects and requestObjects use
* any automatic error checking and correction that has been built in to
* the corresponding methods in the viewType class.
The class SimpleArrayPanel is similar to the existing
* class ArrayPanel but is simpler to use since the most
* common defaults are taken as given. More importantly, this class can
* be used as is since it is not abstract and sufficient tools are made
* available to manage the model-view interaction directly. Finally,
* the new interface controls that permit a user to insert or delete an
* individual row gives the user much more power than is available with
* the older ArrayPanel class.
The class SimpleArrayPanel does not itself implement
* the interface TypedView. The critical reason is that
* to implement TypedView, it would be necessary to define
* the following methods whose definitions cannot be done in a uniform
* manner:
public Class getDataType()*
public Stringable demandObject()*
public Stringable requestObject() throws CancelledException* *
If the user of this class wishes to build a TypedView,
* then it is necessary to create or obtain a view class appropriate for
* an overall view and to define a derived class of this class that does
* implement the above three methods.
*
*
As a convenience, dummy implementations of the following methods of
* the interface TypedView have already been provided:
public void setInputProperties(InputProperties properties)*
public InputProperties getInputProperties()* *
For backward compatibility, the older class ArrayPanel
* is still part of JPT and has been left basically as is. We recommend
* SimpleArrayPanel for all new code.
TablePanel objects constructed directly in
* this array panel; the value is 4.
*/
public static final int MINIMUM_GAP = 4; // pixels
/** The Paintable to make the "insert one row icon". */
public static final Paintable insertRowPaintable
= makeInsertRowPaintable();
/** The Paintable to make the "delete one row icon". */
public static final Paintable deleteRowPaintable
= makeDeleteRowPaintable();
/**
* The view type is the type of each input view in the
* array panel; this type must
* extend the class JComponent,
* implement the interface TypedView, and
* have a public default constructor.
*/
protected Class viewType = null;
/**
* The view data type is the data type associated with
* the view type via the method
* getDataType() of TypedView.
*/
protected Class viewDataType = null;
/**
* The actual length of the array, that is, the current
* number of input views in the array panel.
*/
protected int arrayLength = 0;
/**
* The lengthTFV should display the user meaningful length
* of the array which equals
* arrayLength + lengthOffset.
*/
protected int lengthOffset = 0;
/**
* The initial index in the automatic labels of the input
* views in the array panel.
*/
protected int initialIndex = 0;
/**
* The number of views that should be visible in the scroll
* pane without needing scrolling; this number is used to
* set the minimum size of the scroll pane view port.
*/
protected int visibleViewCount = MINIMUM_VISIBLE;
/**
* The horizontal and vertical cell gap to be used for all
* TablePanel objects constructed directly in
* this array panel.
*/
protected int gap = MINIMUM_GAP;
/**
* Determines whether or not to wrap each view of the array
* panel in a Halo to localize error highlights.
*/
protected boolean autoHalo = false;
/** The preferred width of a default instance of the view type. */
protected int viewWidth = 0;
/** The preferred height of a default instance of the view type. */
protected int viewHeight = 0;
/** The preferred width of the labels and text field view. */
protected int labelWidth = TextFieldView.getSampleWidth("0000");
/**
* The panel that contains the 2-column vertical list with a
* label in the left column of each row and a view in the
* right column of each row.
*/
protected TablePanel innerPanel = null;
/** The scroll pane that contains the inner panel. */
protected JPTScrollPane scrollPane = null;
/** The interactive controls panel. */
protected TablePanel controls = null;
/**
* The lengthTFV is part of the interactive user controls;
* this field displays the user meaningful length of the
* array which equals
* arrayLength + lengthOffset.
*/
protected TextFieldView lengthTFV = new TextFieldView(labelWidth);
/** The action to increment the number of views. */
protected SimpleAction incrementLength =
new SimpleAction("+") {
public void perform() { incrementLength(); };
};
/** The action to decrement the number of views. */
protected SimpleAction decrementLength =
new SimpleAction("-") {
public void perform() { decrementLength(); };
};
/**
* The action to set the array length from the user meaningful
* length in the lengthTFV; this action takes care of required
* adjustments.
*/
protected SimpleAction setLengthFromGUI =
new SimpleAction("Set Length") {
public void perform() { setLengthFromGUI(); };
};
/**
* The vector to hold references to the views in this panel
* for ease of access by the methods of this class.
*/
protected Vector viewList = new Vector();
/**
* The 1-parameter constructor.
* *For a complete discussion of contructor parameters and * defaults, see the introduction to this class.
* * @param viewType the type of view to use in this panel */ public SimpleArrayPanel (Class viewType) { this(viewType, 0, MINIMUM_VISIBLE, MINIMUM_GAP, false); } /** *The 2-parameter constructor.
* *For a complete discussion of contructor parameters and * defaults, see the introduction to this class.
* * @param viewType the type of view to use in this panel * @param initialIndex the initial index in the labels */ public SimpleArrayPanel (Class viewType, int initialIndex) { this(viewType, initialIndex, MINIMUM_VISIBLE, MINIMUM_GAP, false); } /** *The 3-parameter constructor.
* *For a complete discussion of contructor parameters and * defaults, see the introduction to this class.
* * @param viewType the type of view to use in this panel * @param initialIndex the initial index in the labels * @param visibleViewCount the number of views to show at once */ public SimpleArrayPanel (Class viewType, int initialIndex, int visibleViewCount) { this(viewType, initialIndex, visibleViewCount, MINIMUM_GAP, false); } /** *The 4-parameter constructor.
* *For a complete discussion of contructor parameters and * defaults, see the introduction to this class.
* * @param viewType the type of view to use in this panel * @param initialIndex the initial index in the labels * @param visibleViewCount the number of views to show at once * @param gap the pixel gap between cells */ public SimpleArrayPanel (Class viewType, int initialIndex, int visibleViewCount, int gap) { this(viewType, initialIndex, visibleViewCount, gap, false); } /** *The 5-parameter constructor.
* *For a complete discussion of contructor parameters and * defaults, see the introduction to this class.
* * @param viewType the type of view to use in this panel * @param initialIndex the initial index in the labels * @param visibleViewCount the number of views to show at once * @param gap the pixel gap between cells * @param autoHalo whether or not to auto-halo the views */ public SimpleArrayPanel (Class viewType, int initialIndex, int visibleViewCount, int gap, boolean autoHalo) { setViewType(viewType); setInitialIndex(initialIndex); setVisibleViewCount(visibleViewCount); setTableGap(gap); setAutoHalo(autoHalo); buildArrayPanel(); } /** Returns the type of the views repeated in this panel. */ public final Class getViewType() { return viewType; } /** * Returns the model data type associated with the views * repeated in this panel. */ public final Class getViewDataType() { return viewDataType; } /** *Returns the i-th view installed in this panel.
* *Returns null if i is out of range.
Sets the view state of the i-th view to the given data.
* *Does nothing if i is out of range or the given data is
* null.
Gets the view state of the i-th view.
* *Returns null if i is out of range.
Sets the default view state of the i-th view to the * given data.
* *Does nothing if i is out of range or the given data is
* null.
Gets the default view state of the i-th view.
* *Returns null if i is out of range.
Resets the i-th view state to its default state.
* *Does nothing if i is out of range.
* * @param i the view index */ public final void reset(int i) { TypedView typedview = getTypedView(i); if (typedview == null) return; typedview.reset(); } /** *Applies demandObject to the i-th view
* and returns the resulting Stringable.
Returns null if i is out of range.
Applies requestObject to the i-th view
* and returns the resulting Stringable.
Returns null if i is out of range.
Throws CancelledException if the user
* cancels when an error has been detected.
Applies setInputProperties to the i-th
* view.
Does nothing if i is out of range.
* * @param i the view index */ public final void setInputProperties(int i, InputProperties properties) { TypedView typedview = getTypedView(i); if (typedview == null) return; typedview.setInputProperties(properties); } /** *Gets the input properties of the i-th view.
* *Returns null if i is out of range.
Returns an object that is actually an array with the * list of views installed in the panel.
* *Assume, for example,
* that viewType is FooView.class
* and that number is the number of views in
* the panel. Then the return value may be cast to an array
* FooView[] and the length of this array will
* be number.
The array is constructed by the following Java call * that, in effect, uses reflection:
* *Array.newInstance(viewType, number)* *
This array is then populated by calls to the method
* getTypedView(i).
Returns an object that is actually an array that is
* populated by calling demandObject for each
* view.
Assume, for example,
* that viewType is FooView.class,
* that viewDataType is Foo.class,
* and that number is the number of views in
* the panel. Then the return value may be cast to an array
* Foo[] and the length of this array will be
* number.
The array is constructed by the following Java call * that, in effect, uses reflection:
* *Array.newInstance(viewDataType, number)* *
This array is then populated by calls to the method
* demandObject(i).
Returns an object that is actually an array that is
* populated by calling requestObject for each
* view.
Assume, for example,
* that viewType is FooView.class,
* that viewDataType is Foo.class,
* and that number is the number of views in
* the panel. Then the return value may be cast to an array
* Foo[] and the length of this array will be
* number.
The array is constructed by the following Java call * that, in effect, uses reflection:
* *Array.newInstance(viewDataType, number)* *
This array is then populated by calls to the method
* requestObject(i).
Throws CancelledException if the user
* cancels when an error has been detected.
Returns an array of type TypedView[] with
* the views in the panel.
This method is less useful than getViews()
* since the array returned cannot be directly cast to an
* array of the actual viewType due to basic
* restrictions on how Java constructs arrays. Therefore,
* this method is only useful in so far as you wish to treat
* the views simply as TypedView objects.
Returns an array of type Stringable[] that
* is populated by calling demandObject for each
* view.
This method is less useful than
* demandObjects()
* since the array returned cannot be directly cast to an
* array of the actual viewDataType due to basic
* restrictions on how Java constructs arrays. Therefore,
* this method is only useful in so far as you wish to treat
* the objects simply as Stringable objects.
Returns an array of type Stringable[] that
* is populated by calling requestObject for each
* view.
This method is less useful than
* requestObjects()
* since the array returned cannot be directly cast to an
* array of the actual viewDataType due to basic
* restrictions on how Java constructs arrays. Therefore,
* this method is only useful in so far as you wish to treat
* the objects simply as Stringable objects.
Throws CancelledException if the user
* cancels when an error has been detected.
Sets the view states of the views in this panel * to the corresponding strings in the data array.
* * @param data the desired view state array */ public final void setViewStates(String[] data) { if (data == null) return; int min = Math.min(arrayLength, data.length); for (int i = 0; i < min; i++) if (data[i] != null) setViewState(i, data[i]); } /** *Gets the view states of the views in this panel * as items in a string data array.
*/ public final String[] getViewStates() { String[] data = new String[arrayLength]; for (int i = 0; i < arrayLength; i++) data[i] = getViewState(i); return data; } /** *Sets the default view states of the views in this panel * to the corresponding strings in the data array.
* * @param data the desired default view state array */ public final void setDefaultViewStates(String[] data) { if (data == null) return; int min = Math.min(arrayLength, data.length); for (int i = 0; i < min; i++) if (data[i] != null) setDefaultViewState(i, data[i]); } /** *Gets the default view states of the views in this panel * as items in a string data array.
*/ public final String[] getDefaultViewStates() { String[] data = new String[arrayLength]; for (int i = 0; i < arrayLength; i++) data[i] = getDefaultViewState(i); return data; } /** *Sets the input properties of each view to the same input * properties object.
* * @param properties the common input properties for all views */ public final void setCommonInputProperties (InputProperties properties) { for (int i = 0; i < arrayLength; i++) setInputProperties(i, properties); } /** *Sets the input properties of each view to the corresponding * input properties object in the given array of properties.
* * @param properties the array of input properties for all views */ public final void setInputPropertiesByView (InputProperties[] properties) { if (properties == null) return; int min = Math.min(arrayLength, properties.length); for (int i = 0; i < min; i++) setInputProperties(i, properties[i]); } /** *Gets the input properties object for each view and then * returns this information in an array. */ public final InputProperties[] getInputPropertiesByView() { InputProperties[] properties = new InputProperties[arrayLength]; for (int i = 0; i < arrayLength; i++) properties[i] = getInputProperties(i); return properties; } /** *
Sets the view state of the panel using the data * encoded in the given string.
* *Equivalent to:
* *setViewStates(Strings.decode(data))* * @param data the encoded view state */ public final void setViewState(String data) { setViewStates(Strings.decode(data)); } /** *
Gets the view state of the panel as an * encoded string. * *
Equivalent to:
* *return CodecUtilities.encode(getViewStates())*/ public final String getViewState() { return CodecUtilities.encode(getViewStates()); } /** *
Sets the default view state of the panel using the data * encoded in the given string.
* *Equivalent to:
* *setDefaultViewStates(Strings.decode(data))* * @param data the encoded default view state */ public final void setDefaultViewState(String data) { setDefaultViewStates(Strings.decode(data)); } /** *
Gets the default view state of the panel as an * encoded string. * *
Equivalent to:
* *return CodecUtilities.encode(getDefaultViewStates())*/ public final String getDefaultViewState() { return CodecUtilities.encode(getDefaultViewStates()); } /** Resets each view to its default view state. */ public final void reset() { for (int i = 0; i < arrayLength; i++) reset(i); } /** *
This method does nothing since the panel as a whole does * not utilize input properties.
* *Implemented trivially in case the user wants to create a
* derived class that implements TypedView.
This method returns null since the panel as
* a whole does not utilize input properties.
Implemented trivially in case the user wants to create a
* derived class that implements TypedView.
Returns the number of views in this panel or, equivalently, * the length of the array of views.
*/ public final int getLength() { return arrayLength; } /** *Returns the measure of the length of the array that is * meaningful to the end user.
* *Equivalent to:
* *getLength() + getLengthOffest()*/ public final int getUserLength() { return arrayLength + lengthOffset; } /** *
Returns the constant that should be added to the length * to obtain the length measure meaningful to the end user.
*/ public final int getLengthOffset() { return lengthOffset; } /** *Returns the text on the GUI button that sets the length * of the array using the user meaningful length that is held * in the corresponding GUI text field view.
*/ public final String getLengthButtonName() { return (String) setLengthFromGUI.getValue(Action.NAME); } /** *Sets the number of views in this panel or, equivalently, * the length of the array of views.
* *The actual length set will be at least 1.
* *This method is responsible for adding labels, views, * and the "insert one row" and "delete one row" buttons if * the length will be increased. To do this, this method * calls:
* *String createLabelForRow(int i)* *
TypedView createViewForRow(int i)* *
These methods may be overridden in a derived class if * the user of this class wants non-default behavior but the * constraints discussed in this class must be observed.
* *This method is responsible for removing labels, views, * and buttons if the length will be decreased.
* * @param length the desired number of views in this panel */ public final void setLength(int length) { if (length < MINIMUM_LENGTH) length = MINIMUM_LENGTH; if (length == arrayLength) return; if (length > arrayLength) { // add labels, views, and buttons for (int i = arrayLength; i < length; i++) { // add label to panel String label = createLabelForRow(i); innerPanel.addObject(label, i, 0); // add typed view to panel and view list // auto halo if necessary TypedView view = createViewForRow(i); viewList.add(view); Object object = view; if (autoHalo) object = new Halo(object); innerPanel.addObject(object, i, 1); // add insert and delete buttons JButton insertButton = getInsertRowButton(i); JButton deleteButton = getDeleteRowButton(i); innerPanel.addObject(insertButton, i, 2); innerPanel.addObject(deleteButton, i, 3); } } else { // remove objects for (int i = arrayLength - 1; i >= length; i--) { // remove view from view list viewList.remove(i); int k = 4 * i; // remove insert and delete buttons innerPanel.remove(k + 3); innerPanel.remove(k + 2); // remove view from panel innerPanel.remove(k + 1); // remove label from panel innerPanel.remove(k); } } arrayLength = length; lengthTFV.setViewState("" + getUserLength()); repaint(); } /** *Sets the number of views using the measure of length * that is meaningful to the end user.
* * @param userLength the user meaningful length */ public final void setUserLength(int userLength) { setLength(userLength - lengthOffset); } /** *Sets the constant that should be added to the length * to obtain the length measure meaningful to the end user.
* * @param offset the offset used to adjust the length */ public final void setLengthOffset(int offset) { lengthOffset = offset; lengthTFV.setViewState("" + getUserLength()); } /** *Sets the text on the GUI button that sets the length of * the array using the user meaningful length that is held in * the corresponding GUI text field view.
* * @param name the text for the button that sets the length */ public final void setLengthButtonName(String name) { if ((name == null) || (name.length() == 0)) return; setLengthFromGUI.putValue(Action.NAME, name); } /** A helper method to increment the length by 1. */ public final void incrementLength() { setLength(arrayLength + 1); } /** A helper method to decrement the length by 1. */ public final void decrementLength() { setLength(arrayLength - 1); } /** *Returns the label String for the i-th row.
* *By default, this method returns:
* *"" + (i + initialIndex)* *
May be overridden in a derived class if the designer * wants to create a different label String.
* * @param i the row index */ public String createLabelForRow(int i) { return "" + (i + initialIndex); } /** *Returns a new TypedView for the i-th row
* whose class is given by the view type.
By default, this method returns:
* *(TypedView) viewType.newInstance()* *
In particular, this implementation does not use the * index i.
* *May be overridden in a derived class if the designer * wants to use a non-default constructor for the view.
* *The view returned must be assignable to the view type * used to construct the array panel.
* *Furthermore, the view returned by this method must * have the same preferred size independent of the index i.
* * @param i the row index */ protected TypedView createViewForRow(int i) { TypedView typedview = null; try { typedview = (TypedView) viewType.newInstance(); } catch (Exception ex) { throw new RuntimeException ("Failed to construct view in SimpleArrayPanel"); } return typedview; } /** *Method used in the constructor to set the view type of * the views in this panel.
* *Performs error checks to verify the constraints that * are discussed in the introduction to this class.
* *Extracts the model data type corresponding to the view * type and determines the dimensions of a typical view.
* * @param viewType the class of the views in this panel */ protected final void setViewType(Class viewType) { if (viewType == null) throw new NullPointerException ("View type in SimpleArrayPanel must be non-null"); if (! JComponent.class.isAssignableFrom(viewType)) throw new IllegalArgumentException ("View type in SimpleArrayPanel must extend JComponent"); if (! TypedView.class.isAssignableFrom(viewType)) throw new IllegalArgumentException ("View type in SimpleArrayPanel must implement TypedView"); // must set the viewType before call to createViewForRow this.viewType = viewType; // call createViewForRow to create a typical view // in order to extract useful information TypedView typedview = createViewForRow(0); JComponent component = (JComponent) typedview; this.viewDataType = typedview.getDataType(); Dimension dimension = component.getPreferredSize(); viewWidth = dimension.width; viewHeight = dimension.height; } /** *Sets the initial index for the GUI view labels.
* * @param initialIndex the initial index for the labels */ protected final void setInitialIndex(int initialIndex) { this.initialIndex = initialIndex; } /** *Sets the number of views that should be visible in * the scroll pane without needing scrolling.
* *This number is used to set the minimum size of the * scroll pane view port.
* * @param visibleViewCount the number of views visible at once */ protected final void setVisibleViewCount(int visibleViewCount) { if (visibleViewCount < MINIMUM_VISIBLE) visibleViewCount = MINIMUM_VISIBLE; this.visibleViewCount = visibleViewCount; } /** *Sets the horizontal and vertical gap for
* TablePanel objects constructed in this panel.
*
* @param gap the standard pixel gap in tables
*/
protected final void setTableGap(int gap) {
if (gap < MINIMUM_GAP)
gap = MINIMUM_GAP;
this.gap = gap;
setHorizontalGap(gap);
setVerticalGap(gap);
}
/**
*
Sets whether or not each view should be wrapped in a
* Halo object before being inserted into the
* panel.
Insert a row at the given index by inserting a row at the end * of the array panel and then moving the contents of each cell upward * by one cell starting at the index position.
* *Changes the contents of the cell at index to its default view * state.
* *Does nothing unless 0 <= index <getLength().
* * @param index the index at which to insert a row */ public final void insertRowAtIndex(int index) { int L = getLength(); if ((index < 0) || (index >= L)) return; // insert cell at end incrementLength(); // move contents one cell upward for (int i = L; i > index; i--) { TypedView above = getTypedView(i); TypedView below = getTypedView(i - 1); above.setViewState(below.getViewState()); } // reset view state of cell at index TypedView start = getTypedView(index); start.setViewState(start.getDefaultViewState()); } /** *Delete a row at the given index by moving the contents of * each cell at a higher position downward by one cell and then * by deleting the the cell at the end of the array.
* *Does nothing if the array length is 1.
* *Does nothing unless 0 <= index <getLength().
* * @param index the index at which to delete a row */ public final void deleteRowAtIndex(int index) { int L = getLength(); if (L <= MINIMUM_LENGTH) return; if ((index < 0) || (index >= L)) return; // move contents one cell downward for (int i = (index + 1); i < L; i++) { TypedView above = getTypedView(i); TypedView below = getTypedView(i - 1); below.setViewState(above.getViewState()); } // delete cell at end decrementLength(); } /** *Returns an action that inserts a row at the given index.
* * @param index the index at which to insert a row */ public Action getInsertRowAction(final int index) { return new SimpleAction() { public void perform() { insertRowAtIndex(index); } }; } /** *Returns an action that deletes a row at the given index.
* * @param index the index at which to delete a row */ public Action getDeleteRowAction(final int index) { return new SimpleAction() { public void perform() { deleteRowAtIndex(index); } }; } /** *Returns a button that inserts a row at the given index.
* * @param index the index at which to insert a row */ public JButton getInsertRowButton(int index) { return PaintableTools.makeButton (insertRowPaintable, getInsertRowAction(index)); } /** *Returns a button that deletes a row at the given index.
* * @param index the index at which to delete a row */ public JButton getDeleteRowButton(int index) { return PaintableTools.makeButton (deleteRowPaintable, getDeleteRowAction(index)); } /** * Helper method to set the length using the end user length * extracted from the GUI. */ protected final void setLengthFromGUI() { int MINIMUM = MINIMUM_LENGTH + lengthOffset; StringableFilter filter = new MinimumBoundFilter.Long(MINIMUM); try { setUserLength(lengthTFV.requestInt(filter)); } catch (CancelledException ex) { } } /** Method to make thePaintable for the "insert row icon". */
public static Paintable makeInsertRowPaintable() {
XRect r = new XRect(0, 0, 16, 16);
XLine2D v = new XLine2D( 8, 4, 8, 12);
XLine2D h = new XLine2D( 4, 8, 12, 8);
BasicStroke stroke = new BasicStroke(2);
ShapePaintable p1 =
new ShapePaintable
(v, PaintMode.DRAW, null, Colors.black, stroke);
ShapePaintable p2 =
new ShapePaintable
(h, PaintMode.DRAW, null, Colors.black, stroke);
ShapePaintable p3 =
new ShapePaintable
(r, PaintMode.FILL, Colors.lightskyblue);
PaintableSequence icon =
new PaintableSequence(new Object[] { p1, p2, p3 });
return icon;
}
/** Method to make the Paintable for the "delete row icon". */
public static Paintable makeDeleteRowPaintable() {
XRect r = new XRect(0, 0, 16, 16);
XLine2D a = new XLine2D( 4, 4, 12, 12);
XLine2D b = new XLine2D(12, 4, 4, 12);
BasicStroke stroke = new BasicStroke(2);
ShapePaintable p1 =
new ShapePaintable
(a, PaintMode.DRAW, null, Colors.black, stroke);
ShapePaintable p2 =
new ShapePaintable
(b, PaintMode.DRAW, null, Colors.black, stroke);
ShapePaintable p3 =
new ShapePaintable
(r, PaintMode.FILL, Colors.red);
PaintableSequence icon =
new PaintableSequence(new Object[] { p1, p2, p3 });
return icon;
}
}