Java > Open Source Codes > com > teamkonzept > field > TKFieldTable


1 package com.teamkonzept.field;
2
3 import java.util.Properties ;
4 import java.util.StringTokenizer ;
5 import com.teamkonzept.lib.*;
6 import com.teamkonzept.publishing.markups.*;
7 import com.teamkonzept.web.*;
8 import com.teamkonzept.field.db.*;
9 import com.teamkonzept.international.LanguageManager;
10 import org.w3c.dom.*;
11
12 /**
13  * The field table control.
14  * <PRE>
15  * Die Zellen einer Tabelle beinhalten jeweils das gleiche BaseField.
16  * Dies gilt auch fuer die Zusatz-Zeile/Spalte.
17  *
18  * Folgende Moeglichkeiten bestehen:
19  * 1. Anlegen von Tabellen variabler Groesse
20  * 2. Anlegen von einer Zeile/Spalte, die Zusatzinformationen enthalten
21  * 3. Auswahl der Inhalte (Fields) der Zellen
22  * 4. Auswahl der Inhalte (Fields) der Zusatzz-Zeilen/Spalten
23  * 5. Anzeigen der Tabelle
24  * 6. Das modifizieren der Tabelle selbst
25  * - Loeschen von Zeilen/Spalten
26  * - Einfuegen von Zeilen/Spalten
27  * - Vertauschen von Zeilen/Spalten
28  * 7. Speichern aller Daten in die Datenbank
29  * 8. Speichern aller Strukturinformationen in die Datenbank
30  *
31  * Um Verwechselungen zu vermeiden:
32  *
33  * --------------------------------
34  * | Col-Zusatz-Vektor |
35  * --------------------------------
36  * ------
37  * | Row- |
38  * | zu- |
39  * | satz | TABELLE
40  * | vek- |
41  * | tor |
42  * | |
43  * ------
44  * </PRE>
45  * @author $Author: uli $
46  * @version $Revision: 1.27 $
47  */
48 public class TKFieldTable
49     extends TKBaseField
50 {
51     // $Id: TKFieldTable.java,v 1.27 2002/02/27 11:07:04 uli Exp $
52
53     /**
54      * The class identifier.
55      */
56     public static final String CLASS_ID = "FIELDTABLE";
57     public static final String TABLE_ENTRY_KEY = "TABLEENTRY";
58     public static final String ROW_ENTRY_KEY = "ROWENTRY";
59     public static final String COL_ENTRY_KEY = "COLENTRY";
60
61     public static final String IS_ROWENTRY_KEY = "IS_ROWENTRY";
62     public static final String IS_COLENTRY_KEY = "IS_COLENTRY";
63     public static final String ROW_JANEIN_KEY = "JANEINZEILE";
64     public static final String COL_JANEIN_KEY = "JANEINSPALTE";
65
66     public static final String ZUSATZ_KEY = "ZUSATZ";
67     public static final String CELLINFO_KEY = "CELL";
68     public static final String NOCELLINFO_KEY = "NOCELL";
69     public static final String BOOL_ZUSATZ_ROW = "BOOLZUSATZROW";
70     public static final String BOOL_ZUSATZ_COL = "BOOLZUSATZCOL";
71
72     public static final String PRE_COLS = "COL";
73     public static final String PRE_ROWS = "ROW";
74
75     public static final String MODIFY_ROW = "MODIFYROW";
76
77     public boolean isRowCell; //true wenn Cell
78 public boolean isColCell; //true wenn Cell
79
80     TKBaseField tableEntry;
81     TKBaseField rowEntry;
82     TKBaseField colEntry;
83
84     /**
85      * Creates an empty field table control.
86      */
87     public TKFieldTable() {};
88
89     public TKFieldTable( String name, TKBaseField tableEntry )
90     {
91         this( name, tableEntry, null, null );
92     }
93
94
95     public TKFieldTable(
96         String name,
97         TKBaseField tableEntry,
98         TKBaseField rowEntry,
99         TKBaseField colEntry )
100     {
101         this( name, tableEntry, rowEntry, colEntry, null );
102     }
103
104
105     public TKFieldTable(
106         String name,
107         TKBaseField tableEntry,
108         TKBaseField rowEntry,
109         TKBaseField colEntry ,
110         String showName )
111     {
112         initFieldTable( name, tableEntry, rowEntry, colEntry, showName );
113     }
114
115
116     /**
117      * Die BaseFields werden uebergeben und den entsprechenden Objekten
118      * der Klasse zugewiesen (aehnlich einem Konstruktor)
119      *
120      * @param TKBaseField tableEntry, Field-Object fuer die Zellen
121      * @param TKBaseField rowEntry, Field-Object fuer den Zusatzvektor (Row)
122      * @param TKBaseField tableEntry, Field-Object fuer den Zusatzvektor (Col)
123      */
124     public final void initFieldTable(
125         String name,
126         TKBaseField tableEntry,
127         TKBaseField rowEntry,
128         TKBaseField colEntry ,
129         String showName )
130     {
131         initBaseField( CLASS_ID, name, showName );
132         this.tableEntry = tableEntry;
133         this.rowEntry = rowEntry;
134         this.colEntry = colEntry;
135     }
136
137     //*************************************************************************************
138 /**
139      * Die Daten der globalen Struktur werden uebergeben. Aus diesen Daten wird die
140      * Fieldstruktur fuer die Tabelle aufgebaut
141      * Das Field-Objekt fuer die Table wird aus der Registry geholt
142      *
143      * @param String fieldClass, die CLASS_ID
144      * @param Object data, der Datahash
145      */
146     public void init( String fieldClass, Object data )
147         throws
148             TKUnregisteredClassException,
149             ClassNotFoundException ,
150             InstantiationException ,
151             IllegalAccessException
152     {
153         super.init( fieldClass, data );
154
155         TKHashtable tableData = (TKHashtable) data;
156         //--------------------------------------------------------//
157 //---- Objekt fuer die Table filtern und registrieren ----//
158 //--------------------------------------------------------//
159 TKFieldSwitchData subTypeTable = (TKFieldSwitchData) tableData.get(SUB_TYPE_KEY);
160
161         //---- Kein Objekt wurde fuer Tablle uebergeben => abfangen ----//
162 if( subTypeTable.alternative.length() == 0 )
163             throw new InstantiationException ( "no tabletype for "+fieldType+" "+fieldName );
164
165         this.tableEntry = (TKBaseField)
166             TKFieldRegistry.registry.get( subTypeTable.alternative, subTypeTable.data );
167
168         //--------------------------------------------------------//
169 //---- Objekt fuer die Row filtern und registrieren ----//
170 //--------------------------------------------------------//
171 TKFieldOptionData rowData = (TKFieldOptionData)tableData.get(ROW_JANEIN_KEY);
172         initSubFields(rowData, true);
173
174         //--------------------------------------------------------//
175 //---- Objekt fuer die Col filtern und registrieren ----//
176 //--------------------------------------------------------//
177 TKFieldOptionData colData= (TKFieldOptionData)tableData.get(COL_JANEIN_KEY);
178         initSubFields(colData, false);
179     }
180
181     //*************************************************************************************
182 /**
183      * Hilfsmethode fuer init()
184      * Die Field-Objekte fuer die Zusatz-Row/Col werden aus der Registry geholt
185      *
186      * @param String fieldClass, die CLASS_ID
187      * @param Object data, der Datahash
188      */
189     public void initSubFields(TKFieldOptionData optionData, boolean initRow)
190         throws
191         TKUnregisteredClassException,
192         ClassNotFoundException ,
193         InstantiationException ,
194         IllegalAccessException
195
196     {
197
198         if(optionData.data != null) {
199             TKHashtable optionDataHash = (TKHashtable) optionData.data;
200
201             //--------------------------------------------------//
202 //---- Zusatzinfos in globaler Variable merken----//
203 //--------------------------------------------------//
204 String selectedVal = (String ) optionDataHash.get(ZUSATZ_KEY);
205
206             if(initRow) {
207                 if(selectedVal.equals(CELLINFO_KEY)) this.isRowCell = true;
208                 else this.isRowCell = false;
209             }
210             else {
211                 if(selectedVal.equals(CELLINFO_KEY)) this.isColCell = true;
212                 else this.isColCell = false;
213             }
214
215             TKFieldSwitchData subType = (TKFieldSwitchData) optionDataHash.get(SUB_TYPE_KEY);
216
217             if( subType.alternative.length() == 0 )
218                 throw new InstantiationException ( "no tabletype for "+fieldType+" "+fieldName );
219
220
221             if(initRow) {
222                 this.rowEntry = (TKBaseField)
223                     TKFieldRegistry.registry.get( subType.alternative, subType.data );
224             }
225             else {
226                 this.colEntry = (TKBaseField)
227                     TKFieldRegistry.registry.get( subType.alternative, subType.data );
228             }
229
230         }
231         else {
232             if(initRow) {
233                 rowEntry = null;
234             }
235             else {
236                 colEntry = null;
237             }
238         }
239
240     }
241
242     //***************************************************************************
243 /**
244      * Methode zur Definition einer Tabelle
245      */
246     public TKFieldGroup getDefGroup(TKFieldSwitch allSwitch, TKFieldSwitchList allSwitchList) {
247
248         //======================= Switch und Check =================//
249 //---- Eine Checkbox, falls "Yes" selectiert wurde ----//
250 TKVector singleCheckVector = new TKVector(2);
251         singleCheckVector.addElement(
252             new TKOptionFieldEntry( LanguageManager.getText(LANGUAGE_CONTEXT, "FIELDTABLE_CELL"), "CELL" ) );
253         singleCheckVector.addElement(
254             new TKOptionFieldEntry( LanguageManager.getText(LANGUAGE_CONTEXT, "FIELDTABLE_ROW_COLUMN"), "NOCELL" ) );
255
256
257         TKBaseField [] switchAndCheckArray = {
258             new TKSelectField( "ZUSATZ", LanguageManager.getText(LANGUAGE_CONTEXT, "FIELDTABLE_ADDINFO"),singleCheckVector ),
259             allSwitch
260         };
261
262         //======================= SPALTENINFOS =================//
263 //---- Gruppe wird erzeugt mit einer Switchauswahl und einer Checkbox ----//
264 TKFieldGroup switchAndCheckGroup =
265             new TKFieldGroup( TKFieldOption.CLASS_ID, new TKVector( switchAndCheckArray ), LanguageManager.getText(LANGUAGE_CONTEXT, "FIELDTABLE_INFOCOLUMN"));
266
267         //================== ZEILENINFOS =====================/
268 //---- Gruppe wird erzeugt mit einer Switchauswahl und einer Checkbox ----//
269 TKFieldGroup switchAndCheckGroup2 =
270             new TKFieldGroup( TKFieldOption.CLASS_ID, new TKVector( switchAndCheckArray ), LanguageManager.getText(LANGUAGE_CONTEXT, "FIELDTABLE_INFOROW") );
271
272         //========================= TABELLE ==================================//
273 //---- Das Array fuer die Tablle mit allem drum und dran ----//
274 TKBaseField [] tableArray = {
275             new TKInputField( TKFieldTable.NAME_KEY, TKInputField.SMALL_DEFAULT_SIZE, TKInputField.SMALL_DEFAULT_LENGTH, LanguageManager.getText(LANGUAGE_CONTEXT, "FIELDTABLE_NAME"), TKInputField.CHECK_STRING),
276             new TKInputField( TKFieldTable.SHOW_NAME_KEY, TKInputField.LARGE_DEFAULT_SIZE, TKInputField.LARGE_DEFAULT_LENGTH, LanguageManager.getText(LANGUAGE_CONTEXT, "FIELDTABLE_SHOWNAME"), TKInputField.CHECK_STRING),
277             allSwitch,
278             new TKFieldOption( "JANEINSPALTE", switchAndCheckGroup, LanguageManager.getText(LANGUAGE_CONTEXT, "FIELDTABLE_JANEINSPALTE")),
279             new TKFieldOption( "JANEINZEILE", switchAndCheckGroup2, LanguageManager.getText(LANGUAGE_CONTEXT, "FIELDTABLE_JANEINZEILE"))
280         };
281
282
283         //---- Alles, was eine Table haben muss ist da, wenn Feldtabelle ausgewaehlt wird ----//
284 TKFieldGroup tableGroup =
285             new TKFieldGroup( TKFieldTable.CLASS_ID, new TKVector( tableArray ), LanguageManager.getText(LANGUAGE_CONTEXT, TKFieldTable.CLASS_ID) );
286
287
288         return tableGroup;
289     }
290
291
292     /**
293      * Returns the internal representation of this field.
294      *
295      * @return the internal representation of this field.
296      */
297     public Object toData ()
298     {
299         TKHashtable result = (TKHashtable) super.toData();
300
301         //--------------------------------------------//
302 //---- Tabelle contentHash zusammenfuegen ----//
303 //--------------------------------------------//
304 result.put( SUB_TYPE_KEY, getDataOfAlternative( tableEntry ) );
305
306         //--------------------------------------------------//
307 //---- ROW ueber TKFieldOption wiederherstellen ----//
308 //--------------------------------------------------//
309 TKFieldOptionData rowEntryOption = null;
310         result = toDataSubFields(rowEntryOption, rowEntry, result, "row");
311
312         //--------------------------------------------------//
313 //---- COL ueber TKFieldOption wiederherstellen ----//
314 //--------------------------------------------------//
315 TKFieldOptionData colEntryOption = null;
316         result = toDataSubFields(colEntryOption, colEntry, result, "col");
317
318         return result;
319     }
320
321     //*************************************************************************************
322 /**
323      * Hilfsmethode fuer toData()
324      */
325
326     public TKHashtable toDataSubFields(
327         TKFieldOptionData entryOption,
328         TKBaseField rowOrColEntry,
329         TKHashtable result,
330         String rowOrCol)
331     {
332         if(rowOrColEntry != null) {
333             //----------------------------------------------//
334 //---- Das Switch wiederherstellen und in ----//
335 //---- einen Hash fuer dieGruppe packen ----//
336 //----------------------------------------------//
337 TKHashtable groupData = new TKHashtable();
338             groupData.put(
339                 SUB_TYPE_KEY,
340                 new TKFieldSwitchData( rowOrColEntry.getType(), rowOrColEntry.getType(), rowOrColEntry.toData() )
341             );
342             //----------------------------------------------------------//
343 //---- Pulldownmenue wieder herstellen und in den Hash ----//
344 //---- fuer dieGruppe packen ----//
345 //----------------------------------------------------------//
346 if( rowOrCol.equals("row")) {
347                 if(isRowCell )
348                 {
349                     groupData.put(ZUSATZ_KEY, "CELL");
350                 }
351                 else
352                 {
353                     groupData.put(ZUSATZ_KEY, "NOCELL");
354                 }
355             }
356
357             if( rowOrCol.equals("col")) {
358                 if(isColCell)
359                 {
360                     groupData.put(ZUSATZ_KEY, "CELL");
361                 }
362                 else
363                 {
364                     groupData.put(ZUSATZ_KEY, "NOCELL");
365                 }
366             }
367
368             //---------------------------------------------------//
369 //---- Switch-Auswahl wenn yes ausgewaehlt wurde ----//
370 //---------------------------------------------------//
371 entryOption = new TKFieldOptionData( "YES", "YES", groupData );
372         }
373         else {
374             entryOption = new TKFieldOptionData( "NO", "NO", null) ;
375         }
376         if( rowOrCol.equals("row")) result.put( ROW_JANEIN_KEY, entryOption);
377         if( rowOrCol.equals("col")) result.put( COL_JANEIN_KEY, entryOption);
378
379         return result;
380     }
381
382
383     //*************************************************************************************
384 /**
385      * parameter TKHashtable data , enthaelt die Parameter
386      */
387     public Object compileData( String prefix, TKHashtable data, TKHashtable context )
388     {
389         prefix += fieldName+".";
390
391         //-----------------------------------------------------------//
392 //---- Alte Eingabewerte werden in Hiddenfeldern gemerkt ----//
393 //---- und initial auf 1 gesetzt ----//
394 //-----------------------------------------------------------//
395 int rows = Integer.parseInt( (String )data.get(prefix+"ROW"));
396         int cols = Integer.parseInt( (String ) data.get(prefix+"COL"));
397
398         //-----------------------------------------------------------//
399 //---- Data fuer eine ROW mit den Infos des Hiddenfeldes ----//
400 //-----------------------------------------------------------//
401 TKVector rowInfoVector = null;
402         if((rowEntry != null) && (rows > 0)) {
403             rowInfoVector = new TKVector(rows);
404             for( int x=0; x< rows; x++ ) {
405                 rowInfoVector.addElement(rowEntry.compileData( prefix+PRE_ROWS+"."+x+".", data, context ));
406             }
407         }
408
409         //--------------------------------------------------------------//
410 //---- Data fuer eine COLUMN mit den Infos des Hiddenfeldes ----//
411 //--------------------------------------------------------------//
412 TKVector colInfoVector = null;
413         if((colEntry != null) && (cols > 0)) {
414             colInfoVector = new TKVector(cols);
415             for( int x=0; x< cols; x++ ) {
416                 colInfoVector.addElement(colEntry.compileData( prefix+PRE_COLS+"."+x+".", data, context ));
417             }
418         }
419
420         //-------------------------------------------------------------------//
421 //---- Data fuer Zellen der Table mit den Infos des Hiddenfeldes ----//
422 //-------------------------------------------------------------------//
423 TKVector rowsResultVector = (rows == 0) ? null : new TKVector(rows);
424         TKVector colsResultVector = null;
425
426         for( int x=0; x< rows; x++ ) {
427             colsResultVector = new TKVector(cols);
428
429             for( int y=0; y< cols; y++ ) {
430                 colsResultVector.addElement(tableEntry.compileData( prefix+x+"."+y+".", data, context ));
431             }
432             rowsResultVector.addElement(colsResultVector);
433         }
434
435         //-----------------------------------------//
436 //---- Neue Eingabewerte des Benutzers ----//
437 //-----------------------------------------//
438 int newRows = Integer.parseInt( (String ) data.get(prefix+"NEW_ROWS"));
439         int newCols = Integer.parseInt( (String ) data.get(prefix+"NEW_COLS"));
440
441
442         return new TKFieldTableRealData(rowsResultVector, rowInfoVector, colInfoVector, newRows, newCols);
443
444     }
445
446     public Object compileData( String prefix, TKMarkupNode data, TKHashtable context )
447     {
448         TKXmlMarkup markup = data == null ? null : (TKXmlMarkup) data.markup;
449         if (markup == null) { return null;}
450
451         if (!markup.name.equals (getName())) {
452             return null;
453         }
454
455         TKXmlTree tree = (TKXmlTree) data.tree;
456         if (tree == null) { return null;}
457
458         TKVector rowInfoVector = null;
459         TKVector colInfoVector = null;
460         TKVector rowsResultVector = null;
461
462         int newRows = 0;
463         int newCols = 0;
464         int x = 0;
465
466         for (int i = 0; i < tree.size(); i++) {
467
468             Object obj = tree.getSub(i);
469             if (obj == null) continue;
470
471             TKMarkupNode subNode = null;
472             TKXmlMarkup subMarkup = null;
473
474             if (obj instanceof TKXmlMarkup) { // Atomares Markup
475
476                 subMarkup = (TKXmlMarkup) obj;
477
478                 continue;
479
480             } else {
481                 subNode = (TKMarkupNode) obj;
482                 subMarkup = (TKXmlMarkup) subNode.markup;
483             }
484
485             if (subMarkup.name.equals ("CI")) {
486
487                 TKXmlTree subTree = (TKXmlTree) subNode.tree;
488                 if (subTree == null) { continue; }
489
490                 for (int j = 0; j < subTree.size(); j++) {
491
492                     Object subObj = subTree.getSub(j);
493                     if (subObj == null) continue;
494
495                     // TKLog.println ("TKFieldTable.compileData, found ri-obj: "+subObj.getClass().getName());
496
497                     TKMarkupNode subSubNode = null;
498                     TKXmlMarkup subSubMarkup = null;
499
500                     if (subObj instanceof TKXmlMarkup) { // Atomares Markup
501
502                         subSubMarkup = (TKXmlMarkup) subObj;
503                         subSubNode = new TKMarkupNode (subSubMarkup,null);
504
505                     } else {
506                         subSubNode = (TKMarkupNode) subObj;
507                         subSubMarkup = (TKXmlMarkup) subSubNode.markup;
508                     }
509
510                     if (colInfoVector == null) colInfoVector = new TKVector();
511                     colInfoVector.addElement(colEntry.compileData( prefix+j+".", subSubNode, context ));
512                 }
513             }
514
515             else if (subMarkup.name.equals ("TR")) {
516
517                     TKVector colsResultVector = null;
518
519                 TKXmlTree subTree = (TKXmlTree) subNode.tree;
520                 if (subTree == null) { continue; }
521
522                 x++;
523                 if (x >= newRows) newRows = x+1;
524
525                 int y = 0;
526                 for (int j = 0; j < subTree.size(); j++) {
527
528                     Object subObj = subTree.getSub(j);
529                     if (subObj == null) continue;
530
531                     TKMarkupNode subSubNode = null;
532                     TKXmlMarkup subSubMarkup = null;
533
534                     if (subObj instanceof TKXmlMarkup) { // Atomares Markup
535
536                         subSubMarkup = (TKXmlMarkup) subObj;
537                         subSubNode = new TKMarkupNode (subSubMarkup,null);
538
539                     } else {
540                         subSubNode = (TKMarkupNode) subObj;
541                         subSubMarkup = (TKXmlMarkup) subSubNode.markup;
542                     }
543
544                     TKXmlTree subSubTree = (TKXmlTree) subSubNode.tree;
545                     Object subSubObj = subSubTree.getSingleSub();
546                     if (subSubObj == null) continue;
547
548                     TKMarkupNode subSubSubNode = null;
549                     TKXmlMarkup subSubSubMarkup = null;
550
551                     if (subSubObj instanceof TKXmlMarkup) { // Atomares Markup
552
553                         subSubSubMarkup = (TKXmlMarkup) subSubObj;
554                         subSubSubNode = new TKMarkupNode (subSubSubMarkup,null);
555
556                     } else {
557                         subSubSubNode = (TKMarkupNode) subSubObj;
558                         subSubSubMarkup = (TKXmlMarkup) subSubSubNode.markup;
559                     }
560
561                     if (subSubMarkup.name.equals ("RI")) {
562
563                         if (rowInfoVector == null) rowInfoVector = new TKVector();
564                         // TKLog.println ("TKFieldTable added ri: "+subSubSubMarkup.name);
565 rowInfoVector.addElement(rowEntry.compileData( prefix+j+".", subSubSubNode, context ));
566
567
568                     } else {
569
570                         y++;
571                         if (y >= newCols) newCols = y+1;
572
573                         if (rowsResultVector == null) rowsResultVector = new TKVector();
574                         if (colsResultVector == null) {
575
576                             colsResultVector = new TKVector();
577                             rowsResultVector.addElement(colsResultVector);
578                         }
579
580                         colsResultVector.addElement
581                             (tableEntry.compileData( prefix+x+"."+y+".", subSubSubNode, context ));
582                     }
583                 }
584             }
585
586         }
587
588         return new TKFieldTableRealData(rowsResultVector, rowInfoVector, colInfoVector, newRows, newCols);
589     }
590
591     /**
592      * Alle Informationen werden der Methode uebergeben, damit das Template
593      * substituiert werden kann
594      */
595     public void fillIntoTemplate( TKHTMLTemplate t, Object data, String prefix )
596     {
597         TKFieldTableRealData dataClass = (TKFieldTableRealData) data;
598         TKVector dataVector = (TKVector) dataClass.contentData;
599
600         super.fillIntoTemplate( t, data, prefix );
601
602         int rows = ( dataVector == null ? 0 : dataVector.size() );
603         int cols = ( rows == 0 ? 0 : ((TKVector) dataVector.firstElement()).size() );
604
605         t.set("NEW_ROWS", Integer.toString( dataClass.newRowCount ) );
606         t.set("NEW_COLS", Integer.toString( dataClass.newColCount ) );
607
608         t.set("ROW", Integer.toString( rows ));
609         t.set("COL", Integer.toString( cols ));
610
611         if( (TKVector)dataClass.rowData != null )
612                 t.set("IS_COLFORINFOS", Boolean.TRUE);
613
614         if( (TKVector)dataClass.colData != null )
615                 t.set("IS_ROWFORINFOS", Boolean.TRUE);
616
617         if(dataVector != null)
618             t.set("IS_OUTERLIST", Boolean.TRUE);
619         t.setListIterator( new TKFieldTableIterator(
620             dataClass,
621             tableEntry,
622             rowEntry,
623             colEntry,
624             prefix+fieldName+".",
625             t.getListIterator(),
626             "FIELDTABLEROW",
627             "FIELDTABLECOL",
628             "ROWFORINFOLIST"
629         ) );
630     }
631
632     public void fillIntoDOM(Document doc, Element node, Object data) throws DOMException
633     {
634         Element me = doc.createElement(getInternationalName());
635         node.appendChild(me);
636         fillAttributesIntoNode(me, data);
637         TKFieldTableRealData dataClass = (TKFieldTableRealData) data;
638         TKVector dataVector = (TKVector) dataClass.contentData;
639
640         if (dataVector == null)
641         {
642             me.setAttribute("ROWSIZE", String.valueOf( 0 ) );
643             me.setAttribute("COLSIZE", String.valueOf( 0 ) );
644         } else
645         {
646             me.setAttribute("ROWSIZE", String.valueOf( dataVector.size() ) );
647             me.setAttribute("COLSIZE", String.valueOf( ((TKVector)dataVector.firstElement()).size() ) );
648         }
649
650         //---- tabellenlayout ----//
651 if( (TKVector)dataClass.rowData != null )
652                 me.setAttribute("IS_ROWENTRY", Boolean.TRUE.toString());
653
654         if( (TKVector)dataClass.colData != null )
655                 me.setAttribute("IS_COLENTRY", Boolean.TRUE.toString());
656
657         if(dataVector != null)
658             me.setAttribute("IS_OUTERLIST", Boolean.TRUE.toString());
659
660         //--- Ueberschrift ----//
661 if(isRowCell == false)
662             me.setAttribute("HEADERROW", Boolean.TRUE.toString());
663         if(isColCell == false)
664             me.setAttribute("HEADERCOL", Boolean.TRUE.toString());
665         if (dataVector != null)
666         {
667             for (int i = 0; i < dataVector.size(); i++)
668             {
669                 TKVector zeile = (TKVector)dataVector.elementAt(i);
670                 // Zeilen Element
671 Element z = doc.createElement(getName() + "_Row" + i);
672                 me.appendChild(z);
673                 // Zellen einfuegen
674 for (int j = 0; j < zeile.size(); j++)
675                 {
676                     Object fieldData = zeile.elementAt(j);
677                     tableEntry.fillIntoDOM(doc, z, fieldData);
678                 }
679             }
680         }
681         // NICHT FERTIG !
682 /*
683         if (dataVector != null)
684         t.setListIterator( new TKTableShowIterator(
685             dataClass,
686             tableEntry,
687             rowEntry,
688             colEntry,
689             scope,
690             getName(),
691             t.getListIterator(),
692             "OUTERLIST",
693             "INNERLIST",
694             "ROWFORINFOLIST"
695         ) );*/
696
697     }
698
699     public void fillIntoPresentation( TKHTMLTemplate t, Object data, String scope )
700     {
701         TKFieldTableRealData dataClass = (TKFieldTableRealData) data;
702         TKVector dataVector = (TKVector) dataClass.contentData;
703
704         if (dataVector == null)
705         {
706             t.set(scope+"."+getName()+".ROWSIZE", String.valueOf( 0 ) );
707             t.set(scope+"."+getName()+".COLSIZE", String.valueOf( 0 ) );
708
709         } else
710         {
711             t.set(scope+"."+getName()+".ROWSIZE", String.valueOf( dataVector.size() ) );
712             t.set(scope+"."+getName()+".COLSIZE", String.valueOf( ((TKVector)dataVector.firstElement()).size() ) );
713         }
714
715         //---- tabellenlayout ----//
716 if( dataClass.rowData != null )
717                 t.set("IS_ROWENTRY", Boolean.TRUE);
718
719         if( dataClass.colData != null )
720                 t.set("IS_COLENTRY", Boolean.TRUE);
721
722         if (dataVector != null) t.set("IS_OUTERLIST", Boolean.TRUE);
723
724         //--- Ueberschrift ----//
725 if (isRowCell == false) t.set("HEADERROW", Boolean.TRUE);
726         if (isColCell == false) t.set("HEADERCOL", Boolean.TRUE);
727
728         if (dataVector != null)
729         t.setListIterator( new TKTableShowIterator(
730             dataClass,
731             tableEntry,
732             rowEntry,
733             colEntry,
734             scope,
735             getName(),
736             t.getListIterator(),
737             "OUTERLIST",
738             "INNERLIST",
739             "ROWFORINFOLIST"
740         ) );
741
742     }
743
744     /**
745      * Die Klasse, die die Daten der Tabelle haelt wird initial auf die
746      * defaultwerte gesetzt
747      */
748     public Object getDefault()
749     {
750         //return rowVector;
751 return new TKFieldTableRealData(null, null, null, 1, 1);
752     }
753
754     /**
755      * Eine bestehende Tabelle wird veraendert
756      */
757     public Object modify( String action, String fieldPath, Object data, String prefix, StringBuffer destination )
758     {
759         TKFieldTableRealData dataClass = (TKFieldTableRealData) data;
760
761         int pLength = prefix.length()+fieldName.length();
762         int fpLength = fieldPath.length();
763         //--------------------------------//
764 //---- Action betrifft Table ----//
765 //--------------------------------//
766 if(fpLength == pLength) {
767
768             if( action.equals("MODIFY") ) {
769                 destination.append( prefix+fieldName );
770
771                 int rowCount = (dataClass.contentData == null ? 0 : dataClass.contentData.size() );
772                 int colCount = 0;
773                 if( rowCount == 0 ) {
774                     if( dataClass.newRowCount == 0 || dataClass.newColCount == 0) {
775                         return data;
776                     }
777                     dataClass.contentData = new TKVector( dataClass.newColCount );
778                 }
779                 else {
780                     colCount = ((TKVector) dataClass.contentData.firstElement()).size();
781                 }
782
783                 if( colEntry != null ) {
784                     if( dataClass.colData == null ) {
785                         dataClass.colData = new TKVector( dataClass.newColCount );
786                     }
787                     if( colCount < dataClass.newColCount ) {
788                         for( int i=colCount; i<dataClass.newColCount; i++ ) {
789                             dataClass.colData.addElement( colEntry.getDefault() );
790                         }
791                     }
792                     else {
793                         for( int i=dataClass.newColCount; i<colCount; i++ ) {
794                             dataClass.colData.removeElementAt( dataClass.newColCount );
795                         }
796                     }
797                 }
798
799                 if( rowEntry != null ) {
800                     if( dataClass.rowData == null ) {
801                         dataClass.rowData = new TKVector( dataClass.newRowCount );
802                     }
803                     if( rowCount < dataClass.newRowCount ) {
804                         for( int i=rowCount; i<dataClass.newRowCount; i++ ) {
805                             dataClass.rowData.addElement( rowEntry.getDefault() );
806                         }
807                     }
808                     else {
809                         for( int i=dataClass.newRowCount; i<rowCount; i++ ) {
810                             dataClass.rowData.removeElementAt( dataClass.newRowCount );
811                         }
812                     }
813                 }
814
815                 if( rowCount < dataClass.newRowCount ) {
816                     if( colCount < dataClass.newColCount ) {
817                         for( int i=0; i<rowCount; i++ ) {
818                             TKVector currRow = (TKVector) dataClass.contentData.get(i);
819                             for( int j=colCount; j<dataClass.newColCount; j++ )
820                                 currRow.addElement( tableEntry.getDefault() );
821                         }
822                     }
823                     else {
824                         for( int i=0; i<rowCount; i++ ) {
825                             TKVector currRow = (TKVector) dataClass.contentData.get(i);
826                             for( int j=dataClass.newColCount; j<colCount; j++ )
827                                 currRow.removeElementAt( dataClass.newColCount );
828                         }
829                     }
830                     for( int i=rowCount; i<dataClass.newRowCount; i++ ) {
831                         TKVector newRow = new TKVector( dataClass.newColCount );
832                         for( int j=0; j<dataClass.newColCount; j++ ) {
833                             newRow.addElement( tableEntry.getDefault() );
834                         }
835                         dataClass.contentData.addElement( newRow );
836                     }
837                 }
838                 else { //weniger Zeilen in neuer Tabelle
839 for( int i=dataClass.newRowCount; i<rowCount; i++ ) {
840                         dataClass.contentData.removeElementAt( dataClass.newRowCount );
841                     }
842                     if( colCount < dataClass.newColCount ) {
843                         for( int i=0; i<dataClass.newRowCount; i++ ) {
844                             TKVector currRow = (TKVector) dataClass.contentData.get(i);
845                             for( int j=colCount; j<dataClass.newColCount; j++ )
846                                 currRow.addElement( tableEntry.getDefault() );
847                         }
848                     }
849                     else {
850                         for( int i=0; i<dataClass.newRowCount; i++ ) {
851                             TKVector currRow = (TKVector) dataClass.contentData.get(i);
852                             for( int j=dataClass.newColCount; j<colCount; j++ )
853                                 currRow.removeElementAt( dataClass.newColCount );
854                         }
855                     }
856                 }
857             }
858             //---- Falls nix mehr da ----//
859 if(dataClass.contentData.isEmpty())
860             data = this.getDefault();
861
862         }
863         //----------------------------------------------------------//
864 //---- Action betrifft eine Zeile/Spalte der Tabelle -------//
865 //----------------------------------------------------------//
866 // FALSCH !!! (singh 6.4.00): else if(fieldPath.lastIndexOf('.',fpLength-4) == pLength) {
867 else if(fieldPath.lastIndexOf('.',fieldPath.lastIndexOf('.',fpLength-2)-1) == pLength) {
868
869             int rowIdx = 0;
870             int colIdx = 0;
871             String subPath = fieldPath.substring( pLength+1 );
872
873             //---- "MODIFYROW" im fieldPath ----//
874 StringTokenizer getTokenModify = new StringTokenizer ( subPath, ".");
875             if( (getTokenModify.nextElement()).equals(MODIFY_ROW)) {
876                 String subPathModify = fieldPath.substring( pLength+1+9 );
877                 StringTokenizer getToken = new StringTokenizer ( subPathModify, ".");
878                 rowIdx = Integer.parseInt( (String )getToken.nextElement() );
879
880             }
881             else {
882                 StringTokenizer getToken = new StringTokenizer ( subPath, ".");
883                 rowIdx = Integer.parseInt( (String )getToken.nextElement() );
884                 colIdx = Integer.parseInt( (String )getToken.nextElement() );
885             }
886             //------------------------//
887 //---- Modify Spalten ----//
888 //------------------------//
889 if( action.equals("DELETE_COL") ) {
890                 destination.append( prefix+fieldName+"."+MODIFY_ROW+"."+rowIdx+".");
891                 data = deleteRowOrCol(action, dataClass, rowIdx, colIdx);
892             }
893
894             if( action.equals("INSERT_COL") ) {
895                 destination.append( prefix+fieldName+"."+MODIFY_ROW+"."+rowIdx+".");
896                 data = insertRowOrCol(action, dataClass, rowIdx, colIdx);
897             }
898             if( colIdx != 0) {
899                 if( action.equals("FIRST_COL") ) {
900                     destination.append( prefix+fieldName+"."+MODIFY_ROW+"."+rowIdx+".");
901                     dataClass = (TKFieldTableRealData) firstRowOrCol(action, dataClass, rowIdx, colIdx);
902                     data = deleteRowOrCol("DELETE_COL", dataClass, rowIdx, colIdx+1);
903
904                 }
905                 if( action.equals("BACK_COL") ) {
906                     destination.append( prefix+fieldName+"."+MODIFY_ROW+"."+rowIdx+".");
907                     dataClass = (TKFieldTableRealData) backRowOrCol(action, dataClass, rowIdx, colIdx);
908                     data = deleteRowOrCol("DELETE_COL", dataClass, rowIdx, colIdx+1);
909                 }
910             }
911             else {
912                 if( action.equals("BACK_COL") )
913                     destination.append( prefix+fieldName+"."+MODIFY_ROW+"."+rowIdx+".");
914             }
915
916             if( (rowIdx != dataClass.contentData.size()-1) &&
917                 (colIdx != ( (TKVector) dataClass.contentData.firstElement() ).size()-1 ) )
918             {
919                 if( action.equals("LAST_COL") ) {
920                     destination.append( prefix+fieldName+"."+MODIFY_ROW+"."+rowIdx+".");
921                     dataClass = (TKFieldTableRealData) lastRowOrCol(action, dataClass, rowIdx, colIdx);
922                     data = deleteRowOrCol("DELETE_COL", dataClass, rowIdx, colIdx);
923             }
924                 if( action.equals("FORWARD_COL") ) {
925                     destination.append( prefix+fieldName+"."+MODIFY_ROW+"."+rowIdx+".");
926                     dataClass = (TKFieldTableRealData) forwardRowOrCol(action, dataClass, rowIdx, colIdx);
927                     data = deleteRowOrCol("DELETE_COL", dataClass, rowIdx, colIdx);
928                 }
929             }
930             else {
931                 if( action.equals("FORWARD_COL") )
932                     destination.append( prefix+fieldName+"."+MODIFY_ROW+"."+rowIdx+".");
933             }
934             //------------------------//
935 //---- Modify Zeien ----//
936 //------------------------//
937 if( action.equals("DELETE_ROW") ) {
938                 if(rowIdx == 0)
939                     destination.append( prefix+fieldName+"."+MODIFY_ROW+"."+rowIdx+".");
940                 else
941                     destination.append( prefix+fieldName+"."+MODIFY_ROW+"."+(rowIdx-1)+".");
942                 data = deleteRowOrCol(action, dataClass, rowIdx, 0);
943             }
944
945             if( action.equals("INSERT_ROW") ) {
946                 destination.append( prefix+fieldName+"."+MODIFY_ROW+"."+rowIdx+".");
947                 data = insertRowOrCol(action, dataClass, rowIdx, 0);
948             }
949             if(rowIdx != 0) {
950                 if( action.equals("FIRST_ROW") ) {
951                     destination.append( prefix+fieldName+"."+MODIFY_ROW+"."+0+".");
952                     dataClass = (TKFieldTableRealData) firstRowOrCol(action, dataClass, rowIdx, 0);
953                     data = deleteRowOrCol("DELETE_ROW", dataClass, rowIdx+1, 0);
954             }
955                 if( action.equals("BACK_ROW") ) {
956                     destination.append( prefix+fieldName+"."+MODIFY_ROW+"."+(rowIdx-1)+".");
957                     dataClass = (TKFieldTableRealData) backRowOrCol(action, dataClass, rowIdx, 0);
958                     data = deleteRowOrCol("DELETE_ROW", dataClass, rowIdx+1, 0);
959                 }
960             }
961             else {
962                 if( action.equals("BACK_ROW") )
963                     destination.append( prefix+fieldName+"."+MODIFY_ROW+"."+0+".");
964             }
965
966             if( (rowIdx != dataClass.contentData.size()-1) )
967             {
968
969                 if( action.equals("LAST_ROW") ) {
970                     int newRowIdx = ( (TKVector) dataClass.contentData.firstElement()).size()-1;
971                     destination.append( prefix+fieldName+"."+MODIFY_ROW+"."+newRowIdx+".");
972                     dataClass = (TKFieldTableRealData) lastRowOrCol(action, dataClass, rowIdx, 0);
973                     data = deleteRowOrCol("DELETE_ROW", dataClass, rowIdx, 0);
974                 }
975                 if( action.equals("FORWARD_ROW") ) {
976
977                     destination.append( prefix+fieldName+"."+MODIFY_ROW+"."+(rowIdx+1)+".");
978                     dataClass = (TKFieldTableRealData) forwardRowOrCol(action, dataClass, rowIdx, 0);
979                     data = deleteRowOrCol("DELETE_ROW", dataClass, rowIdx, 0);
980                 }
981             }
982             else {
983                 if( action.equals("FORWARD_ROW") )
984                     destination.append( prefix+fieldName+"."+MODIFY_ROW+"."+rowIdx+".");
985             }
986
987         }
988
989         //----------------------------------------------------------//
990 //---- Action betrifft Subelement Auswahl des Elementes ----//
991 //----------------------------------------------------------//
992 else {
993             String subPath = fieldPath.substring( pLength+1 );
994
995             //---- modify des SubElementes in einer ZusatzRow ----//
996 if( subPath.startsWith( PRE_ROWS ) ) {
997                 subPath = subPath.substring( PRE_ROWS.length()+1 );
998                 int idxEnd = subPath.indexOf('.');
999                 String idxStr = subPath.substring( 0, idxEnd );
1000                int idx = Integer.parseInt( idxStr );
1001
1002                dataClass.rowData.put( idx, rowEntry.modify(
1003                    action, fieldPath, dataClass.rowData.get( idx ),
1004                    prefix+fieldName+'.'+PRE_ROWS+"."+idx+'.', destination
1005                ) );
1006            }
1007            //---- modify des SubElementes in einer ZusatzCol ----//
1008 else if( subPath.startsWith( PRE_COLS ) ) {
1009                subPath = subPath.substring( PRE_COLS.length()+1 );
1010                int idxEnd = subPath.indexOf('.');
1011                String idxStr = subPath.substring( 0, idxEnd );
1012                int idx = Integer.parseInt( idxStr );
1013                dataClass.colData.put( idx, colEntry.modify(
1014                    action, fieldPath, dataClass.colData.get( idx ),
1015                    prefix+fieldName+'.'+PRE_COLS+"."+idx+'.',
1016                    destination
1017                ) );
1018            }
1019            else {
1020                //---- modify des SubElementes in einer Zelle ----//
1021 StringTokenizer getToken = new StringTokenizer ( subPath, ".");
1022                int rowIdx = Integer.parseInt( (String )getToken.nextElement() );
1023                int colIdx = Integer.parseInt( (String )getToken.nextElement() );
1024
1025                TKVector colVector = (TKVector) dataClass.contentData.elementAt(rowIdx);
1026                colVector.put(colIdx, tableEntry.modify(
1027                    action, fieldPath, colVector.get(colIdx),
1028                    prefix+fieldName+"."+rowIdx+"."+colIdx+".", destination
1029                ) );
1030            }
1031        }
1032        return data;
1033    }
1034
1035
1036    //***************************************************************
1037 public TKBaseField getTarget(String fieldPath, String prefix)
1038    {
1039        TKBaseField targetField = null;
1040        int pLength = prefix.length()+fieldName.length();
1041        int fpLength = fieldPath.length();
1042
1043        String subPath = fieldPath.substring( pLength+1 );
1044
1045        //-------------------------------------//
1046 //---- action betrifft Sub-ELement ----//
1047 //-------------------------------------//
1048 if ( (fieldPath.length() != pLength) && (fieldPath.lastIndexOf('.',fpLength-4) != pLength) ) {
1049
1050            //---- modify des SubElementes in einer ZusatzRow ----//
1051 if( subPath.startsWith( PRE_ROWS ) ) {
1052                subPath = subPath.substring( PRE_ROWS.length()+1 );
1053                int idxEnd = subPath.indexOf('.');
1054                String idxStr = subPath.substring( 0, idxEnd );
1055                int idx = Integer.parseInt( idxStr );
1056
1057                targetField = rowEntry.getTarget(fieldPath, prefix+fieldName+'.'+PRE_ROWS+"."+idx+'.');
1058
1059            }
1060            //---- modify des SubElementes in einer ZusatzCol ----//
1061 else if( subPath.startsWith( PRE_COLS ) ) {
1062                subPath = subPath.substring( PRE_COLS.length()+1 );
1063                int idxEnd = subPath.indexOf('.');
1064                String idxStr = subPath.substring( 0, idxEnd );
1065                int idx = Integer.parseInt( idxStr );
1066
1067                targetField = colEntry.getTarget(fieldPath, prefix+fieldName+'.'+PRE_COLS+"."+idx+'.');
1068
1069            }
1070            //---- modify des SubElementes in einer Zelle ----//
1071 else {
1072                StringTokenizer getToken = new StringTokenizer (subPath, ".");
1073                int rowIdx = Integer.parseInt( (String ) getToken.nextElement() );
1074                int colIdx = Integer.parseInt( (String ) getToken.nextElement() );
1075
1076                targetField = tableEntry.getTarget(fieldPath, prefix+fieldName+"."+rowIdx+"."+colIdx+".");
1077            }
1078        }
1079
1080        return targetField;
1081    }
1082
1083
1084    //*************************************************************************************
1085 /**
1086     *
1087     */
1088    public Object deleteRowOrCol(
1089        String action,
1090        TKFieldTableRealData dataClass,
1091        int rowIdx,
1092        int colIdx)
1093    {
1094        //---------------------------------------//
1095 //---- Delete Element from ZusatzRow ----//
1096 //---------------------------------------//
1097 if( (rowEntry != null) && (action.equals("DELETE_ROW")) ) {
1098            dataClass.rowData.removeElementAt(rowIdx);
1099        }
1100
1101        //---------------------------------------//
1102 //---- Delete Element from ZusatzCol ----//
1103 //---------------------------------------//
1104 if( (colEntry != null) && (action.equals("DELETE_COL")) ) {
1105            dataClass.colData.removeElementAt(colIdx);
1106        }
1107
1108        //----------------------------------//
1109 //---- Delete Zeile from Table ----//
1110 //---------------------------------//
1111 if( action.equals("DELETE_ROW") ) {
1112            dataClass.contentData.removeElementAt(rowIdx);
1113        }
1114        //----------------------------------//
1115 //---- Delete Spalte from Table ----//
1116 //----------------------------------//
1117 if( action.equals("DELETE_COL") ) {
1118            for(int x=0; x < dataClass.contentData.size(); x++) {
1119                for(int y=0; y < ( (TKVector)dataClass.contentData.elementAt(x) ).size(); y++) {
1120                    if(y == colIdx) {
1121                        ( (TKVector)dataClass.contentData.elementAt(x) ).removeElementAt(y);
1122                    }
1123                }
1124            }
1125        }
1126
1127        //---- Falls nix mehr da ----//
1128 if( dataClass.contentData.isEmpty()) {
1129            return this.getDefault();
1130        }
1131        else if( ((TKVector)dataClass.contentData.firstElement()).isEmpty() ) {
1132            return this.getDefault();
1133        }
1134
1135
1136        return dataClass;
1137    }
1138
1139    /**
1140     *
1141     */
1142    public Object insertRowOrCol(
1143        String action,
1144        TKFieldTableRealData dataClass,
1145        int rowIdx,
1146        int colIdx)
1147    {
1148        //---------------------------------------//
1149 //---- Insert Element in ZusatzRow ----//
1150 //---------------------------------------//
1151 if( (rowEntry != null) && (action.equals("INSERT_ROW")) ) {
1152            dataClass.rowData.insertElementAt(rowEntry.getDefault(), rowIdx);
1153        }
1154
1155        //---------------------------------------//
1156 //---- Insert Element in ZusatzCol ----//
1157 //---------------------------------------//
1158 if( (colEntry != null) && (action.equals("INSERT_COL")) ) {
1159            dataClass.colData.insertElementAt(colEntry.getDefault(), colIdx);
1160        }
1161
1162        //----------------------------------//
1163 //---- Insert Zeile in Table ----//
1164 //---------------------------------//
1165 if( action.equals("INSERT_ROW") ) {
1166            TKVector insertVector = new TKVector();
1167            for(int x=0; x < ( (TKVector) dataClass.contentData.firstElement()).size(); x++) {
1168                insertVector.addElement(tableEntry.getDefault());
1169            }
1170            dataClass.contentData.insertElementAt(insertVector, rowIdx);
1171        }
1172        //----------------------------------//
1173 //---- Insert Spalte in Table ----//
1174 //----------------------------------//
1175 if( action.equals("INSERT_COL") ) {
1176            for(int x=0; x < dataClass.contentData.size(); x++) {
1177                for(int y=0; y < ( (TKVector)dataClass.contentData.elementAt(x) ).size(); y++) {
1178                    if(y == colIdx) {
1179                        ( (TKVector)dataClass.contentData.elementAt(x) ).insertElementAt(tableEntry.getDefault(), y);
1180                    }
1181
1182                }
1183            }
1184        }
1185
1186        return dataClass;
1187    }
1188
1189    /**
1190     * Move Row Or Col to first Position
1191     */
1192    public Object firstRowOrCol(
1193        String action,
1194        TKFieldTableRealData dataClass,
1195        int rowIdx,
1196        int colIdx)
1197    {
1198        //---- Die erste Position bleibt die erste ----//
1199 //if( (action.equals("FIRST_ROW")) && (rowIdx == 0) ) return dataClass;
1200 //if( (action.equals("FIRST_COL")) && (colIdx == 0) ) return dataClass;
1201
1202        //---------------------------------------//
1203 //---- Insert Element in ZusatzRow ----//
1204 //---------------------------------------//
1205 if( (rowEntry != null) && (action.equals("FIRST_ROW")) ) {
1206            Object merkeElement = null;
1207            for(int x = 0; x < dataClass.rowData.size(); x++) {
1208                if(x == rowIdx) merkeElement = dataClass.rowData.elementAt(x);
1209            }
1210            dataClass.rowData.insertElementAt(merkeElement, 0);
1211        }
1212
1213        //---------------------------------------//
1214 //---- Insert Element in ZusatzCol ----//
1215 //---------------------------------------//
1216 if( (colEntry != null) && (action.equals("FIRST_COL")) ) {
1217            Object merkeElement = null;
1218            for(int x = 0; x < dataClass.colData.size(); x++) {
1219                if(x == colIdx) merkeElement = dataClass.colData.elementAt(x);
1220            }
1221            dataClass.colData.insertElementAt(merkeElement, 0);
1222        }
1223
1224        //----------------------------------//
1225 //---- Insert Zeile in Table ----//
1226 //---------------------------------//
1227 if( action.equals("FIRST_ROW") ) {
1228
1229            TKVector merkeRow = null;
1230            //for(int x=0; x < ( (TKVector) dataClass.contentData.firstElement()).size(); x++) {
1231 for(int x=0; x < ( (TKVector) dataClass.contentData).size(); x++) {
1232                if(x == rowIdx) {
1233                    merkeRow = (TKVector) dataClass.contentData.elementAt(x);
1234                }
1235            }
1236
1237            dataClass.contentData.insertElementAt(merkeRow, 0);
1238
1239        }
1240        //----------------------------------//
1241 //---- Insert Spalte in Table ----//
1242 //----------------------------------//
1243 if( action.equals("FIRST_COL") ) {
1244            TKVector merkeCol = new TKVector();
1245            for(int x=0; x < dataClass.contentData.size(); x++) {
1246                for(int y=0; y < ( (TKVector)dataClass.contentData.elementAt(x) ).size(); y++) {
1247                    if(y == colIdx) {
1248                        merkeCol.addElement(( (TKVector)dataClass.contentData.elementAt(x) ).elementAt(y));
1249                    }
1250                }
1251            }
1252            for(int x=0; x < dataClass.contentData.size(); x++) {
1253                for(int y=0; y < ( (TKVector)dataClass.contentData.elementAt(x) ).size(); y++) {
1254                    if(y == 0) {
1255                        ( (TKVector)dataClass.contentData.elementAt(x) ).insertElementAt(merkeCol.elementAt(x), y);
1256                    }
1257
1258                }
1259            }
1260        }
1261
1262        return dataClass;
1263    }
1264
1265    //*************************************************************************************
1266 /**
1267     * Move Row Or Col to last Position
1268     */
1269    public Object lastRowOrCol(
1270        String action,
1271        TKFieldTableRealData dataClass,
1272        int rowIdx,
1273        int colIdx)
1274    {
1275        //---------------------------------------//
1276 //---- Element in ZusatzRow ----//
1277 //---------------------------------------//
1278 if( (rowEntry != null) && (action.equals("LAST_ROW")) ) {
1279            Object merkeElement = null;
1280            for(int x = 0; x < dataClass.rowData.size(); x++) {
1281                if(x == rowIdx) merkeElement = dataClass.rowData.elementAt(x);
1282            }
1283            dataClass.rowData.addElement(merkeElement);
1284        }
1285
1286        //---------------------------------------//
1287 //---- Element in ZusatzCol ----//
1288 //---------------------------------------//
1289 if( (colEntry != null) && (action.equals("LAST_COL")) ) {
1290            Object merkeElement = null;
1291            for(int x = 0; x < dataClass.colData.size(); x++) {
1292                if(x == colIdx) merkeElement = dataClass.colData.elementAt(x);
1293            }
1294            dataClass.colData.addElement(merkeElement);
1295        }
1296
1297        //----------------------------------//
1298 //---- Zeile in Table ----//
1299 //---------------------------------//
1300 if( action.equals("LAST_ROW") ) {
1301
1302            TKVector merkeRow = null;
1303            for(int x=0; x < ( (TKVector) dataClass.contentData.firstElement()).size(); x++) {
1304                if(x == rowIdx) {
1305                    merkeRow = (TKVector) dataClass.contentData.elementAt(x);
1306                }
1307            }
1308            dataClass.contentData.addElement(merkeRow);
1309
1310        }
1311        //----------------------------------//
1312 //---- Spalte in Table ----//
1313 //----------------------------------//
1314 if( action.equals("LAST_COL") ) {
1315            TKVector merkeCol = new TKVector();
1316            for(int x=0; x < dataClass.contentData.size(); x++) {
1317                for(int y=0; y < ( (TKVector)dataClass.contentData.elementAt(x) ).size(); y++) {
1318                    if(y == colIdx) {
1319                        merkeCol.addElement(( (TKVector)dataClass.contentData.elementAt(x) ).elementAt(y));
1320                    }
1321                }
1322            }
1323
1324            for(int x=0; x < dataClass.contentData.size(); x++) {
1325                ((TKVector)dataClass.contentData.elementAt(x)).addElement(merkeCol.elementAt(x));
1326            }
1327        }
1328        return dataClass;
1329    }
1330
1331    //*************************************************************************************
1332 /**
1333     * Move Row Or Col um eine Position nach unten bzw. nachr echts
1334     */
1335    public Object forwardRowOrCol(
1336        String action,
1337        TKFieldTableRealData dataClass,
1338        int rowIdx,
1339        int colIdx)
1340    {
1341        //---------------------------------------//
1342 //---- Element in ZusatzRow ----//
1343 //---------------------------------------//
1344 if( (rowEntry != null) && (action.equals("FORWARD_ROW")) ) {
1345            Object merkeElement = null;
1346            for(int x = 0; x < dataClass.rowData.size(); x++) {
1347                if(x == rowIdx) merkeElement = dataClass.rowData.elementAt(x);
1348            }
1349            dataClass.rowData.insertElementAt(merkeElement, rowIdx+2);
1350        }
1351
1352        //---------------------------------------//
1353 //---- Element in ZusatzCol ----//
1354 //---------------------------------------//
1355 if( (colEntry != null) && (action.equals("FORWARD_COL")) ) {
1356            Object merkeElement = null;
1357            for(int x = 0; x < dataClass.colData.size(); x++) {
1358                if(x == colIdx) merkeElement = dataClass.colData.elementAt(x);
1359            }
1360            dataClass.colData.insertElementAt(merkeElement, colIdx+2);
1361        }
1362
1363        //----------------------------------//
1364 //---- Zeile in Table ----//
1365 //---------------------------------//
1366 if( action.equals("FORWARD_ROW") ) {
1367            TKVector merkeRow = null;
1368            //for(int x=0; x < ( (TKVector) dataClass.contentData.firstElement()).size(); x++) {
1369 for(int x=0; x < ( (TKVector) dataClass.contentData).size(); x++) {
1370                if(x == rowIdx) {
1371                    merkeRow = (TKVector) dataClass.contentData.elementAt(x);
1372                }
1373            }
1374            dataClass.contentData.insertElementAt(merkeRow, rowIdx+2);
1375
1376        }
1377        //----------------------------------//
1378 //---- Spalte in Table ----//
1379 //----------------------------------//
1380 if( action.equals("FORWARD_COL") ) {
1381            TKVector merkeCol = new TKVector();
1382            for(int x=0; x < dataClass.contentData.size(); x++) {
1383                for(int y=0; y < ( (TKVector)dataClass.contentData.elementAt(x) ).size(); y++) {
1384                    if(y == colIdx) {
1385                        merkeCol.addElement(( (TKVector)dataClass.contentData.elementAt(x) ).elementAt(y));
1386                    }
1387                }
1388            }
1389
1390            for(int x=0; x < dataClass.contentData.size(); x++) {
1391                ((TKVector)dataClass.contentData.elementAt(x)).insertElementAt(merkeCol.elementAt(x), colIdx+2);
1392            }
1393        }
1394        return dataClass;
1395    }
1396
1397    //*************************************************************************************
1398 /**
1399     * Move Row Or Col um eine Position nach oben bzw. nach links
1400     */
1401    public Object backRowOrCol(
1402        String action,
1403        TKFieldTableRealData dataClass,
1404        int rowIdx,
1405        int colIdx)
1406    {
1407        //---------------------------------------//
1408 //---- Element in ZusatzRow ----//
1409 //---------------------------------------//
1410 if( (rowEntry != null) && (action.equals("BACK_ROW")) ) {
1411            Object merkeElement = null;
1412            for(int x = 0; x < dataClass.rowData.size(); x++) {
1413                if(x == rowIdx) merkeElement = dataClass.rowData.elementAt(x);
1414            }
1415            dataClass.rowData.insertElementAt(merkeElement, rowIdx-1);
1416        }
1417
1418        //---------------------------------------//
1419 //---- Element in ZusatzCol ----//
1420 //---------------------------------------//
1421 if( (colEntry != null) && (action.equals("BACK_COL")) ) {
1422            Object merkeElement = null;
1423            for(int x = 0; x < dataClass.colData.size(); x++) {
1424                if(x == colIdx) merkeElement = dataClass.colData.elementAt(x);
1425            }
1426            dataClass.colData.insertElementAt(merkeElement, colIdx-1);
1427        }
1428
1429        //----------------------------------//
1430 //---- Zeile in Table ----//
1431 //---------------------------------//
1432 if( action.equals("BACK_ROW") ) {
1433            TKVector merkeRow = null;
1434
1435            //for(int x=0; x < ( (TKVector) dataClass.contentData.firstElement()).size(); x++) {
1436 for(int x=0; x < ( (TKVector) dataClass.contentData).size(); x++) {
1437                if(x == rowIdx) {
1438                    merkeRow = (TKVector) dataClass.contentData.elementAt(x);
1439                }
1440            }
1441            dataClass.contentData.insertElementAt(merkeRow, rowIdx-1);
1442
1443        }
1444        //----------------------------------//
1445 //---- Spalte in Table ----//
1446 //----------------------------------//
1447 if( action.equals("BACK_COL") ) {
1448            TKVector merkeCol = new TKVector();
1449            for(int x=0; x < dataClass.contentData.size(); x++) {
1450                for(int y=0; y < ( (TKVector)dataClass.contentData.elementAt(x) ).size(); y++) {
1451                    if(y == colIdx) {
1452                        merkeCol.addElement(( (TKVector)dataClass.contentData.elementAt(x) ).elementAt(y));
1453                    }
1454                }
1455            }
1456
1457            for(int x=0; x < dataClass.contentData.size(); x++) {
1458                ((TKVector)dataClass.contentData.elementAt(x)).insertElementAt(merkeCol.elementAt(x), colIdx-1);
1459            }
1460        }
1461        return dataClass;
1462    }
1463
1464
1465    /**
1466     * Die Daten des Objekts werden in einer Uebergangsstruktur angelegt,
1467     * damit diese in die DB eingetragen werden kann. Die Daten des Subelementes
1468     * (optionData.data) in der entsprechenden Methode insertDataIntoDB in die
1469     * Uebergangsstruktur gelegt.
1470     */
1471    public int insertDataIntoDB( TKContentDBData db, Object data, int contentId, int leftNr )
1472    {
1473        TKFieldTableRealData tableData = (TKFieldTableRealData) data;
1474        //----------------------------------------------------------------------//
1475 //---- Ein Knoten wird gesetzt, TKFieldOption kann nur einen haben ----//
1476 //---- Das Objekt node haelt alle noetigen Infos fuer die Struktur: ----//
1477 //---- CONTENT_ID, CONTENT_NODE_ID, LEFT_NR, RIGHT_NR,NAME ----//
1478 //---- Intern wird die RIGHT_NR = LEFT_NR+1 gesetzt ----//
1479 //----------------------------------------------------------------------//
1480 TKContentNodeTableData node = insertNewContentNode( db, contentId, leftNr );
1481        int newNodeId = node.content_node_id;
1482
1483        //------------------------------------------------------//
1484 //---- grundlegende Infos zur Tabelle ----//
1485 //---- (leider, Attribute werden in real gesetzt) ----//
1486 //---- 1. Anzahl der rows der Tabelle ----//
1487 //---- 2. Anzahl der cols der Tabelle ----//
1488 //---- 3. Zusatzrow ----//
1489 //---- 4. Zusatzcol ----//
1490 //------------------------------------------------------//
1491 TKVector firstDataRow = null;
1492
1493
1494        if(tableData.contentData != null) {
1495            TKVector dataVector = (TKVector) tableData.contentData;
1496            firstDataRow = (TKVector) dataVector.elementAt(0);
1497            insertNewContentValue( db, contentId, newNodeId, 0, String.valueOf(dataVector.size()) );
1498            insertNewContentValue( db, contentId, newNodeId, 1, String.valueOf(firstDataRow.size()) );
1499        }
1500        else {
1501            insertNewContentValue( db, contentId, newNodeId, 0, "0" );
1502            insertNewContentValue( db, contentId, newNodeId, 1, "0" );
1503            return leftNr+1;
1504        }
1505        //------------------------------------------------------------------------------//
1506 //---- Eine Auswahl wurde bereits getroffen, so dass das uebergebene ----//
1507 //---- Objekt optionEntry bereits erzeugt wurde. Die Struktur des ----//
1508 //---- SubElement muss wiederum in die Uebergangsstruktur eingetragen werden----//
1509 //------------------------------------------------------------------------------//
1510 //---- InfoRow ----//
1511 if(rowEntry != null) {
1512            for (int x=0; x < tableData.contentData.size(); x++) {
1513                node.right_nr = rowEntry.insertDataIntoDB( db, tableData.rowData.elementAt(x), contentId, leftNr+1 )+1;
1514            }
1515        }
1516
1517        //------ InfoCol ----//
1518 if(colEntry != null) {
1519            for (int x=0; x < firstDataRow.size(); x++) {
1520                node.right_nr = colEntry.insertDataIntoDB( db, tableData.colData.elementAt(x), contentId, leftNr+1 )+1;
1521            }
1522        }
1523
1524
1525        //---- Table ----//
1526 for (int x=0; x < tableData.contentData.size(); x++) {
1527            TKVector colVector = (TKVector) tableData.contentData.elementAt(x);
1528            for (int y=0; y < colVector.size(); y++) {
1529                node.right_nr = tableEntry.insertDataIntoDB( db, colVector.elementAt(y), contentId, leftNr+1 )+1;
1530
1531            }
1532        }
1533        return node.right_nr;
1534
1535
1536    }
1537
1538    /**
1539     * Die Daten werden aus der DB ausgelesen und wieder wie vorher aufgebaut
1540     *
1541     * @param TKContentDBData db, enthaelt die Struktur
1542     * @return die Klasse, die die Daten enthaelt
1543     */
1544    public Object getDataFromDB( TKContentDBData db )
1545    {
1546        TKContentNodeTableData node = getContentNodeFromDB( db );
1547
1548        TKContentValueTableData value0 = getContentNodeValueFromDB( db, node );
1549        int sizeTableRow = Integer.parseInt( value0.value );
1550
1551        TKContentValueTableData value1 = getContentNodeValueFromDB( db, node );
1552        int sizeTableCol = Integer.parseInt( value1.value );
1553
1554        if( sizeTableRow == 0) return getDefault();
1555
1556        TKVector rowsResultVector = new TKVector(sizeTableRow);
1557        TKVector colsResultVector = null;
1558
1559        TKVector rowInfoVector = new TKVector(sizeTableRow);
1560        TKVector colInfoVector = new TKVector(sizeTableCol);
1561
1562
1563        //---- Info Row ----//
1564 if(rowEntry != null) {
1565            for( int x=0; x< sizeTableRow; x++ ) {
1566                rowInfoVector.addElement(rowEntry.getDataFromDB( db ));
1567            }
1568        }
1569        else rowInfoVector = null;
1570
1571
1572        //---- Info Col ----//
1573 if(colEntry != null) {
1574            for( int x=0; x< sizeTableCol; x++ ) {
1575                colInfoVector.addElement(colEntry.getDataFromDB( db ));
1576            }
1577        }
1578        else colInfoVector = null;
1579
1580
1581        //---- table ----//
1582 for (int x=0; x < sizeTableRow; x++) {
1583            colsResultVector = new TKVector(sizeTableCol);
1584            for (int y=0; y < sizeTableCol; y++) {
1585                colsResultVector.addElement(tableEntry.getDataFromDB( db ));
1586            }
1587            rowsResultVector.addElement(colsResultVector);
1588        }
1589        return new TKFieldTableRealData(rowsResultVector, rowInfoVector, colInfoVector, sizeTableRow, sizeTableCol);
1590    }
1591
1592    /**
1593     * Erster Aufruf => sich selbst und das Subelemente auf -1 setzen.
1594     * Damit kann im weiteren Verlauf sichergestellt werden, dass, wenn
1595     * ein Opbjekt schon eingetragen ist, dies nicht noch einmal
1596     * eingetragen wird.
1597     */
1598    public void clearId()
1599    {
1600        if( fieldId == -1 ) return;
1601
1602        fieldId = -1;
1603        tableEntry.clearId();
1604        if(rowEntry != null) rowEntry.clearId();
1605        if(colEntry != null) colEntry.clearId();
1606    }
1607
1608    /**
1609     * Die Struktur des Objekts und seiner Subelemente werden in einer Uebergangsstruktur
1610     * fuer die DB abgelegt.
1611     */
1612    public int realInsertIntoDB( TKFormDBData db, int formId )
1613    {
1614        if( super.realInsertIntoDB( db, formId ) == -1 ) return -1;
1615
1616        //---- tableEntry ----//
1617 TKSubFieldTableData subFieldDBTable = insertNewSubField( db, formId, TABLE_ENTRY_KEY, 0 );
1618        tableEntry.realInsertIntoDB( db, formId );
1619        subFieldDBTable.sub_field_id = tableEntry.fieldId;
1620
1621        //------------------------------------------------------------------//
1622 //---- Diese Attribute zuerst setzen, da hieraus erkennbar ist, ----//
1623 //---- ob ein colEntry oder rowEntry vorhanden ist ----//
1624 //------------------------------------------------------------------//
1625 if(rowEntry != null)
1626            insertNewFieldAttribute( db, formId, IS_ROWENTRY_KEY, 0, String.valueOf(1) );
1627        else
1628            insertNewFieldAttribute( db, formId, IS_ROWENTRY_KEY, 0, String.valueOf(0) );
1629
1630        if(colEntry != null)
1631            insertNewFieldAttribute( db, formId, IS_COLENTRY_KEY, 0, String.valueOf(1) );
1632        else
1633            insertNewFieldAttribute( db, formId, IS_COLENTRY_KEY, 0, String.valueOf(0) );
1634
1635
1636        //---- rowEntry ----//
1637 if(rowEntry != null) {
1638            //---- Was wurde im Pulldown ausgewaehlt => true oder false merken ----//
1639 insertNewFieldAttribute( db, formId, BOOL_ZUSATZ_ROW, 0, String.valueOf(isRowCell) );
1640
1641            TKSubFieldTableData subFieldDBRow = insertNewSubField( db, formId, ROW_ENTRY_KEY, 0 );
1642            rowEntry.realInsertIntoDB( db, formId );
1643            subFieldDBRow.sub_field_id = rowEntry.fieldId;
1644
1645        }
1646
1647        //---- colEntry ----//
1648 if(colEntry != null) {
1649            //---- Was wurde im Pulldown ausgewaehlt => true oder false merken ----//
1650 insertNewFieldAttribute( db, formId, BOOL_ZUSATZ_COL, 0, String.valueOf(isColCell) );
1651
1652            TKSubFieldTableData subFieldDBCol = insertNewSubField( db, formId, COL_ENTRY_KEY, 0 );
1653            colEntry.realInsertIntoDB( db, formId );
1654            subFieldDBCol.sub_field_id = colEntry.fieldId;
1655        }
1656
1657        return fieldId;
1658
1659    }
1660
1661    //*************************************************************************************
1662 /**
1663     * Aufgabe wie ein Konstruktor, die Struktur des Objektes und seiner
1664     * Subelemente wird wieder aufgebaut
1665     * ACHTUNG: Aufbau in umgekehrter Reihenfolge als in realInsertIntoDB
1666     */
1667    public void initFromDB( String classId, TKFormDBData db, TKVector otherFields )
1668        throws
1669            TKUnregisteredClassException,
1670            ClassNotFoundException ,
1671            InstantiationException ,
1672            IllegalAccessException
1673    {
1674        super.initFromDB( classId, db, otherFields );
1675
1676        tableEntry = getSubField( db, TABLE_ENTRY_KEY, 0, otherFields );
1677
1678        //---- Attribute, welche ZusatzBaseFields aufgebaut werden muessen ----//
1679 int isRowEntry = Integer.parseInt( getFieldAttribute( db, IS_ROWENTRY_KEY, 0 ) );
1680        int isColEntry = Integer.parseInt( getFieldAttribute( db, IS_COLENTRY_KEY, 0 ) );
1681
1682        if(isRowEntry == 1) {
1683            //---- Attribute, was aus dem Pulldown Ausgewaehlt wurde fuer Row ----//
1684 String zusatzInfoRow = getFieldAttribute( db, BOOL_ZUSATZ_ROW , 0);
1685            isRowCell = (zusatzInfoRow.equalsIgnoreCase("true") ) ? true : false;
1686            rowEntry = getSubField( db, ROW_ENTRY_KEY, 0, otherFields );
1687        }
1688
1689        if(isColEntry == 1) {
1690            //---- Attribute, was aus dem Pulldown Ausgewaehlt wurde fuer Col ----//
1691 String zusatzInfoCol = getFieldAttribute( db, BOOL_ZUSATZ_COL , 0);
1692            isColCell = (zusatzInfoCol.equalsIgnoreCase("true") ) ? true : false;
1693            colEntry = getSubField( db, COL_ENTRY_KEY, 0, otherFields );
1694        }
1695    }
1696
1697    /**
1698     * Checks wether this object and the specified object
1699     * may be treated as equal.
1700     *
1701     * @param object the object to checked for equality.
1702     * @return <CODE>true</CODE> if this object and the
1703     * specified object may be treated as equal, otherwise
1704     * <CODE>false</CODE>.
1705     */
1706    public boolean equals (Object object)
1707    {
1708        if (! super.equals(object))
1709        {
1710            return false;
1711        }
1712
1713        TKFieldTable field = (TKFieldTable) object;
1714
1715        return (this.isRowCell == field.isRowCell) &&
1716               (this.isColCell == field.isColCell) &&
1717               (this.tableEntry == null ? field.tableEntry == null : this.tableEntry.equals(field.tableEntry)) &&
1718               (this.rowEntry == null ? field.rowEntry == null : this.rowEntry.equals(field.rowEntry)) &&
1719               (this.colEntry == null ? field.colEntry == null : this.colEntry.equals(field.colEntry));
1720    }
1721
1722    /**
1723     * Returns the hash code for this object.
1724     *
1725     * @return the hash code for this object.
1726     */
1727    public int hashCode ()
1728    {
1729        // Implementation for JTest only ;-(
1730 return super.hashCode();
1731    }
1732
1733}
1734

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Free Books   Free Magazines  

Popular Tags