KickJava   Java API By Example, From Geeks To Geeks.

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


1 package com.teamkonzept.field;
2
3 import java.util.Properties JavaDoc;
4 import java.util.StringTokenizer JavaDoc;
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 JavaDoc CLASS_ID = "FIELDTABLE";
57     public static final String JavaDoc TABLE_ENTRY_KEY = "TABLEENTRY";
58     public static final String JavaDoc ROW_ENTRY_KEY = "ROWENTRY";
59     public static final String JavaDoc COL_ENTRY_KEY = "COLENTRY";
60
61     public static final String JavaDoc IS_ROWENTRY_KEY = "IS_ROWENTRY";
62     public static final String JavaDoc IS_COLENTRY_KEY = "IS_COLENTRY";
63     public static final String JavaDoc ROW_JANEIN_KEY = "JANEINZEILE";
64     public static final String JavaDoc COL_JANEIN_KEY = "JANEINSPALTE";
65
66     public static final String JavaDoc ZUSATZ_KEY = "ZUSATZ";
67     public static final String JavaDoc CELLINFO_KEY = "CELL";
68     public static final String JavaDoc NOCELLINFO_KEY = "NOCELL";
69     public static final String JavaDoc BOOL_ZUSATZ_ROW = "BOOLZUSATZROW";
70     public static final String JavaDoc BOOL_ZUSATZ_COL = "BOOLZUSATZCOL";
71
72     public static final String JavaDoc PRE_COLS = "COL";
73     public static final String JavaDoc PRE_ROWS = "ROW";
74
75     public static final String JavaDoc 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 JavaDoc name, TKBaseField tableEntry )
90     {
91         this( name, tableEntry, null, null );
92     }
93
94
95     public TKFieldTable(
96         String JavaDoc 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 JavaDoc name,
107         TKBaseField tableEntry,
108         TKBaseField rowEntry,
109         TKBaseField colEntry ,
110         String JavaDoc 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 JavaDoc name,
126         TKBaseField tableEntry,
127         TKBaseField rowEntry,
128         TKBaseField colEntry ,
129         String JavaDoc 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 JavaDoc fieldClass, Object JavaDoc data )
147         throws
148             TKUnregisteredClassException,
149             ClassNotFoundException JavaDoc,
150             InstantiationException JavaDoc,
151             IllegalAccessException JavaDoc
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 JavaDoc( "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 JavaDoc,
193         InstantiationException JavaDoc,
194         IllegalAccessException JavaDoc
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 JavaDoc selectedVal = (String JavaDoc) 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 JavaDoc( "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 JavaDoc 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 JavaDoc 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 JavaDoc compileData( String JavaDoc 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 JavaDoc)data.get(prefix+"ROW"));
396         int cols = Integer.parseInt( (String JavaDoc) 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 JavaDoc) data.get(prefix+"NEW_ROWS"));
439         int newCols = Integer.parseInt( (String JavaDoc) data.get(prefix+"NEW_COLS"));
440
441
442         return new TKFieldTableRealData(rowsResultVector, rowInfoVector, colInfoVector, newRows, newCols);
443
444     }
445
446     public Object JavaDoc compileData( String JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc data, String JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc data, String JavaDoc 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 JavaDoc 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 JavaDoc modify( String JavaDoc action, String JavaDoc fieldPath, Object JavaDoc data, String JavaDoc prefix, StringBuffer JavaDoc 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 JavaDoc subPath = fieldPath.substring( pLength+1 );
872
873             //---- "MODIFYROW" im fieldPath ----//
874
StringTokenizer JavaDoc getTokenModify = new StringTokenizer JavaDoc( subPath, ".");
875             if( (getTokenModify.nextElement()).equals(MODIFY_ROW)) {
876                 String JavaDoc subPathModify = fieldPath.substring( pLength+1+9 );
877                 StringTokenizer JavaDoc getToken = new StringTokenizer JavaDoc( subPathModify, ".");
878                 rowIdx = Integer.parseInt( (String JavaDoc)getToken.nextElement() );
879
880             }
881             else {
882                 StringTokenizer JavaDoc getToken = new StringTokenizer JavaDoc( subPath, ".");
883                 rowIdx = Integer.parseInt( (String JavaDoc)getToken.nextElement() );
884                 colIdx = Integer.parseInt( (String JavaDoc)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 JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc getToken = new StringTokenizer JavaDoc( subPath, ".");
1022                int rowIdx = Integer.parseInt( (String JavaDoc)getToken.nextElement() );
1023                int colIdx = Integer.parseInt( (String JavaDoc)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 JavaDoc fieldPath, String JavaDoc prefix)
1038    {
1039        TKBaseField targetField = null;
1040        int pLength = prefix.length()+fieldName.length();
1041        int fpLength = fieldPath.length();
1042
1043        String JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc getToken = new StringTokenizer JavaDoc(subPath, ".");
1073                int rowIdx = Integer.parseInt( (String JavaDoc) getToken.nextElement() );
1074                int colIdx = Integer.parseInt( (String JavaDoc) 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 JavaDoc deleteRowOrCol(
1089        String JavaDoc 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 JavaDoc insertRowOrCol(
1143        String JavaDoc 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 JavaDoc firstRowOrCol(
1193        String JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc lastRowOrCol(
1270        String JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc forwardRowOrCol(
1336        String JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc backRowOrCol(
1402        String JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc classId, TKFormDBData db, TKVector otherFields )
1668        throws
1669            TKUnregisteredClassException,
1670            ClassNotFoundException JavaDoc,
1671            InstantiationException JavaDoc,
1672            IllegalAccessException JavaDoc
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 JavaDoc 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 JavaDoc 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 JavaDoc 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
Popular Tags