001: /*
002: ItsNat Java Web Application Framework
003: Copyright (C) 2007 Innowhere Software Services S.L., Spanish Company
004: Author: Jose Maria Arranz Santamaria
005:
006: This program is free software: you can redistribute it and/or modify
007: it under the terms of the GNU Affero General Public License as published by
008: the Free Software Foundation, either version 3 of the License, or
009: (at your option) any later version. See the GNU Affero General Public
010: License for more details. See the copy of the GNU Affero General Public License
011: included in this program. If not, see <http://www.gnu.org/licenses/>.
012: */
013:
014: package org.itsnat.impl.comp;
015:
016: import org.itsnat.comp.ItsNatTableCellEditor;
017: import org.itsnat.comp.ItsNatTableCellRenderer;
018: import org.itsnat.comp.ItsNatTableHeader;
019: import org.itsnat.comp.ui.ItsNatTableHeaderUI;
020: import org.itsnat.comp.ui.ItsNatTableUI;
021: import javax.swing.DefaultListSelectionModel;
022: import javax.swing.ListSelectionModel;
023: import javax.swing.event.TableModelEvent;
024: import javax.swing.event.TableModelListener;
025: import javax.swing.table.DefaultTableModel;
026: import javax.swing.table.TableModel;
027: import org.itsnat.comp.ItsNatTable;
028: import org.itsnat.comp.ItsNatTableStructure;
029: import org.itsnat.comp.ui.ItsNatTableCellUI;
030: import org.itsnat.comp.ui.ItsNatTableHeaderCellUI;
031: import org.itsnat.core.event.ParamTransport;
032: import org.itsnat.core.NameValue;
033: import org.w3c.dom.Element;
034: import org.w3c.dom.Node;
035: import org.w3c.dom.events.Event;
036: import org.w3c.dom.events.MouseEvent;
037:
038: /**
039: *
040: * @author jmarranz
041: */
042: public abstract class ItsNatTableImpl extends
043: ItsNatElementComponentImpl implements ItsNatTable,
044: TableModelListener {
045: protected ItsNatTableHeaderImpl header;
046: protected ItsNatTableCellRenderer renderer;
047: protected ListSelectionModelMgrImpl rowSelModelMgr;
048: protected ListSelectionModelMgrImpl columnSelModelMgr;
049: protected boolean rowSelectionAllowed = true; // Por defecto
050: protected boolean columnSelectionAllowed = false; // Por defecto
051: protected TableCellEditorProcessor editorProcessor = new TableCellEditorProcessor(
052: this );
053:
054: /**
055: * Creates a new instance of ItsNatTableImpl
056: */
057: public ItsNatTableImpl(Element element,
058: ItsNatTableStructure structure, NameValue[] artifacts,
059: ItsNatComponentManagerImpl componentMgr) {
060: super (element, artifacts, componentMgr);
061:
062: this .structure = structure; // si es null se creará más tarde la estructura por defecto
063:
064: setItsNatTableCellRenderer(componentMgr
065: .createDefaultItsNatTableCellRenderer());
066: setItsNatTableCellEditor(componentMgr
067: .createDefaultItsNatTableCellEditor(null));
068: }
069:
070: public void setDefaultStructure() {
071: super .setDefaultStructure();
072:
073: ItsNatTableStructure structure = getItsNatTableStructure();
074:
075: Element tableElem = getElement();
076: Element headerElem = structure.getHeadElement(this , tableElem);
077:
078: if (headerElem != null) {
079: // Es neceario crear antes de que se cree el UI, DataModel etc y cuando ya tenemos la estructura
080: this .header = createItsNatTableHeader(headerElem);
081: header.setDefaultStructure();
082: }
083: }
084:
085: public void setDefaultItsNatComponentUI() {
086: super .setDefaultItsNatComponentUI();
087:
088: if (header != null) // Si tiene header el objeto ya fue creado
089: header.setDefaultItsNatComponentUI();
090: }
091:
092: public void setDefaultDataModel() {
093: super .setDefaultDataModel();
094:
095: if (header != null) // Si tiene header el objeto ya fue creado
096: header.setDefaultDataModel(); // El header no tiene modelo pero por si acaso
097: }
098:
099: public void setDefaultModels() {
100: super .setDefaultModels();
101:
102: // Después de la iniciación del data model
103: if (header != null)
104: header.setDefaultListSelectionModel();
105:
106: setRowSelectionModel(new DefaultListSelectionModel());
107: setColumnSelectionModel(new DefaultListSelectionModel());
108: }
109:
110: public void unbindModels() {
111: if (header != null)
112: header.unsetListSelectionModel();
113:
114: unsetRowListSelectionModel();
115: unsetColumnListSelectionModel();
116:
117: super .unbindModels();
118: }
119:
120: public TableCellEditorProcessor getTableCellEditorProcessor() {
121: return editorProcessor;
122: }
123:
124: public void enableEventListeners() {
125: enableEventListener("click");
126: }
127:
128: public abstract ItsNatTableHeaderImpl createItsNatTableHeader(
129: Element headerElem);
130:
131: public ItsNatTableHeader getItsNatTableHeader() {
132: return header;
133: }
134:
135: public ItsNatTableUI getItsNatTableUI() {
136: return (ItsNatTableUI) compUI;
137: }
138:
139: public Object createDefaultModelInternal() {
140: return createDefaultTableModel();
141: }
142:
143: public TableModel createDefaultTableModel() {
144: return new DefaultTableModel();
145: }
146:
147: public void bindDataModel() {
148: // A partir de ahora los cambios los repercutimos en el DOM por eventos
149: // No se debe cambiar el DOM por otra vía que por el objeto dataModel
150: TableModel dataModel = (TableModel) getDataModel();
151: dataModel.addTableModelListener(this );
152: }
153:
154: public void unbindDataModel() {
155: TableModel dataModel = (TableModel) getDataModel();
156: dataModel.removeTableModelListener(this );
157: }
158:
159: public void syncWithDataModel() {
160: super .syncWithDataModel();
161:
162: TableModel dataModel = getTableModel();
163: int columns = dataModel.getColumnCount();
164: int rows = dataModel.getRowCount();
165:
166: updateSelectionModelAddedRemoved(columns, columnSelModelMgr);
167: updateSelectionModelAddedRemoved(rows, rowSelModelMgr);
168: }
169:
170: public void insertDOMRow(int row, Object[] values) {
171: ItsNatTableUI compUI = getItsNatTableUI();
172: compUI.insertRowAt(row, values);
173:
174: rowSelModelMgr.insertElementUpdateModel(row);
175: }
176:
177: public void removeDOMRow(int row) {
178: rowSelModelMgr.removeRangeUpdateModel(row, row);
179:
180: ItsNatTableUI compUI = getItsNatTableUI();
181: compUI.removeRowAt(row);
182: }
183:
184: public void insertDOMColumn(int column, Object[] columData) {
185: ItsNatTableUI compUI = getItsNatTableUI();
186: TableModel dataModel = getTableModel();
187: compUI.insertColumnAt(column, columData);
188:
189: ItsNatTableHeader header = getItsNatTableHeader();
190: if (header != null)
191: header.getItsNatTableHeaderUI().insertElementAt(column,
192: dataModel.getColumnName(column));
193:
194: columnSelModelMgr.insertElementUpdateModel(column);
195: }
196:
197: public void removeDOMColumn(int column) {
198: columnSelModelMgr.removeRangeUpdateModel(column, column);
199:
200: ItsNatTableUI compUI = getItsNatTableUI();
201: compUI.removeColumnAt(column);
202:
203: ItsNatTableHeader header = getItsNatTableHeader();
204: if (header != null)
205: header.getItsNatTableHeaderUI().removeElementAt(column);
206: }
207:
208: public void removeAllDOMRows() {
209: if (rowSelModelMgr != null)
210: rowSelModelMgr.removeAllUpdateModel();
211:
212: ItsNatTableUI compUI = getItsNatTableUI();
213: compUI.removeAllRows();
214: }
215:
216: public void removeAllDOMColumns() {
217: if (columnSelModelMgr != null)
218: columnSelModelMgr.removeAllUpdateModel();
219:
220: ItsNatTableUI compUI = getItsNatTableUI();
221: compUI.removeAllColumns();
222:
223: ItsNatTableHeader header = getItsNatTableHeader();
224: if (header != null)
225: header.getItsNatTableHeaderUI().removeAllElements();
226: }
227:
228: public void updateDOMRowValues(int row, Object[] rowValues) {
229: ItsNatTableUI compUI = getItsNatTableUI();
230: boolean[] selected = getRowSelectionList(row, getTableModel()
231: .getColumnCount());
232: boolean[] hasFocus = new boolean[selected.length];
233: compUI.setRowValuesAt(row, rowValues, selected, hasFocus);
234: }
235:
236: public void setDOMRowCount(int rows) {
237: ItsNatTableUI compUI = getItsNatTableUI();
238: compUI.setRowCount(rows);
239:
240: updateSelectionModelAddedRemoved(rows, rowSelModelMgr);
241: }
242:
243: public void updateSelectionModelAddedRemoved(int size,
244: ListSelectionModelMgrImpl selModelMgr) {
245: if (selModelMgr != null) {
246: selModelMgr.setSize(size);
247: }
248: }
249:
250: public void tableChanged(TableModelEvent e) {
251: // Sincronizamos con el modelo padre
252: TableModel dataModel = (TableModel) e.getSource();
253: int firstRow = e.getFirstRow();
254: int lastRow = e.getLastRow();
255: int column = e.getColumn();
256: int type = e.getType();
257:
258: if (column == TableModelEvent.ALL_COLUMNS) {
259: if (firstRow == TableModelEvent.HEADER_ROW) {
260: // Ha cambiado la estructura de la tabla totalmente
261: syncWithDataModel();
262: return;
263: } else if (lastRow == Integer.MAX_VALUE) // Han cambiado todas las filas (en número y contenido), rehacemos las filas
264: {
265: syncRowsWithDataModel(dataModel);
266: return;
267: }
268: }
269:
270: switch (type) {
271: case TableModelEvent.INSERT:
272: if (column == TableModelEvent.ALL_COLUMNS) // nuevas filas insertadas
273: {
274: int colCount = dataModel.getColumnCount();
275: for (int i = firstRow; i <= lastRow; i++) {
276: Object[] rowValues = getRowValues(i, colCount);
277: insertDOMRow(i, rowValues);
278: }
279: } else // Se ha insertado una columna concreta
280: {
281: Object[] colValues = getColumnValues(column);
282: insertDOMColumn(column, colValues);
283: }
284: break;
285: case TableModelEvent.UPDATE:
286: if (column == TableModelEvent.ALL_COLUMNS) // Caso de movimiento de filas
287: {
288: int colCount = dataModel.getColumnCount();
289: for (int i = firstRow; i <= lastRow; i++) {
290: Object[] rowValues = getRowValues(i, colCount);
291: updateDOMRowValues(i, rowValues);
292: }
293: } else // Caso de actualización de una columna concreta (una o varias filas)
294: {
295: // En teoría con DefaultTableModel no se puede cambiar el nombre de una columna (el nombre se define al insertar la columna únicamente)
296: //Object[] colValues = getColumnValues(column);
297: //updateDOMColumnValues(column,colValues);
298:
299: ItsNatTableUI compUI = getItsNatTableUI();
300: for (int row = firstRow; row <= lastRow; row++) {
301: Object obj = dataModel.getValueAt(row, column);
302: boolean isSelected = isCellSelected(row, column);
303: compUI.setCellValueAt(row, column, obj, isSelected,
304: false);
305: }
306: }
307: break;
308: case TableModelEvent.DELETE:
309: if (column == TableModelEvent.ALL_COLUMNS) // Caso de eliminación de varias filas
310: {
311: for (int i = firstRow; i <= lastRow; i++)
312: removeDOMRow(firstRow); // NO usar i pues al borrar se desplazan las siguientes
313: } else // Caso de eliminación de una columna concreta
314: {
315: removeDOMColumn(column);
316: }
317: break;
318: }
319: }
320:
321: public void syncUIWithDataModel() {
322: // El sistema de eventos usado por DefaultTableModel ante cambios
323: // es muy pobre, da poca información, por ejemplo, ante la adición
324: // de una columna se envía un evento indicando que TODO ha cambiado
325: // En vez de destruir todas las columnas y añadir de nuevo cuando apenas
326: // una habrá cambiado, lo hacemos más inteligente, hay que tener en cuenta
327: // que la eliminación/adición de nodos es un proceso lento.
328: TableModel dataModel = getTableModel();
329:
330: ItsNatTableUI compUI = getItsNatTableUI();
331: int columns = dataModel.getColumnCount();
332: compUI.setColumnCount(columns);
333:
334: ItsNatTableHeader header = getItsNatTableHeader();
335: if (header != null)
336: header.getItsNatTableHeaderUI().setLength(columns);
337:
338: int rows = dataModel.getRowCount();
339: compUI.setRowCount(rows);
340:
341: copyHeaderValuesFromDataModelToUI(dataModel);
342: copyRowValuesFromDataModelToUI(dataModel);
343: }
344:
345: public void syncRowsWithDataModel(TableModel dataModel) {
346: // Leer notas de syncWithDataModel
347: // Suponemos que el número de columnas no ha cambiado
348: // pero el número de filas y contenido sí
349:
350: int rows = dataModel.getRowCount();
351: ItsNatTableUI compUI = getItsNatTableUI();
352: compUI.setRowCount(rows);
353:
354: copyRowValuesFromDataModelToUI(dataModel);
355:
356: updateSelectionModelAddedRemoved(rows, rowSelModelMgr);
357: }
358:
359: public void copyHeaderValuesFromDataModelToUI(TableModel dataModel) {
360: ItsNatTableHeader header = getItsNatTableHeader();
361: if (header != null) {
362: ItsNatTableHeaderUI compUI = header
363: .getItsNatTableHeaderUI();
364: int columns = dataModel.getColumnCount();
365: for (int i = 0; i < columns; i++) {
366: String columnName = dataModel.getColumnName(i);
367: compUI.setElementValueAt(i, columnName, false, false);
368: }
369: }
370: }
371:
372: public void copyRowValuesFromDataModelToUI(TableModel dataModel) {
373: ItsNatTableUI compUI = getItsNatTableUI();
374:
375: int rows = dataModel.getRowCount();
376: int columns = dataModel.getColumnCount();
377:
378: for (int i = 0; i < rows; i++) {
379: for (int j = 0; j < columns; j++) {
380: Object obj = dataModel.getValueAt(i, j);
381: boolean isSelected = isCellSelected(i, j);
382: compUI.setCellValueAt(i, j, obj, isSelected, false);
383: }
384: }
385: }
386:
387: public TableModel getTableModel() {
388: return (TableModel) dataModel;
389: }
390:
391: public void setTableModel(TableModel dataModel) {
392: setDataModel(dataModel);
393: }
394:
395: public ListSelectionModelMgrImpl getRowSelectionModelMgr() {
396: return rowSelModelMgr;
397: }
398:
399: public ListSelectionModel getRowSelectionModel() {
400: if (rowSelModelMgr == null)
401: return null;
402: return rowSelModelMgr.getListSelectionModel();
403: }
404:
405: public void unsetRowListSelectionModel() {
406: if (rowSelModelMgr != null)
407: rowSelModelMgr.dispose();
408: // No anulamos el selModelMgr para que se pueda recuperar el ListSelectionModel después de un dispose
409: }
410:
411: public void setRowSelectionModel(
412: ListSelectionModel rowSelectionModel) {
413: unsetRowListSelectionModel();
414:
415: int size = getTableModel().getRowCount();
416:
417: this .rowSelModelMgr = ListSelectionModelMgrImpl
418: .newListSelectionModelMgr(rowSelectionModel, size);
419:
420: // No hay listener del componente
421: }
422:
423: public ListSelectionModelMgrImpl getColumnSelectionModelMgr() {
424: return columnSelModelMgr;
425: }
426:
427: public ListSelectionModel getColumnSelectionModel() {
428: if (columnSelModelMgr == null)
429: return null;
430: return columnSelModelMgr.getListSelectionModel();
431: }
432:
433: public void unsetColumnListSelectionModel() {
434: if (columnSelModelMgr != null)
435: columnSelModelMgr.dispose();
436: // No anulamos el selModelMgr para que se pueda recuperar el ListSelectionModel después de un dispose
437: }
438:
439: public void setColumnSelectionModel(
440: ListSelectionModel columnSelectionModel) {
441: unsetColumnListSelectionModel();
442:
443: int size = getTableModel().getColumnCount();
444:
445: this .columnSelModelMgr = ListSelectionModelMgrImpl
446: .newListSelectionModelMgr(columnSelectionModel, size);
447:
448: // No hay listener del componente
449: }
450:
451: public void processDOMEvent(Event evt) {
452: String type = evt.getType();
453: if (type.equals("click") || type.equals("mouseup")) {
454: Node nodeClicked = (Node) evt.getTarget(); // Puede ser un nodo interior del elemento pulsado
455: MouseEvent mouseEvt = (MouseEvent) evt;
456: boolean toggle = mouseEvt.getCtrlKey();
457: boolean extend = mouseEvt.getShiftKey();
458:
459: ItsNatTableHeaderCellUI headerCellInfo = null;
460: if (header != null) {
461: // Vemos si ha sido pulsada la cabecera
462: headerCellInfo = header.processEvent(nodeClicked,
463: toggle, extend);
464: if ((headerCellInfo != null)
465: && (isRowSelectionAllowed() || isColumnSelectionAllowed())) {
466: // Además seleccionamos la columna de la tabla
467: int column = headerCellInfo.getIndex();
468: changeColumnSelection(column, toggle, extend);
469: }
470: }
471:
472: if ((headerCellInfo == null)
473: && (isRowSelectionAllowed() || isColumnSelectionAllowed())) {
474: // Ha sido seguramente pulsado el cuerpo de la tabla
475: ItsNatTableUI bodyUI = getItsNatTableUI();
476: ItsNatTableCellUI cellInfo = bodyUI
477: .getItsNatTableCellUIFromNode(nodeClicked);
478: if (cellInfo != null) {
479: int row = cellInfo.getRowIndex();
480: int column = cellInfo.getColumnIndex();
481: changeSelection(row, column, toggle, extend);
482: }
483: }
484: }
485:
486: super .processDOMEvent(evt);
487: }
488:
489: public void changeSelection(int rowIndex, int columnIndex,
490: boolean toggle, boolean extend) {
491: // Idem JTable y segun http://developer.classpath.org/doc/javax/swing/JTable-source.html#line.4945
492: boolean selected = isCellSelected(rowIndex, columnIndex);
493:
494: columnSelModelMgr.changeSelectionModel(columnIndex, toggle,
495: extend, selected);
496: rowSelModelMgr.changeSelectionModel(rowIndex, toggle, extend,
497: selected);
498: }
499:
500: public void changeColumnSelection(int columnIndex, boolean toggle,
501: boolean extend) {
502: ListSelectionModel csm = getColumnSelectionModel();
503:
504: boolean selected = csm.isSelectedIndex(columnIndex);
505:
506: columnSelModelMgr.changeSelectionModel(columnIndex, toggle,
507: extend, selected);
508: }
509:
510: public void clearSelection() {
511: getRowSelectionModel().clearSelection();
512: getColumnSelectionModel().clearSelection();
513: }
514:
515: public void setSelectionMode(int selectionMode) {
516: clearSelection();
517: getRowSelectionModel().setSelectionMode(selectionMode);
518: getColumnSelectionModel().setSelectionMode(selectionMode);
519: }
520:
521: public boolean isRowSelectionAllowed() {
522: return rowSelectionAllowed;
523: }
524:
525: public void setRowSelectionAllowed(boolean rowSelectionAllowed) {
526: this .rowSelectionAllowed = rowSelectionAllowed;
527: }
528:
529: public boolean isColumnSelectionAllowed() {
530: return columnSelectionAllowed;
531: }
532:
533: public void setColumnSelectionAllowed(boolean columnSelectionAllowed) {
534: this .columnSelectionAllowed = columnSelectionAllowed;
535: }
536:
537: public boolean isCellSelectionEnabled() {
538: return isRowSelectionAllowed() && isColumnSelectionAllowed();
539: }
540:
541: public void setCellSelectionEnabled(boolean cellSelectionEnabled) {
542: setRowSelectionAllowed(cellSelectionEnabled);
543: setColumnSelectionAllowed(cellSelectionEnabled);
544: }
545:
546: public boolean isRowSelected(int row) {
547: return getRowSelectionModel().isSelectedIndex(row);
548: }
549:
550: public boolean isColumnSelected(int column) {
551: return getColumnSelectionModel().isSelectedIndex(column);
552: }
553:
554: public boolean isCellSelected(int row, int column) {
555: /* Casuística:
556: * Filas y columnas NO seleccionables: no celda seleccionada
557: * Fila O columna seleccionables (no las dos): celda seleccionada si está en una fila o columna seleccionada
558: * Fila Y columna seleccionables: celda seleccionada SOLO si la celda está en una fila Y columna seleccionadas (ambas),
559: * en este caso se trata de evitar que al seleccionar una celda seleccione la fila y la columna enteras (formando una cruz)
560: * este caso sirve para seleccionar celdas individuales.
561: */
562: if (!isRowSelectionAllowed() && !isColumnSelectionAllowed())
563: return false;
564:
565: return ((!isRowSelectionAllowed() || isRowSelected(row)) && (!isColumnSelectionAllowed() || isColumnSelected(column)));
566: }
567:
568: public void setRowSelectionInterval(int index0, int index1) {
569: getRowSelectionModel().setSelectionInterval(index0, index1);
570: }
571:
572: public void setColumnSelectionInterval(int index0, int index1) {
573: getColumnSelectionModel().setSelectionInterval(index0, index1);
574: }
575:
576: public int[] getSelectedRows() {
577: return rowSelModelMgr.getSelectedIndices();
578: }
579:
580: public void setSelectedRows(int[] indices) {
581: rowSelModelMgr.setSelectedIndices(indices);
582: }
583:
584: public int[] getSelectedColumns() {
585: return columnSelModelMgr.getSelectedIndices();
586: }
587:
588: public void setSelectedColumns(int[] indices) {
589: columnSelModelMgr.setSelectedIndices(indices);
590: }
591:
592: public int getSelectedColumn() {
593: return getColumnSelectionModel().getMinSelectionIndex();
594: }
595:
596: public int getSelectedRow() {
597: return getRowSelectionModel().getMinSelectionIndex();
598: }
599:
600: public void selectAll() {
601: int rows = getTableModel().getRowCount();
602: int columns = getTableModel().getColumnCount();
603: if ((rows > 0) && (columns > 0)) {
604: setRowSelectionInterval(0, rows - 1);
605: setColumnSelectionInterval(0, columns - 1);
606: }
607: }
608:
609: public Object[] getRowValues(int row, int colCount) {
610: TableModel dataModel = getTableModel();
611: Object[] rowValues = new Object[colCount];
612: for (int j = 0; j < colCount; j++) {
613: rowValues[j] = dataModel.getValueAt(row, j);
614: }
615: return rowValues;
616: }
617:
618: public Object[] getColumnValues(int column) {
619: TableModel dataModel = getTableModel();
620: int rowCount = dataModel.getRowCount();
621: Object[] colValues = new Object[rowCount];
622: for (int i = 0; i < rowCount; i++) {
623: colValues[i] = dataModel.getValueAt(i, column);
624: }
625: return colValues;
626: }
627:
628: public boolean[] getRowSelectionList(int row, int colCount) {
629: boolean[] rowSelList = new boolean[colCount];
630: for (int j = 0; j < colCount; j++) {
631: rowSelList[j] = isCellSelected(row, j);
632: }
633: return rowSelList;
634: }
635:
636: public boolean[] getColumnSelectionList(int column) {
637: TableModel dataModel = getTableModel();
638: int rowCount = dataModel.getRowCount();
639: boolean[] colSelList = new boolean[rowCount];
640: for (int i = 0; i < rowCount; i++) {
641: colSelList[i] = isCellSelected(i, column);
642: }
643: return colSelList;
644: }
645:
646: public ItsNatTableCellRenderer getItsNatTableCellRenderer() {
647: return renderer;
648: }
649:
650: public void setItsNatTableCellRenderer(
651: ItsNatTableCellRenderer renderer) {
652: this .renderer = renderer;
653: }
654:
655: public ItsNatTableCellEditor getItsNatTableCellEditor() {
656: TableCellEditorProcessor editorProcessor = getTableCellEditorProcessor();
657: return editorProcessor.getItsNatTableCellEditor();
658: }
659:
660: public void setItsNatTableCellEditor(
661: ItsNatTableCellEditor cellEditor) {
662: editorProcessor.setItsNatTableCellEditor(cellEditor);
663: }
664:
665: public void startEditingAt(int row, int column) {
666: getTableCellEditorProcessor().startEdition(row, column);
667: }
668:
669: public boolean isEditing() {
670: return getTableCellEditorProcessor().isEditing();
671: }
672:
673: public int getEditingRow() {
674: return getTableCellEditorProcessor().getRow();
675: }
676:
677: public int getEditingColumn() {
678: return getTableCellEditorProcessor().getColumn();
679: }
680:
681: public String getEditorActivatorEvent() {
682: return getTableCellEditorProcessor().getEditorActivatorEvent();
683: }
684:
685: public void setEditorActivatorEvent(String editorActivatorEvent) {
686: getTableCellEditorProcessor().setEditorActivatorEvent(
687: editorActivatorEvent);
688: }
689:
690: protected ParamTransport[] getParamTransports(String type) {
691: return null;
692: }
693:
694: public Class getStructureClass() {
695: return ItsNatTableStructure.class;
696: }
697:
698: public ItsNatTableStructure getItsNatTableStructure() {
699: return (ItsNatTableStructure) structure;
700: }
701:
702: public Object createDefaultStructure() {
703: return getItsNatComponentManager()
704: .createDefaultItsNatTableStructure();
705: }
706:
707: }
|