KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > objectweb > jac > aspects > gui > FieldAppearenceGuiConf


1 /*
2   Copyright (C) 2001-2003 Renaud Pawlak <renaud@aopsys.com>,
3                           Laurent Martelli <laurent@aopsys.com>
4
5   This program is free software; you can redistribute it and/or modify
6   it under the terms of the GNU Lesser General Public License as
7   published by the Free Software Foundation; either version 2 of the
8   License, or (at your option) any later version.
9
10   This program is distributed in the hope that it will be useful,
11   but WITHOUT ANY WARRANTY; without even the implied warranty of
12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13   GNU Lesser General Public License for more details.
14
15   You should have received a copy of the GNU Lesser General Public License
16   along with this program; if not, write to the Free Software
17   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
18
19 package org.objectweb.jac.aspects.gui;
20
21 import org.objectweb.jac.core.rtti.*;
22
23 /**
24  * This configuration interface of the Gui aspect defines all the
25  * methods that handle the appearence of the fields in objects views.
26  *
27  * @see GuiAC
28  * @see View
29  *
30  * @author <a HREF="mailto:renaud@cnam.fr">Renaud Pawlak</a>
31  * @author <a HREF="mailto:laurent@aopsys.com">Laurent Martelli</a> */
32
33 public interface FieldAppearenceGuiConf {
34
35     /**
36      * Sets an item to be visible or not.
37      *
38      * <p>If a field of method item is not visible, it will not be
39      * displayed by the object views. If a class item is not visible,
40      * then it will not be possible to open a view on objects of this
41      * class.
42      *
43      * <p>By default, the RTTI does not define this property and every
44      * item is visble. Thus, the GUI aspect component programmer should
45      * overload the default contructor of this class to set some
46      * visible attributes to false.<p>
47      *
48      * @param member the member item (may be a method or a field name);
49      * it can be null to set the whole class visible or not
50      * @param visible whether the member must be visible
51      *
52      * @see GuiAC#isVisible(MetaItem)
53      */
54     void setVisible(MemberItem member, boolean visible);
55
56     /**
57      * Tells the GUI to use embedded editors in the default view for
58      * all fields of a class, whenever possible.
59      * @param cl the class item
60      * @see FieldEditor
61      */
62     void setEmbeddedEditors(ClassItem cl);
63
64     /**
65      * Tells the GUI wether to use embedded editors in a view for all
66      * fields of a class.
67      * @param cl the class item
68      * @param viewName the view name
69      * @param embedded wether to use embedded editors by default
70      * @see FieldEditor
71      */
72     void setEmbeddedEditors(ClassItem cl, String viewName, boolean embedded);
73
74     /**
75      * Tells wether to use embedded editors for the cells of a table
76      * in a given view.
77      *
78      * @param collection the collection whose table view to configure
79      * @param viewName the view name for which to configure
80      * @param embedded wether to use embedded editors or not in the cells of the table
81      *
82      * @see #setEmbeddedEditorColumns(CollectionItem,String,MemberItem[]) */
83     void setEmbeddedEditors(
84         CollectionItem collection,
85         String viewName,
86         boolean embedded);
87
88     /**
89      * Tells to use embedded editors for the cells of some columns in
90      * a given view
91      *
92      * @param collection the collection whose table view to configure
93      * @param viewName the view name for which to configure
94      * @param members wether to use embedded editors or not in the cells of the table
95      *
96      * @see #setEmbeddedEditors(CollectionItem,String,boolean)
97      */
98     void setEmbeddedEditorColumns(
99         CollectionItem collection,
100         String viewName,
101         MemberItem[] members);
102
103     /**
104      * This configuration method allows the programmer to set a class
105      * member to be internally edited for the default view.
106      *
107      * @param member the member item to be embedded (may be a
108      * field or a method)
109      * @see FieldEditor
110      * @see #setEmbeddedEditor(MemberItem,String,boolean)
111      */
112     void setEmbeddedEditor(MemberItem member);
113
114     /**
115      * This configuration method allows the programmer to set a class
116      * member to be internally edited.
117      *
118      * <p>By default, each member of a class is editable with an "edit"
119      * button or link that opens a popup that allows the user to edit
120      * its value (see the <code>FieldEditor</code> interface). If this
121      * configuration method is called, then the editor will be embedded
122      * into the object's view the member belongs to.
123      *
124      * @param member the member item to be embedded (may be a
125      * field or a method)
126      * @param viewName the view for which to use an embedded
127      * editor. "default", "autocreate" or one of your own.
128      * @param embedded wether to use an editor or not
129      *
130      * @see FieldEditor
131      * @see #setEmbeddedEditor(MemberItem,String,boolean)
132      */
133     void setEmbeddedEditor(MemberItem member, String viewName, boolean embedded);
134
135     /**
136      * Sets a border to the field in an object view.
137      *
138      * @param field the field
139      * @param alignment LEFT: title is on the left, RIGHT:
140      * title is on the right, CENTER: title is centered
141      * @param style LINE: the border is a line, ETCHED: the border is a
142      * 3D line, LOWERED: the border is a 3D effect that makes the
143      * bordered element lowered, RAISED: the border is a 3D effect that
144      * makes the bordered element raised.
145      * @see #setBorder(FieldItem)
146      */
147     void setBorder(FieldItem field, String alignment, String style);
148
149     /**
150      * Sets a border to the field in an object view. Uses a default
151      * style (LINE) and alignement(LEFT)
152      *
153      * @param field the field
154      * @see #setBorder(FieldItem,String,String)
155      */
156     void setBorder(FieldItem field);
157
158     /**
159      * Sets the width of the field's embedded editor when exist.
160      *
161      * @param field the field
162      * @param width the editor width
163      * @see #setEmbeddedEditor(MemberItem)
164      * @see #setEditorHeight(FieldItem,Length)
165      * @see #setDefaultEditorWidth(ClassItem,Length)
166      */
167     void setEditorWidth(FieldItem field, Length width);
168
169     /**
170      * Sets the default editor width for value of a given type.
171      *
172      * @param type the type
173      * @param width the editor width
174      *
175      * @see #setDefaultEditorWidth(ClassItem,Length)
176      * @see #setDefaultEditorHeight(VirtualClassItem,Length)
177      * @see #setEditorWidth(FieldItem,Length)
178      */
179     void setDefaultEditorWidth(VirtualClassItem type, Length width);
180
181     /**
182      * Sets the default editor width for value of a given type.
183      *
184      * @param type the type
185      * @param width the editor width
186      *
187      * @see #setDefaultEditorWidth(VirtualClassItem,Length)
188      * @see #setDefaultEditorHeight(VirtualClassItem,Length)
189      * @see #setEditorWidth(FieldItem,Length)
190      */
191     void setDefaultEditorWidth(ClassItem type, Length width);
192
193     /**
194      * Set a field to be editable.
195      *
196      * @param field the field
197      * @param editable the flag (true is default)
198      */
199     void setEditable(FieldItem field, boolean editable);
200
201     /**
202      * Sets the height of a field's editor. It does not affect single
203      * line editors (used by primitive types)
204      *
205      * @param field the field
206      * @param height the editor height
207      *
208      * @see #setEmbeddedEditor(MemberItem)
209      * @see #setEditorWidth(FieldItem,Length)
210      * @see #setDefaultEditorHeight(ClassItem,Length)
211      */
212     void setEditorHeight(FieldItem field, Length height);
213
214     /**
215      * Sets the default editor height for value of a given type.
216      *
217      * @param type the type
218      * @param height the editor height
219      *
220      * @see #setDefaultEditorHeight(ClassItem,Length)
221      * @see #setDefaultEditorWidth(VirtualClassItem,Length)
222      * @see #setEditorHeight(FieldItem,Length)
223      */
224     void setDefaultEditorHeight(VirtualClassItem type, Length height);
225
226     /**
227      * Sets the default editor height for value of a given type.
228      *
229      * @param type the type
230      * @param height the editor height
231      *
232      * @see #setDefaultEditorHeight(VirtualClassItem,Length)
233      * @see #setDefaultEditorWidth(VirtualClassItem,Length)
234      * @see #setEditorHeight(FieldItem,Length)
235      */
236     void setDefaultEditorHeight(ClassItem type, Length height);
237
238     /**
239      * Sets the category of an item of a class.
240      *
241      * <p>The category must correspond to one of these defined on the
242      * class with the <code>setCategories</code> configuration method.
243      *
244      * @param member the member to categorize (a method or a field)
245      * @param category the existing category name
246      * @see #setCategories(MemberItem,String[])
247      * @see ClassAppearenceGuiConf#setCategories(ClassItem,String[])
248      */
249     void setCategory(MemberItem member, String category);
250
251     /**
252      * Sets the categories of an item of a class.
253      *
254      * <p>The category must correspond to one of these defined on the
255      * class with the <code>setCategories</code> configuration method.
256      *
257      * @param member the member to categorize (a method or a field)
258      * @param categories the existing category names
259      * @see #setCategory(MemberItem,String)
260      * @see ClassAppearenceGuiConf#setCategories(ClassItem,String[])
261      */
262     void setCategories(MemberItem member, String[] categories);
263
264     /**
265      * Tells the GUI to insert a referenced object to be displayed as an
266      * embedded view in its container object view.
267      *
268      * @param member the member (reference field or method) that must
269      * be embedded
270      *
271      * @see #setEmbeddedView(MemberItem,String,boolean)
272      */
273     void setEmbeddedView(MemberItem member);
274
275     /**
276      * Tells the GUI to insert a referenced object to be displayed as an
277      * embedded view in its container object view.
278      *
279      * @param member the member (reference field or method) that must
280      * be embedded
281      * @param viewName the view for which the member must be embedded
282      * @param embedded wether to embedded the member or not
283      *
284      * @see #setEmbeddedView(MemberItem)
285      */
286     void setEmbeddedView(MemberItem member,
287                          String viewName,
288                          boolean embedded);
289
290     /**
291      * Tells the GUI wether to use an embedded view for the adder of a
292      * collection.
293      * @param collection the collection
294      * @param embedded wether to use an embedded view for the adder
295      */
296     void setEmbeddedAdder(CollectionItem collection, boolean embedded);
297
298     /**
299      * Sets the render of a given field (more precisely a collection)
300      * to be rendered by a table.
301      *
302      * <p>In a table view, each item of the displayed collection fills
303      * a table line. Each column represents one field of the objects
304      * whithin the collection (the item within the collection whould be
305      * of the same class --- or at least share a common superclass).
306      *
307      * @param field the field that contains the collection
308      */
309     void setTableView(FieldItem field);
310
311     /**
312      * Sets the render of a collection to be rendered by a choice and an
313      * embedded view on the selected object.
314      *
315      * @param collection the collection
316      * @param external tell if the object is embedded in the current view or if is is opened in an external panel (given by {@link GuiConf#addReferenceToPane(String,MemberItem,String)}
317      */
318     void setChoiceView(CollectionItem collection, boolean external);
319
320     /**
321      * Tells the GUI wether to show row numbers for tables and lists.
322      * @param collection the affected collection
323      * @param value wether to show row numbers
324      *
325      * @see #setDefaultShowRowNumbers(boolean)
326      */
327     void showRowNumbers(CollectionItem collection, boolean value);
328
329     /**
330      * Tells the GUI wether to show row numbers for tables and lists by
331      * default.
332      *
333      * @param value wether to show row numbers
334      *
335      * @see #showRowNumbers(CollectionItem,boolean)
336      */
337     void setDefaultShowRowNumbers(boolean value);
338
339     /**
340      * Sets a default sorted column for a collection.
341      *
342      * <p>By default, collections are not sorted. You can precise a
343      * column to use to sort the collection by default. It will be used
344      * at the construction of the collection.</p>
345      *
346      * @param collection the collection
347      * @param column the column used to sort (it is a fieldItem, watch
348      * out for case). You may preprend a '-' to use the reverse order
349      * of that column.
350      */
351     void setDefaultSortedColumn(CollectionItem collection, String column);
352
353     /**
354      * Sets the default order in which the attributes of the elements
355      * of a collection are to be rendered.
356      *
357      * @param collection the collection
358      * @param targetClass the class of attributes to render
359      * @param memberNames the name of the members in the
360      * rendering order
361      *
362      * @see #setMembersOrder(CollectionItem,String,ClassItem,String[])
363      * @see ClassAppearenceGuiConf#setTableMembersOrder(ClassItem,String[])
364      * @see ClassAppearenceGuiConf#setAttributesOrder(ClassItem,String[]) */
365     void setMembersOrder(
366         CollectionItem collection,
367         ClassItem targetClass,
368         String[] memberNames);
369
370     /**
371      * Sets the order in which the attributes of the elements of a
372      * collection are to be rendered for a given view.
373      *
374      * @param collection the collection
375      * @param viewName the type for which to set the members order
376      * @param targetClass the class of attributes to render
377      * @param memberNames the name of the members in the
378      * rendering order
379      *
380      * @see #setMembersOrder(CollectionItem,ClassItem,String[]) */
381     void setMembersOrder(
382         CollectionItem collection,
383         String viewName,
384         ClassItem targetClass,
385         String[] memberNames);
386
387     /**
388      * This configuration method allows the programmer to make a set of
389      * object to be proposed to the final user when an edition of this
390      * field value is performed.
391      *
392      * <p>Most of the GUI will propose the choice within a ComboBox.
393      *
394      * <p>When the choices values can not be defined at programming
395      * time but must be dynamically created, then the programmer can
396      * use the <code>setDynamicFieldChoice</code> method.
397      *
398      * @param field the field
399      * @param choice the values the user will have to choose from when
400      * a edition of the field is performed
401      *
402      * @see #setDynamicFieldChoice(FieldItem,Boolean,ClassItem,String)
403      * @see #setFieldChoice(FieldItem,Boolean,String[])
404      * @see #setFieldEnum(FieldItem,String)
405      * @see GuiConf#defineEnum(String,String[],int,int)
406      */
407     void setFieldChoice(FieldItem field, Boolean editable, String[] choice);
408
409     /**
410      * <p>Declare a field as an enumeration.</p>
411      *
412      * @param field the field
413      * @param enum the name of the enumeration
414      *
415      * @see GuiConf#defineEnum(String,String[],int,int)
416      * @see #setFieldChoice(FieldItem,Boolean,String[])
417      * @see #setDynamicFieldChoice(FieldItem,Boolean,ClassItem,String)
418      */
419     void setFieldEnum(FieldItem field, String enum);
420
421     /**
422      * Same as <code>setFieldChoice</code> but with dynamically
423      * defined values.
424      *
425      * <p>The values are dynamically defined at runtime by the
426      * invocation of a target method. This target method must return a
427      * collection of objects or an array of objects that contains the
428      * possible new values for the fields.</p>
429      *
430      * <p>If the target method is static, it will be called with the
431      * object as the only parameter. If it's not static, it will called
432      * <em>on</em> the object with no parameters.</p>
433      *
434      * @param field the field
435      * @param targetClass the class that contains the target method
436      * @param targetMethod name of a static method within the target
437      * class that returns the values to choose from. It must take an
438      * Object as parameter which will be the instance to which the
439      * field belongs to.
440      *
441      * @see #setDynamicFieldChoice(FieldItem,Boolean,MethodItem)
442      * @see ClassAppearenceGuiConf#setDynamicClassChoice(String,MethodItem)
443      */
444     void setDynamicFieldChoice(
445         FieldItem field,
446         Boolean editable,
447         ClassItem targetClass,
448         String targetMethod);
449
450     /**
451      * Same as <code>setFieldChoice</code> but with dynamically
452      * defined values.
453      *
454      * @param field the field
455      * @param targetMethod a static method that returns the values to
456      * choose from. It must take an Object as parameter which will be
457      * the instance to which the field belongs to.
458      *
459      * @see #setDynamicFieldChoice(FieldItem,Boolean,ClassItem,String)
460      * @see ClassAppearenceGuiConf#setDynamicClassChoice(String,MethodItem)
461      */
462     void setDynamicFieldChoice(
463         FieldItem field,
464         Boolean editable,
465         MethodItem targetMethod);
466
467     /**
468      * Use objects from a collection as the available choices to edit
469      * a reference field.
470      *
471      * @param field the edited reference field
472      * @param targetCollection the collection. It belong to same class
473      * as the field.
474      */
475     void setDynamicFieldChoice(
476         FieldItem field,
477         CollectionItem targetCollection);
478
479     /**
480      * Set the type of the objects of a collection.
481      *
482      * <p>If this method is not used, the collection type can be
483      * dynamically found out by the GUI from the adder's argument
484      * types.
485      *
486      * @param collection the collection within this class
487      * @param type the type of this collection (an exiting class name)
488      */
489     void setCollectionType(CollectionItem collection, String type);
490
491     /**
492      * Tells the preferred height a table or list view of a collection
493      * should take, if possible.
494      *
495      * @param collection the collection
496      * @param height the preferred height
497      *
498      * @see #setPreferredWidth(CollectionItem,Length)
499      */
500     void setPreferredHeight(CollectionItem collection, Length height);
501
502     /**
503      * Tells the preferred width a table or list view of a collection
504      * should take, if possible.
505      *
506      * @param collection the collection
507      * @param width the preferred width
508      *
509      * @see #setPreferredHeight(CollectionItem,Length)
510      */
511     void setPreferredWidth(CollectionItem collection, Length width);
512
513     /**
514      * Sets the number of rows to display simultaneously for a
515      * collection.
516      *
517      * <p>This is only used by the web GUI so that generated
518      * web pages are not too big. If the number of elements in the
519      * collection is bigger than numRows, a "previous" and a "next"
520      * button are displayed so that the user can see the rest of the
521      * collection. The default is 10. Use 0 to display all rows.</p>
522      *
523      * @param collection the collection
524      * @param numRows the number of rows per page
525      *
526      * @see #setAvailableNumRowsPerPage(CollectionItem,int[])
527      */
528     void setNumRowsPerPage(CollectionItem collection, int numRows);
529
530     /**
531      * Causes the view of a collection to let the user selects the
532      * number of rows to display simultaneously at runtime.
533      *
534      * @param collection the collection
535      * @param numRows the numbers of rows per page the user can choose from.
536      *
537      * @see #setNumRowsPerPage(CollectionItem,int)
538      */
539     void setAvailableNumRowsPerPage(CollectionItem collection, int[] numRows);
540
541     /**
542      * Enables the user to filter a table by retaining only rows whose
543      * columns have a given value. This feature is only available on
544      * the web GUI for the moment.
545      * @param collection the collection to configure
546      * @param columnNames the field names (from the collection's
547      * component type) that can be filtered
548      */
549     void showColumnFilters(CollectionItem collection,
550                            String[] columnNames);
551     /**
552      * Sets the view of a given setter's calling box to be a file
553      * chooser.<p>
554      *
555      * As logically expected, the type of the set field must be a
556      * String or an URL.<p>
557      *
558      * @param method the method item. It can be of the form
559      * "methodName" or "methodName(<types>)". The first syntax will use
560      * the method with that name. The second syntax allow you to
561      * specify parameter types (separated by commas, with no spaces).
562      * @param fileExtensions allowed file extensions to choose from
563      * @param fileDescription
564      *
565      * @see java.net.URL
566      * @see GuiAC#isFileChooserView(MethodItem)
567      */
568     void setFileChooserView(
569         MethodItem method,
570         String[] fileExtensions,
571         String fileDescription);
572
573     /**
574      * Add some allowed file extensions for File field.
575      *
576      * @param field the field
577      * @param fileExtensions a list of allowed file extensions to
578      * choose from (for instance {"html","xhtml"})
579      * @param fileDescription a description for those file extensions
580      * (for instance "HTML documents")
581      */
582     /*
583     void addAllowedFileExtensions(
584         FieldItem field,
585         String[] fileExtensions,
586         String fileDescription);
587     */
588
589     /**
590      * This configuration method attaches an icon to a given field so
591      * that the iconized instances of this field will be represented by
592      * this icon (for instance in a treeview).
593      *
594      * @param member the member (field or method)
595      * @param name the icon's resource name
596      */
597     void setIcon(MemberItem member, String name);
598
599     /**
600      * This configuration method allows not to use a node to represent
601      * a given relation (collection) in a treeview, even if the show
602      * relations mode is on .
603      *
604      * @param field the field
605      */
606     void hideTreeRelation(FieldItem field);
607
608     /**
609      * Set the default value for a choice.
610      *
611      * <p>The default value is dynamically calculated by the
612      * <code>method</code> parameter from the string value (result can
613      * be an object). A default implementation for method is provided
614      * by <code>GuiAC</code>.
615      *
616      * @param field the field
617      * @param method a static method that returns the default value
618      * (prototype: Object m(FieldItem,String))
619      * @param value the string representation of the default value
620      * @see GuiAC#getDefaultValue(FieldItem,String) */
621     void setDefaultValue(FieldItem field, MethodItem method, String value);
622
623     /**
624      * Set the default value for a choice.
625      *
626      * <p>Same as setDefaultValue(ClassItem, String, MethodItem, String)
627      * using default MethodItem <code>GuiAC.getDefaultValue</code>.
628      *
629      * @param field the field
630      * @param value the string representation of the default value
631      * @see GuiAC#getDefaultValue(FieldItem,String)
632      * @see #setDefaultValue(FieldItem,MethodItem,String)
633      */
634     void setDefaultValue(FieldItem field, String value);
635
636     /**
637      * Sets the display format of a float or double field.
638      *
639      * @param field the field
640      * @param format the display format of the field
641      *
642      * @see java.text.DecimalFormat
643      */
644     void setFloatFormat(FieldItem field, String format);
645
646     /**
647      * Sets the description of a class member (field of method).
648      *
649      * @param member the member
650      * @param description the description of the class member
651      */
652     void setDescription(MemberItem member, String description);
653
654     /**
655      * Sets the label of a class member (field of method).
656      *
657      * @param member the member
658      * @param label the label of the class member
659      * @see #setLabel(MemberItem,MemberItem,String)
660      */
661     void setLabel(MemberItem member, String label);
662
663     /**
664      * Sets the label of a class member (field of method) for a given
665      * context
666      *
667      * @param member the member
668      * @param selector use the label when inside the view of his member item
669      * @param label the label of the class member
670      * @see #setLabel(MemberItem,String)
671      */
672     void setLabel(MemberItem member, MemberItem selector, String label);
673
674     /**
675      * Wether to display a label containing the name of the field in views.
676      *
677      * @param member the member
678      * @param value boolean indicating wether to display the label
679      */
680     void setDisplayLabel(MemberItem member, boolean value);
681
682     /**
683      * Set the style of a field
684      *
685      * @param field the field
686      * @param style the CSS style
687      *
688      * @see ClassAppearenceGuiConf#setStyle(ClassItem,String)
689      * @see GuiConf#addStyleSheetURL(String)
690      * @see GuiConf#addStyleSheetURL(String,String)
691      */
692     void setStyle(FieldItem field, String style);
693
694     /**
695      * Tells wether to show an add button for a collection
696      *
697      * @param collection the collection to configure
698      * @param addable wether to show a button or not
699      *
700      * @see #setRemovable(CollectionItem,boolean)
701      */
702     void setAddable(CollectionItem collection, boolean addable);
703
704     /**
705      * Tells wether to show remove buttons for items of a collection
706      *
707      * @param collection the collection to configure
708      * @param removable wether to show buttons or not
709      *
710      * @see #setAddable(CollectionItem,boolean)
711      */
712     void setRemovable(CollectionItem collection, boolean removable);
713
714     /**
715      * Sets the view type of a field instead of using the default
716      * one ("List" or "Table"). It allows you to define a custom view
717      * constructor for that type in order to handle complex tables.
718      * The view constructor must take 3 arguments: a CollectionItem, an
719      * Object (the susbtance), and a CollectionItemView)
720      */
721     void setViewType(FieldItem field, String viewName, String viewType);
722
723     /**
724      * Tells wether items in the default view of a collection have a
725      * "view" button to open a view of the item.
726      *
727      * @param collection the collection
728      * @param viewable wether items are viewable
729      *
730      * @see #setViewableItems(CollectionItem,String,boolean)
731      */
732     void setViewableItems(CollectionItem collection, boolean viewable);
733
734     /**
735      * Tells wether items in a given default view of a collection have
736      * a "view" button to open a view of the item.
737      *
738      * @param collection the collection
739      * @param viewName the view to configure
740      * @param viewable wether items have a view button
741      *
742      * @see #setViewableItems(CollectionItem,boolean)
743      */
744     void setViewableItems(CollectionItem collection, String viewName, boolean viewable);
745     
746     /**
747      * Enables or disables links for references in cells of a table
748      */
749     void setEnableLinks(CollectionItem collection, String viewName, boolean enable);
750
751     /**
752      * Groups cells of table.
753      *
754      * @param collection the collection whose table cells to group
755      * @param viewName the view to configure
756      * @param groupBy group adjacent cells with same values of columns
757      * whose field start with this field
758      *
759      * @see #setMultiLineCollection(CollectionItem,String,CollectionItem)
760      */
761     void groupBy(CollectionItem collection,
762                  String viewName,
763                  FieldItem groupBy);
764
765     /**
766      * Creates subrows in some cells of a table.
767      *
768      * @param collection the collection whose table cells to subdivide
769      * @param viewName the view to configure
770      * @param multiLine subdivide cells of columns whose field start
771      * with this field
772      *
773      * @see #groupBy(CollectionItem,String,FieldItem)
774      */
775     void setMultiLineCollection(CollectionItem collection,
776                                 String viewName,
777                                 CollectionItem multiLine);
778
779     /**
780      * Use a field as a row to be added at the end of a table
781      */
782     void setAdditionalRow(CollectionItem collection,String viewName,
783                           String row);
784
785     /**
786      * Sets the view type to use for cells of a column of table,
787      * instead of the default one.
788      *
789      * @param collection the collection to configure
790      * @param viewName the view to configure
791      * @param column the column to configure
792      * @param viewType the view type to use for that column
793      *
794      * @see GuiConf#setViewConstructor(String,String,AbstractMethodItem)
795      */
796     void setCellViewType(CollectionItem collection, String viewName,
797                          FieldItem column, String viewType);
798
799     /**
800      * Defines preferred mnemonics for field of method.
801      * @param method
802      * @param mnemonics the mnemonics
803      */
804     void setMnemonics(MemberItem method, String mnemonics);
805 }
806
Popular Tags