0001: package com.teamkonzept.field;
0002:
0003: import java.util.Properties;
0004: import java.util.StringTokenizer;
0005: import com.teamkonzept.lib.*;
0006: import com.teamkonzept.publishing.markups.*;
0007: import com.teamkonzept.web.*;
0008: import com.teamkonzept.field.db.*;
0009: import com.teamkonzept.international.LanguageManager;
0010: import org.w3c.dom.*;
0011:
0012: /**
0013: * The field table control.
0014: * <PRE>
0015: * Die Zellen einer Tabelle beinhalten jeweils das gleiche BaseField.
0016: * Dies gilt auch fuer die Zusatz-Zeile/Spalte.
0017: *
0018: * Folgende Moeglichkeiten bestehen:
0019: * 1. Anlegen von Tabellen variabler Groesse
0020: * 2. Anlegen von einer Zeile/Spalte, die Zusatzinformationen enthalten
0021: * 3. Auswahl der Inhalte (Fields) der Zellen
0022: * 4. Auswahl der Inhalte (Fields) der Zusatzz-Zeilen/Spalten
0023: * 5. Anzeigen der Tabelle
0024: * 6. Das modifizieren der Tabelle selbst
0025: * - Loeschen von Zeilen/Spalten
0026: * - Einfuegen von Zeilen/Spalten
0027: * - Vertauschen von Zeilen/Spalten
0028: * 7. Speichern aller Daten in die Datenbank
0029: * 8. Speichern aller Strukturinformationen in die Datenbank
0030: *
0031: * Um Verwechselungen zu vermeiden:
0032: *
0033: * --------------------------------
0034: * | Col-Zusatz-Vektor |
0035: * --------------------------------
0036: * ------
0037: * | Row- |
0038: * | zu- |
0039: * | satz | TABELLE
0040: * | vek- |
0041: * | tor |
0042: * | |
0043: * ------
0044: * </PRE>
0045: * @author $Author: uli $
0046: * @version $Revision: 1.27 $
0047: */
0048: public class TKFieldTable extends TKBaseField {
0049: // $Id: TKFieldTable.java,v 1.27 2002/02/27 11:07:04 uli Exp $
0050:
0051: /**
0052: * The class identifier.
0053: */
0054: public static final String CLASS_ID = "FIELDTABLE";
0055: public static final String TABLE_ENTRY_KEY = "TABLEENTRY";
0056: public static final String ROW_ENTRY_KEY = "ROWENTRY";
0057: public static final String COL_ENTRY_KEY = "COLENTRY";
0058:
0059: public static final String IS_ROWENTRY_KEY = "IS_ROWENTRY";
0060: public static final String IS_COLENTRY_KEY = "IS_COLENTRY";
0061: public static final String ROW_JANEIN_KEY = "JANEINZEILE";
0062: public static final String COL_JANEIN_KEY = "JANEINSPALTE";
0063:
0064: public static final String ZUSATZ_KEY = "ZUSATZ";
0065: public static final String CELLINFO_KEY = "CELL";
0066: public static final String NOCELLINFO_KEY = "NOCELL";
0067: public static final String BOOL_ZUSATZ_ROW = "BOOLZUSATZROW";
0068: public static final String BOOL_ZUSATZ_COL = "BOOLZUSATZCOL";
0069:
0070: public static final String PRE_COLS = "COL";
0071: public static final String PRE_ROWS = "ROW";
0072:
0073: public static final String MODIFY_ROW = "MODIFYROW";
0074:
0075: public boolean isRowCell; //true wenn Cell
0076: public boolean isColCell; //true wenn Cell
0077:
0078: TKBaseField tableEntry;
0079: TKBaseField rowEntry;
0080: TKBaseField colEntry;
0081:
0082: /**
0083: * Creates an empty field table control.
0084: */
0085: public TKFieldTable() {
0086: };
0087:
0088: public TKFieldTable(String name, TKBaseField tableEntry) {
0089: this (name, tableEntry, null, null);
0090: }
0091:
0092: public TKFieldTable(String name, TKBaseField tableEntry,
0093: TKBaseField rowEntry, TKBaseField colEntry) {
0094: this (name, tableEntry, rowEntry, colEntry, null);
0095: }
0096:
0097: public TKFieldTable(String name, TKBaseField tableEntry,
0098: TKBaseField rowEntry, TKBaseField colEntry, String showName) {
0099: initFieldTable(name, tableEntry, rowEntry, colEntry, showName);
0100: }
0101:
0102: /**
0103: * Die BaseFields werden uebergeben und den entsprechenden Objekten
0104: * der Klasse zugewiesen (aehnlich einem Konstruktor)
0105: *
0106: * @param TKBaseField tableEntry, Field-Object fuer die Zellen
0107: * @param TKBaseField rowEntry, Field-Object fuer den Zusatzvektor (Row)
0108: * @param TKBaseField tableEntry, Field-Object fuer den Zusatzvektor (Col)
0109: */
0110: public final void initFieldTable(String name,
0111: TKBaseField tableEntry, TKBaseField rowEntry,
0112: TKBaseField colEntry, String showName) {
0113: initBaseField(CLASS_ID, name, showName);
0114: this .tableEntry = tableEntry;
0115: this .rowEntry = rowEntry;
0116: this .colEntry = colEntry;
0117: }
0118:
0119: //*************************************************************************************
0120: /**
0121: * Die Daten der globalen Struktur werden uebergeben. Aus diesen Daten wird die
0122: * Fieldstruktur fuer die Tabelle aufgebaut
0123: * Das Field-Objekt fuer die Table wird aus der Registry geholt
0124: *
0125: * @param String fieldClass, die CLASS_ID
0126: * @param Object data, der Datahash
0127: */
0128: public void init(String fieldClass, Object data)
0129: throws TKUnregisteredClassException,
0130: ClassNotFoundException, InstantiationException,
0131: IllegalAccessException {
0132: super .init(fieldClass, data);
0133:
0134: TKHashtable tableData = (TKHashtable) data;
0135: //--------------------------------------------------------//
0136: //---- Objekt fuer die Table filtern und registrieren ----//
0137: //--------------------------------------------------------//
0138: TKFieldSwitchData subTypeTable = (TKFieldSwitchData) tableData
0139: .get(SUB_TYPE_KEY);
0140:
0141: //---- Kein Objekt wurde fuer Tablle uebergeben => abfangen ----//
0142: if (subTypeTable.alternative.length() == 0)
0143: throw new InstantiationException("no tabletype for "
0144: + fieldType + " " + fieldName);
0145:
0146: this .tableEntry = (TKBaseField) TKFieldRegistry.registry.get(
0147: subTypeTable.alternative, subTypeTable.data);
0148:
0149: //--------------------------------------------------------//
0150: //---- Objekt fuer die Row filtern und registrieren ----//
0151: //--------------------------------------------------------//
0152: TKFieldOptionData rowData = (TKFieldOptionData) tableData
0153: .get(ROW_JANEIN_KEY);
0154: initSubFields(rowData, true);
0155:
0156: //--------------------------------------------------------//
0157: //---- Objekt fuer die Col filtern und registrieren ----//
0158: //--------------------------------------------------------//
0159: TKFieldOptionData colData = (TKFieldOptionData) tableData
0160: .get(COL_JANEIN_KEY);
0161: initSubFields(colData, false);
0162: }
0163:
0164: //*************************************************************************************
0165: /**
0166: * Hilfsmethode fuer init()
0167: * Die Field-Objekte fuer die Zusatz-Row/Col werden aus der Registry geholt
0168: *
0169: * @param String fieldClass, die CLASS_ID
0170: * @param Object data, der Datahash
0171: */
0172: public void initSubFields(TKFieldOptionData optionData,
0173: boolean initRow) throws TKUnregisteredClassException,
0174: ClassNotFoundException, InstantiationException,
0175: IllegalAccessException
0176:
0177: {
0178:
0179: if (optionData.data != null) {
0180: TKHashtable optionDataHash = (TKHashtable) optionData.data;
0181:
0182: //--------------------------------------------------//
0183: //---- Zusatzinfos in globaler Variable merken----//
0184: //--------------------------------------------------//
0185: String selectedVal = (String) optionDataHash
0186: .get(ZUSATZ_KEY);
0187:
0188: if (initRow) {
0189: if (selectedVal.equals(CELLINFO_KEY))
0190: this .isRowCell = true;
0191: else
0192: this .isRowCell = false;
0193: } else {
0194: if (selectedVal.equals(CELLINFO_KEY))
0195: this .isColCell = true;
0196: else
0197: this .isColCell = false;
0198: }
0199:
0200: TKFieldSwitchData subType = (TKFieldSwitchData) optionDataHash
0201: .get(SUB_TYPE_KEY);
0202:
0203: if (subType.alternative.length() == 0)
0204: throw new InstantiationException("no tabletype for "
0205: + fieldType + " " + fieldName);
0206:
0207: if (initRow) {
0208: this .rowEntry = (TKBaseField) TKFieldRegistry.registry
0209: .get(subType.alternative, subType.data);
0210: } else {
0211: this .colEntry = (TKBaseField) TKFieldRegistry.registry
0212: .get(subType.alternative, subType.data);
0213: }
0214:
0215: } else {
0216: if (initRow) {
0217: rowEntry = null;
0218: } else {
0219: colEntry = null;
0220: }
0221: }
0222:
0223: }
0224:
0225: //***************************************************************************
0226: /**
0227: * Methode zur Definition einer Tabelle
0228: */
0229: public TKFieldGroup getDefGroup(TKFieldSwitch allSwitch,
0230: TKFieldSwitchList allSwitchList) {
0231:
0232: //======================= Switch und Check =================//
0233: //---- Eine Checkbox, falls "Yes" selectiert wurde ----//
0234: TKVector singleCheckVector = new TKVector(2);
0235: singleCheckVector.addElement(new TKOptionFieldEntry(
0236: LanguageManager.getText(LANGUAGE_CONTEXT,
0237: "FIELDTABLE_CELL"), "CELL"));
0238: singleCheckVector.addElement(new TKOptionFieldEntry(
0239: LanguageManager.getText(LANGUAGE_CONTEXT,
0240: "FIELDTABLE_ROW_COLUMN"), "NOCELL"));
0241:
0242: TKBaseField[] switchAndCheckArray = {
0243: new TKSelectField("ZUSATZ", LanguageManager.getText(
0244: LANGUAGE_CONTEXT, "FIELDTABLE_ADDINFO"),
0245: singleCheckVector), allSwitch };
0246:
0247: //======================= SPALTENINFOS =================//
0248: //---- Gruppe wird erzeugt mit einer Switchauswahl und einer Checkbox ----//
0249: TKFieldGroup switchAndCheckGroup = new TKFieldGroup(
0250: TKFieldOption.CLASS_ID, new TKVector(
0251: switchAndCheckArray), LanguageManager.getText(
0252: LANGUAGE_CONTEXT, "FIELDTABLE_INFOCOLUMN"));
0253:
0254: //================== ZEILENINFOS =====================/
0255: //---- Gruppe wird erzeugt mit einer Switchauswahl und einer Checkbox ----//
0256: TKFieldGroup switchAndCheckGroup2 = new TKFieldGroup(
0257: TKFieldOption.CLASS_ID, new TKVector(
0258: switchAndCheckArray), LanguageManager.getText(
0259: LANGUAGE_CONTEXT, "FIELDTABLE_INFOROW"));
0260:
0261: //========================= TABELLE ==================================//
0262: //---- Das Array fuer die Tablle mit allem drum und dran ----//
0263: TKBaseField[] tableArray = {
0264: new TKInputField(TKFieldTable.NAME_KEY,
0265: TKInputField.SMALL_DEFAULT_SIZE,
0266: TKInputField.SMALL_DEFAULT_LENGTH,
0267: LanguageManager.getText(LANGUAGE_CONTEXT,
0268: "FIELDTABLE_NAME"),
0269: TKInputField.CHECK_STRING),
0270: new TKInputField(TKFieldTable.SHOW_NAME_KEY,
0271: TKInputField.LARGE_DEFAULT_SIZE,
0272: TKInputField.LARGE_DEFAULT_LENGTH,
0273: LanguageManager.getText(LANGUAGE_CONTEXT,
0274: "FIELDTABLE_SHOWNAME"),
0275: TKInputField.CHECK_STRING),
0276: allSwitch,
0277: new TKFieldOption("JANEINSPALTE", switchAndCheckGroup,
0278: LanguageManager.getText(LANGUAGE_CONTEXT,
0279: "FIELDTABLE_JANEINSPALTE")),
0280: new TKFieldOption("JANEINZEILE", switchAndCheckGroup2,
0281: LanguageManager.getText(LANGUAGE_CONTEXT,
0282: "FIELDTABLE_JANEINZEILE")) };
0283:
0284: //---- Alles, was eine Table haben muss ist da, wenn Feldtabelle ausgewaehlt wird ----//
0285: TKFieldGroup tableGroup = new TKFieldGroup(
0286: TKFieldTable.CLASS_ID, new TKVector(tableArray),
0287: LanguageManager.getText(LANGUAGE_CONTEXT,
0288: TKFieldTable.CLASS_ID));
0289:
0290: return tableGroup;
0291: }
0292:
0293: /**
0294: * Returns the internal representation of this field.
0295: *
0296: * @return the internal representation of this field.
0297: */
0298: public Object toData() {
0299: TKHashtable result = (TKHashtable) super .toData();
0300:
0301: //--------------------------------------------//
0302: //---- Tabelle contentHash zusammenfuegen ----//
0303: //--------------------------------------------//
0304: result.put(SUB_TYPE_KEY, getDataOfAlternative(tableEntry));
0305:
0306: //--------------------------------------------------//
0307: //---- ROW ueber TKFieldOption wiederherstellen ----//
0308: //--------------------------------------------------//
0309: TKFieldOptionData rowEntryOption = null;
0310: result = toDataSubFields(rowEntryOption, rowEntry, result,
0311: "row");
0312:
0313: //--------------------------------------------------//
0314: //---- COL ueber TKFieldOption wiederherstellen ----//
0315: //--------------------------------------------------//
0316: TKFieldOptionData colEntryOption = null;
0317: result = toDataSubFields(colEntryOption, colEntry, result,
0318: "col");
0319:
0320: return result;
0321: }
0322:
0323: //*************************************************************************************
0324: /**
0325: * Hilfsmethode fuer toData()
0326: */
0327:
0328: public TKHashtable toDataSubFields(TKFieldOptionData entryOption,
0329: TKBaseField rowOrColEntry, TKHashtable result,
0330: String rowOrCol) {
0331: if (rowOrColEntry != null) {
0332: //----------------------------------------------//
0333: //---- Das Switch wiederherstellen und in ----//
0334: //---- einen Hash fuer dieGruppe packen ----//
0335: //----------------------------------------------//
0336: TKHashtable groupData = new TKHashtable();
0337: groupData.put(SUB_TYPE_KEY, new TKFieldSwitchData(
0338: rowOrColEntry.getType(), rowOrColEntry.getType(),
0339: rowOrColEntry.toData()));
0340: //----------------------------------------------------------//
0341: //---- Pulldownmenue wieder herstellen und in den Hash ----//
0342: //---- fuer dieGruppe packen ----//
0343: //----------------------------------------------------------//
0344: if (rowOrCol.equals("row")) {
0345: if (isRowCell) {
0346: groupData.put(ZUSATZ_KEY, "CELL");
0347: } else {
0348: groupData.put(ZUSATZ_KEY, "NOCELL");
0349: }
0350: }
0351:
0352: if (rowOrCol.equals("col")) {
0353: if (isColCell) {
0354: groupData.put(ZUSATZ_KEY, "CELL");
0355: } else {
0356: groupData.put(ZUSATZ_KEY, "NOCELL");
0357: }
0358: }
0359:
0360: //---------------------------------------------------//
0361: //---- Switch-Auswahl wenn yes ausgewaehlt wurde ----//
0362: //---------------------------------------------------//
0363: entryOption = new TKFieldOptionData("YES", "YES", groupData);
0364: } else {
0365: entryOption = new TKFieldOptionData("NO", "NO", null);
0366: }
0367: if (rowOrCol.equals("row"))
0368: result.put(ROW_JANEIN_KEY, entryOption);
0369: if (rowOrCol.equals("col"))
0370: result.put(COL_JANEIN_KEY, entryOption);
0371:
0372: return result;
0373: }
0374:
0375: //*************************************************************************************
0376: /**
0377: * parameter TKHashtable data , enthaelt die Parameter
0378: */
0379: public Object compileData(String prefix, TKHashtable data,
0380: TKHashtable context) {
0381: prefix += fieldName + ".";
0382:
0383: //-----------------------------------------------------------//
0384: //---- Alte Eingabewerte werden in Hiddenfeldern gemerkt ----//
0385: //---- und initial auf 1 gesetzt ----//
0386: //-----------------------------------------------------------//
0387: int rows = Integer.parseInt((String) data.get(prefix + "ROW"));
0388: int cols = Integer.parseInt((String) data.get(prefix + "COL"));
0389:
0390: //-----------------------------------------------------------//
0391: //---- Data fuer eine ROW mit den Infos des Hiddenfeldes ----//
0392: //-----------------------------------------------------------//
0393: TKVector rowInfoVector = null;
0394: if ((rowEntry != null) && (rows > 0)) {
0395: rowInfoVector = new TKVector(rows);
0396: for (int x = 0; x < rows; x++) {
0397: rowInfoVector.addElement(rowEntry.compileData(prefix
0398: + PRE_ROWS + "." + x + ".", data, context));
0399: }
0400: }
0401:
0402: //--------------------------------------------------------------//
0403: //---- Data fuer eine COLUMN mit den Infos des Hiddenfeldes ----//
0404: //--------------------------------------------------------------//
0405: TKVector colInfoVector = null;
0406: if ((colEntry != null) && (cols > 0)) {
0407: colInfoVector = new TKVector(cols);
0408: for (int x = 0; x < cols; x++) {
0409: colInfoVector.addElement(colEntry.compileData(prefix
0410: + PRE_COLS + "." + x + ".", data, context));
0411: }
0412: }
0413:
0414: //-------------------------------------------------------------------//
0415: //---- Data fuer Zellen der Table mit den Infos des Hiddenfeldes ----//
0416: //-------------------------------------------------------------------//
0417: TKVector rowsResultVector = (rows == 0) ? null : new TKVector(
0418: rows);
0419: TKVector colsResultVector = null;
0420:
0421: for (int x = 0; x < rows; x++) {
0422: colsResultVector = new TKVector(cols);
0423:
0424: for (int y = 0; y < cols; y++) {
0425: colsResultVector.addElement(tableEntry.compileData(
0426: prefix + x + "." + y + ".", data, context));
0427: }
0428: rowsResultVector.addElement(colsResultVector);
0429: }
0430:
0431: //-----------------------------------------//
0432: //---- Neue Eingabewerte des Benutzers ----//
0433: //-----------------------------------------//
0434: int newRows = Integer.parseInt((String) data.get(prefix
0435: + "NEW_ROWS"));
0436: int newCols = Integer.parseInt((String) data.get(prefix
0437: + "NEW_COLS"));
0438:
0439: return new TKFieldTableRealData(rowsResultVector,
0440: rowInfoVector, colInfoVector, newRows, newCols);
0441:
0442: }
0443:
0444: public Object compileData(String prefix, TKMarkupNode data,
0445: TKHashtable context) {
0446: TKXmlMarkup markup = data == null ? null
0447: : (TKXmlMarkup) data.markup;
0448: if (markup == null) {
0449: return null;
0450: }
0451:
0452: if (!markup.name.equals(getName())) {
0453: return null;
0454: }
0455:
0456: TKXmlTree tree = (TKXmlTree) data.tree;
0457: if (tree == null) {
0458: return null;
0459: }
0460:
0461: TKVector rowInfoVector = null;
0462: TKVector colInfoVector = null;
0463: TKVector rowsResultVector = null;
0464:
0465: int newRows = 0;
0466: int newCols = 0;
0467: int x = 0;
0468:
0469: for (int i = 0; i < tree.size(); i++) {
0470:
0471: Object obj = tree.getSub(i);
0472: if (obj == null)
0473: continue;
0474:
0475: TKMarkupNode subNode = null;
0476: TKXmlMarkup subMarkup = null;
0477:
0478: if (obj instanceof TKXmlMarkup) { // Atomares Markup
0479:
0480: subMarkup = (TKXmlMarkup) obj;
0481:
0482: continue;
0483:
0484: } else {
0485: subNode = (TKMarkupNode) obj;
0486: subMarkup = (TKXmlMarkup) subNode.markup;
0487: }
0488:
0489: if (subMarkup.name.equals("CI")) {
0490:
0491: TKXmlTree subTree = (TKXmlTree) subNode.tree;
0492: if (subTree == null) {
0493: continue;
0494: }
0495:
0496: for (int j = 0; j < subTree.size(); j++) {
0497:
0498: Object subObj = subTree.getSub(j);
0499: if (subObj == null)
0500: continue;
0501:
0502: // TKLog.println ("TKFieldTable.compileData, found ri-obj: "+subObj.getClass().getName());
0503:
0504: TKMarkupNode subSubNode = null;
0505: TKXmlMarkup subSubMarkup = null;
0506:
0507: if (subObj instanceof TKXmlMarkup) { // Atomares Markup
0508:
0509: subSubMarkup = (TKXmlMarkup) subObj;
0510: subSubNode = new TKMarkupNode(subSubMarkup,
0511: null);
0512:
0513: } else {
0514: subSubNode = (TKMarkupNode) subObj;
0515: subSubMarkup = (TKXmlMarkup) subSubNode.markup;
0516: }
0517:
0518: if (colInfoVector == null)
0519: colInfoVector = new TKVector();
0520: colInfoVector.addElement(colEntry.compileData(
0521: prefix + j + ".", subSubNode, context));
0522: }
0523: }
0524:
0525: else if (subMarkup.name.equals("TR")) {
0526:
0527: TKVector colsResultVector = null;
0528:
0529: TKXmlTree subTree = (TKXmlTree) subNode.tree;
0530: if (subTree == null) {
0531: continue;
0532: }
0533:
0534: x++;
0535: if (x >= newRows)
0536: newRows = x + 1;
0537:
0538: int y = 0;
0539: for (int j = 0; j < subTree.size(); j++) {
0540:
0541: Object subObj = subTree.getSub(j);
0542: if (subObj == null)
0543: continue;
0544:
0545: TKMarkupNode subSubNode = null;
0546: TKXmlMarkup subSubMarkup = null;
0547:
0548: if (subObj instanceof TKXmlMarkup) { // Atomares Markup
0549:
0550: subSubMarkup = (TKXmlMarkup) subObj;
0551: subSubNode = new TKMarkupNode(subSubMarkup,
0552: null);
0553:
0554: } else {
0555: subSubNode = (TKMarkupNode) subObj;
0556: subSubMarkup = (TKXmlMarkup) subSubNode.markup;
0557: }
0558:
0559: TKXmlTree subSubTree = (TKXmlTree) subSubNode.tree;
0560: Object subSubObj = subSubTree.getSingleSub();
0561: if (subSubObj == null)
0562: continue;
0563:
0564: TKMarkupNode subSubSubNode = null;
0565: TKXmlMarkup subSubSubMarkup = null;
0566:
0567: if (subSubObj instanceof TKXmlMarkup) { // Atomares Markup
0568:
0569: subSubSubMarkup = (TKXmlMarkup) subSubObj;
0570: subSubSubNode = new TKMarkupNode(
0571: subSubSubMarkup, null);
0572:
0573: } else {
0574: subSubSubNode = (TKMarkupNode) subSubObj;
0575: subSubSubMarkup = (TKXmlMarkup) subSubSubNode.markup;
0576: }
0577:
0578: if (subSubMarkup.name.equals("RI")) {
0579:
0580: if (rowInfoVector == null)
0581: rowInfoVector = new TKVector();
0582: // TKLog.println ("TKFieldTable added ri: "+subSubSubMarkup.name);
0583: rowInfoVector.addElement(rowEntry.compileData(
0584: prefix + j + ".", subSubSubNode,
0585: context));
0586:
0587: } else {
0588:
0589: y++;
0590: if (y >= newCols)
0591: newCols = y + 1;
0592:
0593: if (rowsResultVector == null)
0594: rowsResultVector = new TKVector();
0595: if (colsResultVector == null) {
0596:
0597: colsResultVector = new TKVector();
0598: rowsResultVector
0599: .addElement(colsResultVector);
0600: }
0601:
0602: colsResultVector.addElement(tableEntry
0603: .compileData(
0604: prefix + x + "." + y + ".",
0605: subSubSubNode, context));
0606: }
0607: }
0608: }
0609:
0610: }
0611:
0612: return new TKFieldTableRealData(rowsResultVector,
0613: rowInfoVector, colInfoVector, newRows, newCols);
0614: }
0615:
0616: /**
0617: * Alle Informationen werden der Methode uebergeben, damit das Template
0618: * substituiert werden kann
0619: */
0620: public void fillIntoTemplate(TKHTMLTemplate t, Object data,
0621: String prefix) {
0622: TKFieldTableRealData dataClass = (TKFieldTableRealData) data;
0623: TKVector dataVector = (TKVector) dataClass.contentData;
0624:
0625: super .fillIntoTemplate(t, data, prefix);
0626:
0627: int rows = (dataVector == null ? 0 : dataVector.size());
0628: int cols = (rows == 0 ? 0 : ((TKVector) dataVector
0629: .firstElement()).size());
0630:
0631: t.set("NEW_ROWS", Integer.toString(dataClass.newRowCount));
0632: t.set("NEW_COLS", Integer.toString(dataClass.newColCount));
0633:
0634: t.set("ROW", Integer.toString(rows));
0635: t.set("COL", Integer.toString(cols));
0636:
0637: if ((TKVector) dataClass.rowData != null)
0638: t.set("IS_COLFORINFOS", Boolean.TRUE);
0639:
0640: if ((TKVector) dataClass.colData != null)
0641: t.set("IS_ROWFORINFOS", Boolean.TRUE);
0642:
0643: if (dataVector != null)
0644: t.set("IS_OUTERLIST", Boolean.TRUE);
0645: t.setListIterator(new TKFieldTableIterator(dataClass,
0646: tableEntry, rowEntry, colEntry, prefix + fieldName
0647: + ".", t.getListIterator(), "FIELDTABLEROW",
0648: "FIELDTABLECOL", "ROWFORINFOLIST"));
0649: }
0650:
0651: public void fillIntoDOM(Document doc, Element node, Object data)
0652: throws DOMException {
0653: Element me = doc.createElement(getInternationalName());
0654: node.appendChild(me);
0655: fillAttributesIntoNode(me, data);
0656: TKFieldTableRealData dataClass = (TKFieldTableRealData) data;
0657: TKVector dataVector = (TKVector) dataClass.contentData;
0658:
0659: if (dataVector == null) {
0660: me.setAttribute("ROWSIZE", String.valueOf(0));
0661: me.setAttribute("COLSIZE", String.valueOf(0));
0662: } else {
0663: me.setAttribute("ROWSIZE", String
0664: .valueOf(dataVector.size()));
0665: me.setAttribute("COLSIZE", String
0666: .valueOf(((TKVector) dataVector.firstElement())
0667: .size()));
0668: }
0669:
0670: //---- tabellenlayout ----//
0671: if ((TKVector) dataClass.rowData != null)
0672: me.setAttribute("IS_ROWENTRY", Boolean.TRUE.toString());
0673:
0674: if ((TKVector) dataClass.colData != null)
0675: me.setAttribute("IS_COLENTRY", Boolean.TRUE.toString());
0676:
0677: if (dataVector != null)
0678: me.setAttribute("IS_OUTERLIST", Boolean.TRUE.toString());
0679:
0680: //--- Ueberschrift ----//
0681: if (isRowCell == false)
0682: me.setAttribute("HEADERROW", Boolean.TRUE.toString());
0683: if (isColCell == false)
0684: me.setAttribute("HEADERCOL", Boolean.TRUE.toString());
0685: if (dataVector != null) {
0686: for (int i = 0; i < dataVector.size(); i++) {
0687: TKVector zeile = (TKVector) dataVector.elementAt(i);
0688: // Zeilen Element
0689: Element z = doc.createElement(getName() + "_Row" + i);
0690: me.appendChild(z);
0691: // Zellen einfuegen
0692: for (int j = 0; j < zeile.size(); j++) {
0693: Object fieldData = zeile.elementAt(j);
0694: tableEntry.fillIntoDOM(doc, z, fieldData);
0695: }
0696: }
0697: }
0698: // NICHT FERTIG !
0699: /*
0700: if (dataVector != null)
0701: t.setListIterator( new TKTableShowIterator(
0702: dataClass,
0703: tableEntry,
0704: rowEntry,
0705: colEntry,
0706: scope,
0707: getName(),
0708: t.getListIterator(),
0709: "OUTERLIST",
0710: "INNERLIST",
0711: "ROWFORINFOLIST"
0712: ) );*/
0713:
0714: }
0715:
0716: public void fillIntoPresentation(TKHTMLTemplate t, Object data,
0717: String scope) {
0718: TKFieldTableRealData dataClass = (TKFieldTableRealData) data;
0719: TKVector dataVector = (TKVector) dataClass.contentData;
0720:
0721: if (dataVector == null) {
0722: t.set(scope + "." + getName() + ".ROWSIZE", String
0723: .valueOf(0));
0724: t.set(scope + "." + getName() + ".COLSIZE", String
0725: .valueOf(0));
0726:
0727: } else {
0728: t.set(scope + "." + getName() + ".ROWSIZE", String
0729: .valueOf(dataVector.size()));
0730: t.set(scope + "." + getName() + ".COLSIZE", String
0731: .valueOf(((TKVector) dataVector.firstElement())
0732: .size()));
0733: }
0734:
0735: //---- tabellenlayout ----//
0736: if (dataClass.rowData != null)
0737: t.set("IS_ROWENTRY", Boolean.TRUE);
0738:
0739: if (dataClass.colData != null)
0740: t.set("IS_COLENTRY", Boolean.TRUE);
0741:
0742: if (dataVector != null)
0743: t.set("IS_OUTERLIST", Boolean.TRUE);
0744:
0745: //--- Ueberschrift ----//
0746: if (isRowCell == false)
0747: t.set("HEADERROW", Boolean.TRUE);
0748: if (isColCell == false)
0749: t.set("HEADERCOL", Boolean.TRUE);
0750:
0751: if (dataVector != null)
0752: t.setListIterator(new TKTableShowIterator(dataClass,
0753: tableEntry, rowEntry, colEntry, scope, getName(), t
0754: .getListIterator(), "OUTERLIST",
0755: "INNERLIST", "ROWFORINFOLIST"));
0756:
0757: }
0758:
0759: /**
0760: * Die Klasse, die die Daten der Tabelle haelt wird initial auf die
0761: * defaultwerte gesetzt
0762: */
0763: public Object getDefault() {
0764: //return rowVector;
0765: return new TKFieldTableRealData(null, null, null, 1, 1);
0766: }
0767:
0768: /**
0769: * Eine bestehende Tabelle wird veraendert
0770: */
0771: public Object modify(String action, String fieldPath, Object data,
0772: String prefix, StringBuffer destination) {
0773: TKFieldTableRealData dataClass = (TKFieldTableRealData) data;
0774:
0775: int pLength = prefix.length() + fieldName.length();
0776: int fpLength = fieldPath.length();
0777: //--------------------------------//
0778: //---- Action betrifft Table ----//
0779: //--------------------------------//
0780: if (fpLength == pLength) {
0781:
0782: if (action.equals("MODIFY")) {
0783: destination.append(prefix + fieldName);
0784:
0785: int rowCount = (dataClass.contentData == null ? 0
0786: : dataClass.contentData.size());
0787: int colCount = 0;
0788: if (rowCount == 0) {
0789: if (dataClass.newRowCount == 0
0790: || dataClass.newColCount == 0) {
0791: return data;
0792: }
0793: dataClass.contentData = new TKVector(
0794: dataClass.newColCount);
0795: } else {
0796: colCount = ((TKVector) dataClass.contentData
0797: .firstElement()).size();
0798: }
0799:
0800: if (colEntry != null) {
0801: if (dataClass.colData == null) {
0802: dataClass.colData = new TKVector(
0803: dataClass.newColCount);
0804: }
0805: if (colCount < dataClass.newColCount) {
0806: for (int i = colCount; i < dataClass.newColCount; i++) {
0807: dataClass.colData.addElement(colEntry
0808: .getDefault());
0809: }
0810: } else {
0811: for (int i = dataClass.newColCount; i < colCount; i++) {
0812: dataClass.colData
0813: .removeElementAt(dataClass.newColCount);
0814: }
0815: }
0816: }
0817:
0818: if (rowEntry != null) {
0819: if (dataClass.rowData == null) {
0820: dataClass.rowData = new TKVector(
0821: dataClass.newRowCount);
0822: }
0823: if (rowCount < dataClass.newRowCount) {
0824: for (int i = rowCount; i < dataClass.newRowCount; i++) {
0825: dataClass.rowData.addElement(rowEntry
0826: .getDefault());
0827: }
0828: } else {
0829: for (int i = dataClass.newRowCount; i < rowCount; i++) {
0830: dataClass.rowData
0831: .removeElementAt(dataClass.newRowCount);
0832: }
0833: }
0834: }
0835:
0836: if (rowCount < dataClass.newRowCount) {
0837: if (colCount < dataClass.newColCount) {
0838: for (int i = 0; i < rowCount; i++) {
0839: TKVector currRow = (TKVector) dataClass.contentData
0840: .get(i);
0841: for (int j = colCount; j < dataClass.newColCount; j++)
0842: currRow.addElement(tableEntry
0843: .getDefault());
0844: }
0845: } else {
0846: for (int i = 0; i < rowCount; i++) {
0847: TKVector currRow = (TKVector) dataClass.contentData
0848: .get(i);
0849: for (int j = dataClass.newColCount; j < colCount; j++)
0850: currRow
0851: .removeElementAt(dataClass.newColCount);
0852: }
0853: }
0854: for (int i = rowCount; i < dataClass.newRowCount; i++) {
0855: TKVector newRow = new TKVector(
0856: dataClass.newColCount);
0857: for (int j = 0; j < dataClass.newColCount; j++) {
0858: newRow.addElement(tableEntry.getDefault());
0859: }
0860: dataClass.contentData.addElement(newRow);
0861: }
0862: } else { //weniger Zeilen in neuer Tabelle
0863: for (int i = dataClass.newRowCount; i < rowCount; i++) {
0864: dataClass.contentData
0865: .removeElementAt(dataClass.newRowCount);
0866: }
0867: if (colCount < dataClass.newColCount) {
0868: for (int i = 0; i < dataClass.newRowCount; i++) {
0869: TKVector currRow = (TKVector) dataClass.contentData
0870: .get(i);
0871: for (int j = colCount; j < dataClass.newColCount; j++)
0872: currRow.addElement(tableEntry
0873: .getDefault());
0874: }
0875: } else {
0876: for (int i = 0; i < dataClass.newRowCount; i++) {
0877: TKVector currRow = (TKVector) dataClass.contentData
0878: .get(i);
0879: for (int j = dataClass.newColCount; j < colCount; j++)
0880: currRow
0881: .removeElementAt(dataClass.newColCount);
0882: }
0883: }
0884: }
0885: }
0886: //---- Falls nix mehr da ----//
0887: if (dataClass.contentData.isEmpty())
0888: data = this .getDefault();
0889:
0890: }
0891: //----------------------------------------------------------//
0892: //---- Action betrifft eine Zeile/Spalte der Tabelle -------//
0893: //----------------------------------------------------------//
0894: // FALSCH !!! (singh 6.4.00): else if(fieldPath.lastIndexOf('.',fpLength-4) == pLength) {
0895: else if (fieldPath.lastIndexOf('.', fieldPath.lastIndexOf('.',
0896: fpLength - 2) - 1) == pLength) {
0897:
0898: int rowIdx = 0;
0899: int colIdx = 0;
0900: String subPath = fieldPath.substring(pLength + 1);
0901:
0902: //---- "MODIFYROW" im fieldPath ----//
0903: StringTokenizer getTokenModify = new StringTokenizer(
0904: subPath, ".");
0905: if ((getTokenModify.nextElement()).equals(MODIFY_ROW)) {
0906: String subPathModify = fieldPath
0907: .substring(pLength + 1 + 9);
0908: StringTokenizer getToken = new StringTokenizer(
0909: subPathModify, ".");
0910: rowIdx = Integer.parseInt((String) getToken
0911: .nextElement());
0912:
0913: } else {
0914: StringTokenizer getToken = new StringTokenizer(subPath,
0915: ".");
0916: rowIdx = Integer.parseInt((String) getToken
0917: .nextElement());
0918: colIdx = Integer.parseInt((String) getToken
0919: .nextElement());
0920: }
0921: //------------------------//
0922: //---- Modify Spalten ----//
0923: //------------------------//
0924: if (action.equals("DELETE_COL")) {
0925: destination.append(prefix + fieldName + "."
0926: + MODIFY_ROW + "." + rowIdx + ".");
0927: data = deleteRowOrCol(action, dataClass, rowIdx, colIdx);
0928: }
0929:
0930: if (action.equals("INSERT_COL")) {
0931: destination.append(prefix + fieldName + "."
0932: + MODIFY_ROW + "." + rowIdx + ".");
0933: data = insertRowOrCol(action, dataClass, rowIdx, colIdx);
0934: }
0935: if (colIdx != 0) {
0936: if (action.equals("FIRST_COL")) {
0937: destination.append(prefix + fieldName + "."
0938: + MODIFY_ROW + "." + rowIdx + ".");
0939: dataClass = (TKFieldTableRealData) firstRowOrCol(
0940: action, dataClass, rowIdx, colIdx);
0941: data = deleteRowOrCol("DELETE_COL", dataClass,
0942: rowIdx, colIdx + 1);
0943:
0944: }
0945: if (action.equals("BACK_COL")) {
0946: destination.append(prefix + fieldName + "."
0947: + MODIFY_ROW + "." + rowIdx + ".");
0948: dataClass = (TKFieldTableRealData) backRowOrCol(
0949: action, dataClass, rowIdx, colIdx);
0950: data = deleteRowOrCol("DELETE_COL", dataClass,
0951: rowIdx, colIdx + 1);
0952: }
0953: } else {
0954: if (action.equals("BACK_COL"))
0955: destination.append(prefix + fieldName + "."
0956: + MODIFY_ROW + "." + rowIdx + ".");
0957: }
0958:
0959: if ((rowIdx != dataClass.contentData.size() - 1)
0960: && (colIdx != ((TKVector) dataClass.contentData
0961: .firstElement()).size() - 1)) {
0962: if (action.equals("LAST_COL")) {
0963: destination.append(prefix + fieldName + "."
0964: + MODIFY_ROW + "." + rowIdx + ".");
0965: dataClass = (TKFieldTableRealData) lastRowOrCol(
0966: action, dataClass, rowIdx, colIdx);
0967: data = deleteRowOrCol("DELETE_COL", dataClass,
0968: rowIdx, colIdx);
0969: }
0970: if (action.equals("FORWARD_COL")) {
0971: destination.append(prefix + fieldName + "."
0972: + MODIFY_ROW + "." + rowIdx + ".");
0973: dataClass = (TKFieldTableRealData) forwardRowOrCol(
0974: action, dataClass, rowIdx, colIdx);
0975: data = deleteRowOrCol("DELETE_COL", dataClass,
0976: rowIdx, colIdx);
0977: }
0978: } else {
0979: if (action.equals("FORWARD_COL"))
0980: destination.append(prefix + fieldName + "."
0981: + MODIFY_ROW + "." + rowIdx + ".");
0982: }
0983: //------------------------//
0984: //---- Modify Zeien ----//
0985: //------------------------//
0986: if (action.equals("DELETE_ROW")) {
0987: if (rowIdx == 0)
0988: destination.append(prefix + fieldName + "."
0989: + MODIFY_ROW + "." + rowIdx + ".");
0990: else
0991: destination.append(prefix + fieldName + "."
0992: + MODIFY_ROW + "." + (rowIdx - 1) + ".");
0993: data = deleteRowOrCol(action, dataClass, rowIdx, 0);
0994: }
0995:
0996: if (action.equals("INSERT_ROW")) {
0997: destination.append(prefix + fieldName + "."
0998: + MODIFY_ROW + "." + rowIdx + ".");
0999: data = insertRowOrCol(action, dataClass, rowIdx, 0);
1000: }
1001: if (rowIdx != 0) {
1002: if (action.equals("FIRST_ROW")) {
1003: destination.append(prefix + fieldName + "."
1004: + MODIFY_ROW + "." + 0 + ".");
1005: dataClass = (TKFieldTableRealData) firstRowOrCol(
1006: action, dataClass, rowIdx, 0);
1007: data = deleteRowOrCol("DELETE_ROW", dataClass,
1008: rowIdx + 1, 0);
1009: }
1010: if (action.equals("BACK_ROW")) {
1011: destination.append(prefix + fieldName + "."
1012: + MODIFY_ROW + "." + (rowIdx - 1) + ".");
1013: dataClass = (TKFieldTableRealData) backRowOrCol(
1014: action, dataClass, rowIdx, 0);
1015: data = deleteRowOrCol("DELETE_ROW", dataClass,
1016: rowIdx + 1, 0);
1017: }
1018: } else {
1019: if (action.equals("BACK_ROW"))
1020: destination.append(prefix + fieldName + "."
1021: + MODIFY_ROW + "." + 0 + ".");
1022: }
1023:
1024: if ((rowIdx != dataClass.contentData.size() - 1)) {
1025:
1026: if (action.equals("LAST_ROW")) {
1027: int newRowIdx = ((TKVector) dataClass.contentData
1028: .firstElement()).size() - 1;
1029: destination.append(prefix + fieldName + "."
1030: + MODIFY_ROW + "." + newRowIdx + ".");
1031: dataClass = (TKFieldTableRealData) lastRowOrCol(
1032: action, dataClass, rowIdx, 0);
1033: data = deleteRowOrCol("DELETE_ROW", dataClass,
1034: rowIdx, 0);
1035: }
1036: if (action.equals("FORWARD_ROW")) {
1037:
1038: destination.append(prefix + fieldName + "."
1039: + MODIFY_ROW + "." + (rowIdx + 1) + ".");
1040: dataClass = (TKFieldTableRealData) forwardRowOrCol(
1041: action, dataClass, rowIdx, 0);
1042: data = deleteRowOrCol("DELETE_ROW", dataClass,
1043: rowIdx, 0);
1044: }
1045: } else {
1046: if (action.equals("FORWARD_ROW"))
1047: destination.append(prefix + fieldName + "."
1048: + MODIFY_ROW + "." + rowIdx + ".");
1049: }
1050:
1051: }
1052:
1053: //----------------------------------------------------------//
1054: //---- Action betrifft Subelement Auswahl des Elementes ----//
1055: //----------------------------------------------------------//
1056: else {
1057: String subPath = fieldPath.substring(pLength + 1);
1058:
1059: //---- modify des SubElementes in einer ZusatzRow ----//
1060: if (subPath.startsWith(PRE_ROWS)) {
1061: subPath = subPath.substring(PRE_ROWS.length() + 1);
1062: int idxEnd = subPath.indexOf('.');
1063: String idxStr = subPath.substring(0, idxEnd);
1064: int idx = Integer.parseInt(idxStr);
1065:
1066: dataClass.rowData.put(idx, rowEntry.modify(action,
1067: fieldPath, dataClass.rowData.get(idx), prefix
1068: + fieldName + '.' + PRE_ROWS + "."
1069: + idx + '.', destination));
1070: }
1071: //---- modify des SubElementes in einer ZusatzCol ----//
1072: else if (subPath.startsWith(PRE_COLS)) {
1073: subPath = subPath.substring(PRE_COLS.length() + 1);
1074: int idxEnd = subPath.indexOf('.');
1075: String idxStr = subPath.substring(0, idxEnd);
1076: int idx = Integer.parseInt(idxStr);
1077: dataClass.colData.put(idx, colEntry.modify(action,
1078: fieldPath, dataClass.colData.get(idx), prefix
1079: + fieldName + '.' + PRE_COLS + "."
1080: + idx + '.', destination));
1081: } else {
1082: //---- modify des SubElementes in einer Zelle ----//
1083: StringTokenizer getToken = new StringTokenizer(subPath,
1084: ".");
1085: int rowIdx = Integer.parseInt((String) getToken
1086: .nextElement());
1087: int colIdx = Integer.parseInt((String) getToken
1088: .nextElement());
1089:
1090: TKVector colVector = (TKVector) dataClass.contentData
1091: .elementAt(rowIdx);
1092: colVector.put(colIdx, tableEntry.modify(action,
1093: fieldPath, colVector.get(colIdx), prefix
1094: + fieldName + "." + rowIdx + "."
1095: + colIdx + ".", destination));
1096: }
1097: }
1098: return data;
1099: }
1100:
1101: //***************************************************************
1102: public TKBaseField getTarget(String fieldPath, String prefix) {
1103: TKBaseField targetField = null;
1104: int pLength = prefix.length() + fieldName.length();
1105: int fpLength = fieldPath.length();
1106:
1107: String subPath = fieldPath.substring(pLength + 1);
1108:
1109: //-------------------------------------//
1110: //---- action betrifft Sub-ELement ----//
1111: //-------------------------------------//
1112: if ((fieldPath.length() != pLength)
1113: && (fieldPath.lastIndexOf('.', fpLength - 4) != pLength)) {
1114:
1115: //---- modify des SubElementes in einer ZusatzRow ----//
1116: if (subPath.startsWith(PRE_ROWS)) {
1117: subPath = subPath.substring(PRE_ROWS.length() + 1);
1118: int idxEnd = subPath.indexOf('.');
1119: String idxStr = subPath.substring(0, idxEnd);
1120: int idx = Integer.parseInt(idxStr);
1121:
1122: targetField = rowEntry.getTarget(fieldPath, prefix
1123: + fieldName + '.' + PRE_ROWS + "." + idx + '.');
1124:
1125: }
1126: //---- modify des SubElementes in einer ZusatzCol ----//
1127: else if (subPath.startsWith(PRE_COLS)) {
1128: subPath = subPath.substring(PRE_COLS.length() + 1);
1129: int idxEnd = subPath.indexOf('.');
1130: String idxStr = subPath.substring(0, idxEnd);
1131: int idx = Integer.parseInt(idxStr);
1132:
1133: targetField = colEntry.getTarget(fieldPath, prefix
1134: + fieldName + '.' + PRE_COLS + "." + idx + '.');
1135:
1136: }
1137: //---- modify des SubElementes in einer Zelle ----//
1138: else {
1139: StringTokenizer getToken = new StringTokenizer(subPath,
1140: ".");
1141: int rowIdx = Integer.parseInt((String) getToken
1142: .nextElement());
1143: int colIdx = Integer.parseInt((String) getToken
1144: .nextElement());
1145:
1146: targetField = tableEntry
1147: .getTarget(fieldPath, prefix + fieldName + "."
1148: + rowIdx + "." + colIdx + ".");
1149: }
1150: }
1151:
1152: return targetField;
1153: }
1154:
1155: //*************************************************************************************
1156: /**
1157: *
1158: */
1159: public Object deleteRowOrCol(String action,
1160: TKFieldTableRealData dataClass, int rowIdx, int colIdx) {
1161: //---------------------------------------//
1162: //---- Delete Element from ZusatzRow ----//
1163: //---------------------------------------//
1164: if ((rowEntry != null) && (action.equals("DELETE_ROW"))) {
1165: dataClass.rowData.removeElementAt(rowIdx);
1166: }
1167:
1168: //---------------------------------------//
1169: //---- Delete Element from ZusatzCol ----//
1170: //---------------------------------------//
1171: if ((colEntry != null) && (action.equals("DELETE_COL"))) {
1172: dataClass.colData.removeElementAt(colIdx);
1173: }
1174:
1175: //----------------------------------//
1176: //---- Delete Zeile from Table ----//
1177: //---------------------------------//
1178: if (action.equals("DELETE_ROW")) {
1179: dataClass.contentData.removeElementAt(rowIdx);
1180: }
1181: //----------------------------------//
1182: //---- Delete Spalte from Table ----//
1183: //----------------------------------//
1184: if (action.equals("DELETE_COL")) {
1185: for (int x = 0; x < dataClass.contentData.size(); x++) {
1186: for (int y = 0; y < ((TKVector) dataClass.contentData
1187: .elementAt(x)).size(); y++) {
1188: if (y == colIdx) {
1189: ((TKVector) dataClass.contentData.elementAt(x))
1190: .removeElementAt(y);
1191: }
1192: }
1193: }
1194: }
1195:
1196: //---- Falls nix mehr da ----//
1197: if (dataClass.contentData.isEmpty()) {
1198: return this .getDefault();
1199: } else if (((TKVector) dataClass.contentData.firstElement())
1200: .isEmpty()) {
1201: return this .getDefault();
1202: }
1203:
1204: return dataClass;
1205: }
1206:
1207: /**
1208: *
1209: */
1210: public Object insertRowOrCol(String action,
1211: TKFieldTableRealData dataClass, int rowIdx, int colIdx) {
1212: //---------------------------------------//
1213: //---- Insert Element in ZusatzRow ----//
1214: //---------------------------------------//
1215: if ((rowEntry != null) && (action.equals("INSERT_ROW"))) {
1216: dataClass.rowData.insertElementAt(rowEntry.getDefault(),
1217: rowIdx);
1218: }
1219:
1220: //---------------------------------------//
1221: //---- Insert Element in ZusatzCol ----//
1222: //---------------------------------------//
1223: if ((colEntry != null) && (action.equals("INSERT_COL"))) {
1224: dataClass.colData.insertElementAt(colEntry.getDefault(),
1225: colIdx);
1226: }
1227:
1228: //----------------------------------//
1229: //---- Insert Zeile in Table ----//
1230: //---------------------------------//
1231: if (action.equals("INSERT_ROW")) {
1232: TKVector insertVector = new TKVector();
1233: for (int x = 0; x < ((TKVector) dataClass.contentData
1234: .firstElement()).size(); x++) {
1235: insertVector.addElement(tableEntry.getDefault());
1236: }
1237: dataClass.contentData.insertElementAt(insertVector, rowIdx);
1238: }
1239: //----------------------------------//
1240: //---- Insert Spalte in Table ----//
1241: //----------------------------------//
1242: if (action.equals("INSERT_COL")) {
1243: for (int x = 0; x < dataClass.contentData.size(); x++) {
1244: for (int y = 0; y < ((TKVector) dataClass.contentData
1245: .elementAt(x)).size(); y++) {
1246: if (y == colIdx) {
1247: ((TKVector) dataClass.contentData.elementAt(x))
1248: .insertElementAt(tableEntry
1249: .getDefault(), y);
1250: }
1251:
1252: }
1253: }
1254: }
1255:
1256: return dataClass;
1257: }
1258:
1259: /**
1260: * Move Row Or Col to first Position
1261: */
1262: public Object firstRowOrCol(String action,
1263: TKFieldTableRealData dataClass, int rowIdx, int colIdx) {
1264: //---- Die erste Position bleibt die erste ----//
1265: //if( (action.equals("FIRST_ROW")) && (rowIdx == 0) ) return dataClass;
1266: //if( (action.equals("FIRST_COL")) && (colIdx == 0) ) return dataClass;
1267:
1268: //---------------------------------------//
1269: //---- Insert Element in ZusatzRow ----//
1270: //---------------------------------------//
1271: if ((rowEntry != null) && (action.equals("FIRST_ROW"))) {
1272: Object merkeElement = null;
1273: for (int x = 0; x < dataClass.rowData.size(); x++) {
1274: if (x == rowIdx)
1275: merkeElement = dataClass.rowData.elementAt(x);
1276: }
1277: dataClass.rowData.insertElementAt(merkeElement, 0);
1278: }
1279:
1280: //---------------------------------------//
1281: //---- Insert Element in ZusatzCol ----//
1282: //---------------------------------------//
1283: if ((colEntry != null) && (action.equals("FIRST_COL"))) {
1284: Object merkeElement = null;
1285: for (int x = 0; x < dataClass.colData.size(); x++) {
1286: if (x == colIdx)
1287: merkeElement = dataClass.colData.elementAt(x);
1288: }
1289: dataClass.colData.insertElementAt(merkeElement, 0);
1290: }
1291:
1292: //----------------------------------//
1293: //---- Insert Zeile in Table ----//
1294: //---------------------------------//
1295: if (action.equals("FIRST_ROW")) {
1296:
1297: TKVector merkeRow = null;
1298: //for(int x=0; x < ( (TKVector) dataClass.contentData.firstElement()).size(); x++) {
1299: for (int x = 0; x < ((TKVector) dataClass.contentData)
1300: .size(); x++) {
1301: if (x == rowIdx) {
1302: merkeRow = (TKVector) dataClass.contentData
1303: .elementAt(x);
1304: }
1305: }
1306:
1307: dataClass.contentData.insertElementAt(merkeRow, 0);
1308:
1309: }
1310: //----------------------------------//
1311: //---- Insert Spalte in Table ----//
1312: //----------------------------------//
1313: if (action.equals("FIRST_COL")) {
1314: TKVector merkeCol = new TKVector();
1315: for (int x = 0; x < dataClass.contentData.size(); x++) {
1316: for (int y = 0; y < ((TKVector) dataClass.contentData
1317: .elementAt(x)).size(); y++) {
1318: if (y == colIdx) {
1319: merkeCol
1320: .addElement(((TKVector) dataClass.contentData
1321: .elementAt(x)).elementAt(y));
1322: }
1323: }
1324: }
1325: for (int x = 0; x < dataClass.contentData.size(); x++) {
1326: for (int y = 0; y < ((TKVector) dataClass.contentData
1327: .elementAt(x)).size(); y++) {
1328: if (y == 0) {
1329: ((TKVector) dataClass.contentData.elementAt(x))
1330: .insertElementAt(merkeCol.elementAt(x),
1331: y);
1332: }
1333:
1334: }
1335: }
1336: }
1337:
1338: return dataClass;
1339: }
1340:
1341: //*************************************************************************************
1342: /**
1343: * Move Row Or Col to last Position
1344: */
1345: public Object lastRowOrCol(String action,
1346: TKFieldTableRealData dataClass, int rowIdx, int colIdx) {
1347: //---------------------------------------//
1348: //---- Element in ZusatzRow ----//
1349: //---------------------------------------//
1350: if ((rowEntry != null) && (action.equals("LAST_ROW"))) {
1351: Object merkeElement = null;
1352: for (int x = 0; x < dataClass.rowData.size(); x++) {
1353: if (x == rowIdx)
1354: merkeElement = dataClass.rowData.elementAt(x);
1355: }
1356: dataClass.rowData.addElement(merkeElement);
1357: }
1358:
1359: //---------------------------------------//
1360: //---- Element in ZusatzCol ----//
1361: //---------------------------------------//
1362: if ((colEntry != null) && (action.equals("LAST_COL"))) {
1363: Object merkeElement = null;
1364: for (int x = 0; x < dataClass.colData.size(); x++) {
1365: if (x == colIdx)
1366: merkeElement = dataClass.colData.elementAt(x);
1367: }
1368: dataClass.colData.addElement(merkeElement);
1369: }
1370:
1371: //----------------------------------//
1372: //---- Zeile in Table ----//
1373: //---------------------------------//
1374: if (action.equals("LAST_ROW")) {
1375:
1376: TKVector merkeRow = null;
1377: for (int x = 0; x < ((TKVector) dataClass.contentData
1378: .firstElement()).size(); x++) {
1379: if (x == rowIdx) {
1380: merkeRow = (TKVector) dataClass.contentData
1381: .elementAt(x);
1382: }
1383: }
1384: dataClass.contentData.addElement(merkeRow);
1385:
1386: }
1387: //----------------------------------//
1388: //---- Spalte in Table ----//
1389: //----------------------------------//
1390: if (action.equals("LAST_COL")) {
1391: TKVector merkeCol = new TKVector();
1392: for (int x = 0; x < dataClass.contentData.size(); x++) {
1393: for (int y = 0; y < ((TKVector) dataClass.contentData
1394: .elementAt(x)).size(); y++) {
1395: if (y == colIdx) {
1396: merkeCol
1397: .addElement(((TKVector) dataClass.contentData
1398: .elementAt(x)).elementAt(y));
1399: }
1400: }
1401: }
1402:
1403: for (int x = 0; x < dataClass.contentData.size(); x++) {
1404: ((TKVector) dataClass.contentData.elementAt(x))
1405: .addElement(merkeCol.elementAt(x));
1406: }
1407: }
1408: return dataClass;
1409: }
1410:
1411: //*************************************************************************************
1412: /**
1413: * Move Row Or Col um eine Position nach unten bzw. nachr echts
1414: */
1415: public Object forwardRowOrCol(String action,
1416: TKFieldTableRealData dataClass, int rowIdx, int colIdx) {
1417: //---------------------------------------//
1418: //---- Element in ZusatzRow ----//
1419: //---------------------------------------//
1420: if ((rowEntry != null) && (action.equals("FORWARD_ROW"))) {
1421: Object merkeElement = null;
1422: for (int x = 0; x < dataClass.rowData.size(); x++) {
1423: if (x == rowIdx)
1424: merkeElement = dataClass.rowData.elementAt(x);
1425: }
1426: dataClass.rowData.insertElementAt(merkeElement, rowIdx + 2);
1427: }
1428:
1429: //---------------------------------------//
1430: //---- Element in ZusatzCol ----//
1431: //---------------------------------------//
1432: if ((colEntry != null) && (action.equals("FORWARD_COL"))) {
1433: Object merkeElement = null;
1434: for (int x = 0; x < dataClass.colData.size(); x++) {
1435: if (x == colIdx)
1436: merkeElement = dataClass.colData.elementAt(x);
1437: }
1438: dataClass.colData.insertElementAt(merkeElement, colIdx + 2);
1439: }
1440:
1441: //----------------------------------//
1442: //---- Zeile in Table ----//
1443: //---------------------------------//
1444: if (action.equals("FORWARD_ROW")) {
1445: TKVector merkeRow = null;
1446: //for(int x=0; x < ( (TKVector) dataClass.contentData.firstElement()).size(); x++) {
1447: for (int x = 0; x < ((TKVector) dataClass.contentData)
1448: .size(); x++) {
1449: if (x == rowIdx) {
1450: merkeRow = (TKVector) dataClass.contentData
1451: .elementAt(x);
1452: }
1453: }
1454: dataClass.contentData.insertElementAt(merkeRow, rowIdx + 2);
1455:
1456: }
1457: //----------------------------------//
1458: //---- Spalte in Table ----//
1459: //----------------------------------//
1460: if (action.equals("FORWARD_COL")) {
1461: TKVector merkeCol = new TKVector();
1462: for (int x = 0; x < dataClass.contentData.size(); x++) {
1463: for (int y = 0; y < ((TKVector) dataClass.contentData
1464: .elementAt(x)).size(); y++) {
1465: if (y == colIdx) {
1466: merkeCol
1467: .addElement(((TKVector) dataClass.contentData
1468: .elementAt(x)).elementAt(y));
1469: }
1470: }
1471: }
1472:
1473: for (int x = 0; x < dataClass.contentData.size(); x++) {
1474: ((TKVector) dataClass.contentData.elementAt(x))
1475: .insertElementAt(merkeCol.elementAt(x),
1476: colIdx + 2);
1477: }
1478: }
1479: return dataClass;
1480: }
1481:
1482: //*************************************************************************************
1483: /**
1484: * Move Row Or Col um eine Position nach oben bzw. nach links
1485: */
1486: public Object backRowOrCol(String action,
1487: TKFieldTableRealData dataClass, int rowIdx, int colIdx) {
1488: //---------------------------------------//
1489: //---- Element in ZusatzRow ----//
1490: //---------------------------------------//
1491: if ((rowEntry != null) && (action.equals("BACK_ROW"))) {
1492: Object merkeElement = null;
1493: for (int x = 0; x < dataClass.rowData.size(); x++) {
1494: if (x == rowIdx)
1495: merkeElement = dataClass.rowData.elementAt(x);
1496: }
1497: dataClass.rowData.insertElementAt(merkeElement, rowIdx - 1);
1498: }
1499:
1500: //---------------------------------------//
1501: //---- Element in ZusatzCol ----//
1502: //---------------------------------------//
1503: if ((colEntry != null) && (action.equals("BACK_COL"))) {
1504: Object merkeElement = null;
1505: for (int x = 0; x < dataClass.colData.size(); x++) {
1506: if (x == colIdx)
1507: merkeElement = dataClass.colData.elementAt(x);
1508: }
1509: dataClass.colData.insertElementAt(merkeElement, colIdx - 1);
1510: }
1511:
1512: //----------------------------------//
1513: //---- Zeile in Table ----//
1514: //---------------------------------//
1515: if (action.equals("BACK_ROW")) {
1516: TKVector merkeRow = null;
1517:
1518: //for(int x=0; x < ( (TKVector) dataClass.contentData.firstElement()).size(); x++) {
1519: for (int x = 0; x < ((TKVector) dataClass.contentData)
1520: .size(); x++) {
1521: if (x == rowIdx) {
1522: merkeRow = (TKVector) dataClass.contentData
1523: .elementAt(x);
1524: }
1525: }
1526: dataClass.contentData.insertElementAt(merkeRow, rowIdx - 1);
1527:
1528: }
1529: //----------------------------------//
1530: //---- Spalte in Table ----//
1531: //----------------------------------//
1532: if (action.equals("BACK_COL")) {
1533: TKVector merkeCol = new TKVector();
1534: for (int x = 0; x < dataClass.contentData.size(); x++) {
1535: for (int y = 0; y < ((TKVector) dataClass.contentData
1536: .elementAt(x)).size(); y++) {
1537: if (y == colIdx) {
1538: merkeCol
1539: .addElement(((TKVector) dataClass.contentData
1540: .elementAt(x)).elementAt(y));
1541: }
1542: }
1543: }
1544:
1545: for (int x = 0; x < dataClass.contentData.size(); x++) {
1546: ((TKVector) dataClass.contentData.elementAt(x))
1547: .insertElementAt(merkeCol.elementAt(x),
1548: colIdx - 1);
1549: }
1550: }
1551: return dataClass;
1552: }
1553:
1554: /**
1555: * Die Daten des Objekts werden in einer Uebergangsstruktur angelegt,
1556: * damit diese in die DB eingetragen werden kann. Die Daten des Subelementes
1557: * (optionData.data) in der entsprechenden Methode insertDataIntoDB in die
1558: * Uebergangsstruktur gelegt.
1559: */
1560: public int insertDataIntoDB(TKContentDBData db, Object data,
1561: int contentId, int leftNr) {
1562: TKFieldTableRealData tableData = (TKFieldTableRealData) data;
1563: //----------------------------------------------------------------------//
1564: //---- Ein Knoten wird gesetzt, TKFieldOption kann nur einen haben ----//
1565: //---- Das Objekt node haelt alle noetigen Infos fuer die Struktur: ----//
1566: //---- CONTENT_ID, CONTENT_NODE_ID, LEFT_NR, RIGHT_NR,NAME ----//
1567: //---- Intern wird die RIGHT_NR = LEFT_NR+1 gesetzt ----//
1568: //----------------------------------------------------------------------//
1569: TKContentNodeTableData node = insertNewContentNode(db,
1570: contentId, leftNr);
1571: int newNodeId = node.content_node_id;
1572:
1573: //------------------------------------------------------//
1574: //---- grundlegende Infos zur Tabelle ----//
1575: //---- (leider, Attribute werden in real gesetzt) ----//
1576: //---- 1. Anzahl der rows der Tabelle ----//
1577: //---- 2. Anzahl der cols der Tabelle ----//
1578: //---- 3. Zusatzrow ----//
1579: //---- 4. Zusatzcol ----//
1580: //------------------------------------------------------//
1581: TKVector firstDataRow = null;
1582:
1583: if (tableData.contentData != null) {
1584: TKVector dataVector = (TKVector) tableData.contentData;
1585: firstDataRow = (TKVector) dataVector.elementAt(0);
1586: insertNewContentValue(db, contentId, newNodeId, 0, String
1587: .valueOf(dataVector.size()));
1588: insertNewContentValue(db, contentId, newNodeId, 1, String
1589: .valueOf(firstDataRow.size()));
1590: } else {
1591: insertNewContentValue(db, contentId, newNodeId, 0, "0");
1592: insertNewContentValue(db, contentId, newNodeId, 1, "0");
1593: return leftNr + 1;
1594: }
1595: //------------------------------------------------------------------------------//
1596: //---- Eine Auswahl wurde bereits getroffen, so dass das uebergebene ----//
1597: //---- Objekt optionEntry bereits erzeugt wurde. Die Struktur des ----//
1598: //---- SubElement muss wiederum in die Uebergangsstruktur eingetragen werden----//
1599: //------------------------------------------------------------------------------//
1600: //---- InfoRow ----//
1601: if (rowEntry != null) {
1602: for (int x = 0; x < tableData.contentData.size(); x++) {
1603: node.right_nr = rowEntry.insertDataIntoDB(db,
1604: tableData.rowData.elementAt(x), contentId,
1605: leftNr + 1) + 1;
1606: }
1607: }
1608:
1609: //------ InfoCol ----//
1610: if (colEntry != null) {
1611: for (int x = 0; x < firstDataRow.size(); x++) {
1612: node.right_nr = colEntry.insertDataIntoDB(db,
1613: tableData.colData.elementAt(x), contentId,
1614: leftNr + 1) + 1;
1615: }
1616: }
1617:
1618: //---- Table ----//
1619: for (int x = 0; x < tableData.contentData.size(); x++) {
1620: TKVector colVector = (TKVector) tableData.contentData
1621: .elementAt(x);
1622: for (int y = 0; y < colVector.size(); y++) {
1623: node.right_nr = tableEntry.insertDataIntoDB(db,
1624: colVector.elementAt(y), contentId, leftNr + 1) + 1;
1625:
1626: }
1627: }
1628: return node.right_nr;
1629:
1630: }
1631:
1632: /**
1633: * Die Daten werden aus der DB ausgelesen und wieder wie vorher aufgebaut
1634: *
1635: * @param TKContentDBData db, enthaelt die Struktur
1636: * @return die Klasse, die die Daten enthaelt
1637: */
1638: public Object getDataFromDB(TKContentDBData db) {
1639: TKContentNodeTableData node = getContentNodeFromDB(db);
1640:
1641: TKContentValueTableData value0 = getContentNodeValueFromDB(db,
1642: node);
1643: int sizeTableRow = Integer.parseInt(value0.value);
1644:
1645: TKContentValueTableData value1 = getContentNodeValueFromDB(db,
1646: node);
1647: int sizeTableCol = Integer.parseInt(value1.value);
1648:
1649: if (sizeTableRow == 0)
1650: return getDefault();
1651:
1652: TKVector rowsResultVector = new TKVector(sizeTableRow);
1653: TKVector colsResultVector = null;
1654:
1655: TKVector rowInfoVector = new TKVector(sizeTableRow);
1656: TKVector colInfoVector = new TKVector(sizeTableCol);
1657:
1658: //---- Info Row ----//
1659: if (rowEntry != null) {
1660: for (int x = 0; x < sizeTableRow; x++) {
1661: rowInfoVector.addElement(rowEntry.getDataFromDB(db));
1662: }
1663: } else
1664: rowInfoVector = null;
1665:
1666: //---- Info Col ----//
1667: if (colEntry != null) {
1668: for (int x = 0; x < sizeTableCol; x++) {
1669: colInfoVector.addElement(colEntry.getDataFromDB(db));
1670: }
1671: } else
1672: colInfoVector = null;
1673:
1674: //---- table ----//
1675: for (int x = 0; x < sizeTableRow; x++) {
1676: colsResultVector = new TKVector(sizeTableCol);
1677: for (int y = 0; y < sizeTableCol; y++) {
1678: colsResultVector.addElement(tableEntry
1679: .getDataFromDB(db));
1680: }
1681: rowsResultVector.addElement(colsResultVector);
1682: }
1683: return new TKFieldTableRealData(rowsResultVector,
1684: rowInfoVector, colInfoVector, sizeTableRow,
1685: sizeTableCol);
1686: }
1687:
1688: /**
1689: * Erster Aufruf => sich selbst und das Subelemente auf -1 setzen.
1690: * Damit kann im weiteren Verlauf sichergestellt werden, dass, wenn
1691: * ein Opbjekt schon eingetragen ist, dies nicht noch einmal
1692: * eingetragen wird.
1693: */
1694: public void clearId() {
1695: if (fieldId == -1)
1696: return;
1697:
1698: fieldId = -1;
1699: tableEntry.clearId();
1700: if (rowEntry != null)
1701: rowEntry.clearId();
1702: if (colEntry != null)
1703: colEntry.clearId();
1704: }
1705:
1706: /**
1707: * Die Struktur des Objekts und seiner Subelemente werden in einer Uebergangsstruktur
1708: * fuer die DB abgelegt.
1709: */
1710: public int realInsertIntoDB(TKFormDBData db, int formId) {
1711: if (super .realInsertIntoDB(db, formId) == -1)
1712: return -1;
1713:
1714: //---- tableEntry ----//
1715: TKSubFieldTableData subFieldDBTable = insertNewSubField(db,
1716: formId, TABLE_ENTRY_KEY, 0);
1717: tableEntry.realInsertIntoDB(db, formId);
1718: subFieldDBTable.sub_field_id = tableEntry.fieldId;
1719:
1720: //------------------------------------------------------------------//
1721: //---- Diese Attribute zuerst setzen, da hieraus erkennbar ist, ----//
1722: //---- ob ein colEntry oder rowEntry vorhanden ist ----//
1723: //------------------------------------------------------------------//
1724: if (rowEntry != null)
1725: insertNewFieldAttribute(db, formId, IS_ROWENTRY_KEY, 0,
1726: String.valueOf(1));
1727: else
1728: insertNewFieldAttribute(db, formId, IS_ROWENTRY_KEY, 0,
1729: String.valueOf(0));
1730:
1731: if (colEntry != null)
1732: insertNewFieldAttribute(db, formId, IS_COLENTRY_KEY, 0,
1733: String.valueOf(1));
1734: else
1735: insertNewFieldAttribute(db, formId, IS_COLENTRY_KEY, 0,
1736: String.valueOf(0));
1737:
1738: //---- rowEntry ----//
1739: if (rowEntry != null) {
1740: //---- Was wurde im Pulldown ausgewaehlt => true oder false merken ----//
1741: insertNewFieldAttribute(db, formId, BOOL_ZUSATZ_ROW, 0,
1742: String.valueOf(isRowCell));
1743:
1744: TKSubFieldTableData subFieldDBRow = insertNewSubField(db,
1745: formId, ROW_ENTRY_KEY, 0);
1746: rowEntry.realInsertIntoDB(db, formId);
1747: subFieldDBRow.sub_field_id = rowEntry.fieldId;
1748:
1749: }
1750:
1751: //---- colEntry ----//
1752: if (colEntry != null) {
1753: //---- Was wurde im Pulldown ausgewaehlt => true oder false merken ----//
1754: insertNewFieldAttribute(db, formId, BOOL_ZUSATZ_COL, 0,
1755: String.valueOf(isColCell));
1756:
1757: TKSubFieldTableData subFieldDBCol = insertNewSubField(db,
1758: formId, COL_ENTRY_KEY, 0);
1759: colEntry.realInsertIntoDB(db, formId);
1760: subFieldDBCol.sub_field_id = colEntry.fieldId;
1761: }
1762:
1763: return fieldId;
1764:
1765: }
1766:
1767: //*************************************************************************************
1768: /**
1769: * Aufgabe wie ein Konstruktor, die Struktur des Objektes und seiner
1770: * Subelemente wird wieder aufgebaut
1771: * ACHTUNG: Aufbau in umgekehrter Reihenfolge als in realInsertIntoDB
1772: */
1773: public void initFromDB(String classId, TKFormDBData db,
1774: TKVector otherFields) throws TKUnregisteredClassException,
1775: ClassNotFoundException, InstantiationException,
1776: IllegalAccessException {
1777: super .initFromDB(classId, db, otherFields);
1778:
1779: tableEntry = getSubField(db, TABLE_ENTRY_KEY, 0, otherFields);
1780:
1781: //---- Attribute, welche ZusatzBaseFields aufgebaut werden muessen ----//
1782: int isRowEntry = Integer.parseInt(getFieldAttribute(db,
1783: IS_ROWENTRY_KEY, 0));
1784: int isColEntry = Integer.parseInt(getFieldAttribute(db,
1785: IS_COLENTRY_KEY, 0));
1786:
1787: if (isRowEntry == 1) {
1788: //---- Attribute, was aus dem Pulldown Ausgewaehlt wurde fuer Row ----//
1789: String zusatzInfoRow = getFieldAttribute(db,
1790: BOOL_ZUSATZ_ROW, 0);
1791: isRowCell = (zusatzInfoRow.equalsIgnoreCase("true")) ? true
1792: : false;
1793: rowEntry = getSubField(db, ROW_ENTRY_KEY, 0, otherFields);
1794: }
1795:
1796: if (isColEntry == 1) {
1797: //---- Attribute, was aus dem Pulldown Ausgewaehlt wurde fuer Col ----//
1798: String zusatzInfoCol = getFieldAttribute(db,
1799: BOOL_ZUSATZ_COL, 0);
1800: isColCell = (zusatzInfoCol.equalsIgnoreCase("true")) ? true
1801: : false;
1802: colEntry = getSubField(db, COL_ENTRY_KEY, 0, otherFields);
1803: }
1804: }
1805:
1806: /**
1807: * Checks wether this object and the specified object
1808: * may be treated as equal.
1809: *
1810: * @param object the object to checked for equality.
1811: * @return <CODE>true</CODE> if this object and the
1812: * specified object may be treated as equal, otherwise
1813: * <CODE>false</CODE>.
1814: */
1815: public boolean equals(Object object) {
1816: if (!super .equals(object)) {
1817: return false;
1818: }
1819:
1820: TKFieldTable field = (TKFieldTable) object;
1821:
1822: return (this .isRowCell == field.isRowCell)
1823: && (this .isColCell == field.isColCell)
1824: && (this .tableEntry == null ? field.tableEntry == null
1825: : this .tableEntry.equals(field.tableEntry))
1826: && (this .rowEntry == null ? field.rowEntry == null
1827: : this .rowEntry.equals(field.rowEntry))
1828: && (this .colEntry == null ? field.colEntry == null
1829: : this .colEntry.equals(field.colEntry));
1830: }
1831:
1832: /**
1833: * Returns the hash code for this object.
1834: *
1835: * @return the hash code for this object.
1836: */
1837: public int hashCode() {
1838: // Implementation for JTest only ;-(
1839: return super.hashCode();
1840: }
1841:
1842: }
|