KickJava   Java API By Example, From Geeks To Geeks.

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


1 package com.teamkonzept.field;
2
3 import java.sql.*;
4 import com.teamkonzept.lib.*;
5 import com.teamkonzept.publishing.markups.*;
6 import com.teamkonzept.web.*;
7 import com.teamkonzept.field.db.*;
8 import com.teamkonzept.international.LanguageManager;
9 import org.apache.log4j.Category;
10 import org.w3c.dom.*;
11
12 /**
13  * The fragment field control.
14  *
15  * @author $Author: uli $
16  * @version $Revision: 1.27 $
17  */
18 public class TKFragmentField
19     extends TKBaseField
20 {
21     // $Id: TKFragmentField.java,v 1.27 2002/02/27 11:07:04 uli Exp $
22
23     private static final Category LOG = Category.getInstance(TKFragmentField.class);
24
25     public static final String JavaDoc CLASS_ID = "FRAGMENT";
26     public static final String JavaDoc FORM_ID = "FORM_ID";
27     public static final String JavaDoc SELECTED_FORM = "SELECTED_FORM";
28
29     int selectedFormId;
30     TKBaseField field;
31
32     /**
33      * The name of the fragment.
34      */
35     protected String JavaDoc fragmentName = null;
36
37     /**
38      * The description of the fragment.
39      */
40     protected String JavaDoc fragmentShowName = null;
41
42     /**
43      * Konstruktor 1
44      */
45     public TKFragmentField() {};
46
47     /**
48      * Konstruktor 2
49      *
50      * @param String Name, ein beliebiger Name
51      */
52     public TKFragmentField( String JavaDoc name )
53     {
54         this( name, null );
55     }
56
57     /**
58      * Konstruktor 3
59      *
60      * @param String Name, ein beliebiger Name
61      * @param String showName, Name, den der Benuzer fuer das Feld gewaehlt hat
62      */
63     public TKFragmentField( String JavaDoc name, String JavaDoc showName )
64     {
65         this(name, showName, 0);
66     }
67
68     /**
69      * Konstruktor 4
70      */
71     public TKFragmentField( String JavaDoc name, String JavaDoc showName, int selectedFormId )
72     {
73         initFragmentField( CLASS_ID, name, showName, selectedFormId );
74     }
75
76     /**
77      * Funktionalitaet eines Konstruktors
78      *
79      * @param String type, CLASS_ID
80      * @param String Name, ein beliebiger Name
81      * @param String showName, Name, den der Benuzer fuer das Feld gewaehlt hat
82      * @param int selectedFormId, eine ausgeaehlte id einer Form (switch)
83      */
84     public final void initFragmentField( String JavaDoc type, String JavaDoc name, String JavaDoc showName, int selectedFormId )
85     {
86         initBaseField( type, name, showName );
87         this.selectedFormId = selectedFormId;
88
89         this.field = null;
90     }
91
92     /*
93      * Das zu bearbeitende field wird global zur Verfuegung gestellt
94      *
95      * @param String fieldType, CLASS_ID
96      * @param Object initData, Strukturparameter
97      */
98     public void init( String JavaDoc fieldType, Object JavaDoc initData )
99         throws
100             TKUnregisteredClassException,
101             ClassNotFoundException JavaDoc,
102             InstantiationException JavaDoc,
103             IllegalAccessException JavaDoc
104     {
105         super.init( fieldType, initData );
106         TKHashtable data = (TKHashtable) initData;
107
108         selectedFormId = Integer.parseInt( (String JavaDoc) data.get(FORM_ID) );
109 // fieldShowName = data.get("SHOWNAME").toString();
110 // fieldName = data.get("NAME").toString();
111 checkField(showName, fieldName);
112     }
113
114     /**
115      * Methode zur Definition eines Fragmenfeldes
116      * Die Struktur eines Fragmen-Feldes besteht aus einer Gruppe von zwei Inputfeldern, mit
117      * denen Name und Beschreibung festgelegt werden und eines Selectfeldes, welches die
118      * aus der DB eingelesenen Forms beinhaltet.
119      *
120      * @param allSwich, wird hier nicht benoetigt
121      * @param allSwitchList, wird hier nicht benoetigt
122      *
123      * @return eine Gruppe die die Definition des Fragmenfeldes enthaelt
124      */
125     public TKFieldGroup getDefGroup(TKFieldSwitch allSwitch, TKFieldSwitchList allSwitchList) {
126
127         //---- static: liest forms aus der DB ----//
128 TKReadFormFromDB readForms = new TKReadFormFromDB();
129         readForms.getForms();
130
131         TKBaseField [] fragmentArray = {
132                 new TKInputField(TKFragmentField.NAME_KEY, TKInputField.SMALL_DEFAULT_SIZE, TKInputField.SMALL_DEFAULT_LENGTH, LanguageManager.getText(LANGUAGE_CONTEXT, "FRAGMENT_NAME"), TKInputField.CHECK_STRING),
133                 new TKInputField(TKFragmentField.SHOW_NAME_KEY, TKInputField.LARGE_DEFAULT_SIZE, TKInputField.LARGE_DEFAULT_LENGTH, LanguageManager.getText(LANGUAGE_CONTEXT, "FRAGMENT_SHOWNAME"), TKInputField.CHECK_STRING),
134                 new TKSelectField(FORM_ID, LanguageManager.getText(LANGUAGE_CONTEXT, "FRAGMENT_FORMS"), readForms.formVector , 1, false)
135
136         };
137
138         TKFieldGroup fragmentGroup =
139             new TKFieldGroup( TKFragmentField.CLASS_ID, new TKVector( fragmentArray ), LanguageManager.getText(LANGUAGE_CONTEXT, TKFragmentField.CLASS_ID) );
140         return fragmentGroup;
141     }
142
143     /**
144      * Es existiert keine interne Representation fuer ein Fragment.
145      * und dem Ablageverzeichnis
146      *
147      * @return den Default des naechsten fields oder die der mutter
148      */
149     public Object JavaDoc getDefault()
150     {
151         if(field == null) {
152             checkField( showName, fieldName);
153         }
154         return field.getDefault();
155     }
156
157     /**
158      * Interne Repraesentation der realen Daten des naechsten Feldes.
159      *
160      * @param prefix, der prefix
161      * @param data, die realen Daten die das Fragment weitergibt fals ein field vorhanden
162      *
163      * @return result, die realen Daten
164      */
165     public Object JavaDoc compileData( String JavaDoc prefix, TKHashtable data, TKHashtable context )
166     {
167         //--- eine form wurde selected ----//
168 if(field == null) {
169             checkField( showName, fieldName);
170         }
171
172         Object JavaDoc result = field.compileData(prefix, data, context);
173         return result;
174     }
175
176     public Object JavaDoc compileData( String JavaDoc prefix, TKMarkupNode data, TKHashtable context )
177     {
178         TKXmlMarkup markup = data == null ? null : (TKXmlMarkup) data.markup;
179         if (markup == null) { return null;}
180
181         if (!markup.name.equals (getName())) {
182             return null;
183         }
184         Object JavaDoc result = field.compileData(prefix, data, context);
185         return result;
186     }
187
188     /**
189      * Die ausgewaehlte Form in der Struktur wird in einem Hash gespeichert.
190      *
191      * @return result, enhaelt die uebergabe aus der Struktur
192      */
193     public Object JavaDoc toData()
194     {
195         TKHashtable result = (TKHashtable) super.toData();
196         result.put( FORM_ID, new Integer JavaDoc(selectedFormId) );
197         return result;
198     }
199
200     /*
201      * Das naechste field wird angezeigt. falls dies nicht existier, wird die
202      * Mutter angezeigt
203      *
204      * @param t, ein Template
205      * @param value, Hasch mit Filename und Upbaseverzeichnis
206      * @param prefix, der aktuelle Prefix
207      */
208     public void fillIntoTemplate( TKHTMLTemplate t, Object JavaDoc data, String JavaDoc prefix)
209     {
210         field.fillIntoTemplate(t, data, prefix);
211     }
212
213     public void fillIntoDOM(Document doc, Element node, Object JavaDoc data) throws DOMException
214     {
215         field.fillIntoDOM(doc, node, data);
216     }
217
218     public void fillIntoPresentation( TKHTMLTemplate t, Object JavaDoc data, String JavaDoc scope )
219     {
220         field.fillIntoPresentation(t, data, scope);
221     }
222
223     /**
224      * Der Event wird an das field weitergegeben
225      *
226      * @param action, die aktuelle Aktion, MODIFY
227      * @param t, ein Template
228      * @param params, der Parameterhash
229      * @param fieldPath, sas zuletzt ausgewaehlte File im Pulldownmenue
230      */
231     public Object JavaDoc modify( String JavaDoc action, String JavaDoc fieldPath, Object JavaDoc data, String JavaDoc prefix, StringBuffer JavaDoc destination )
232     {
233         field.modify(action, fieldPath,data,prefix, destination);
234
235         return data;
236     }
237
238     //**********************************************************************
239 public int realInsertIntoDB( TKFormDBData db, int formId )
240     {
241         if( super.realInsertIntoDB( db, formId ) == -1 ) return -1;
242         insertNewFieldAttribute( db, formId, FORM_ID, 0, String.valueOf( selectedFormId ) );
243
244         return fieldId;
245     }
246
247
248     //**********************************************************************
249 public void initFromDB( String JavaDoc classId, TKFormDBData db, TKVector otherFields )
250         throws
251             TKUnregisteredClassException,
252             ClassNotFoundException JavaDoc,
253             InstantiationException JavaDoc,
254             IllegalAccessException JavaDoc
255     {
256         //--- eigenen SHOW_NAME merken, vor super ----//
257 //fieldShowName = ((TKFieldTableData)db.field.get( 0 )).field_show_name;
258 //fieldName = ((TKFieldTableData)db.field.get( 0 )).field_name;
259
260         super.initFromDB( classId, db, otherFields );
261
262
263         if( hasFieldAttribute( db, FORM_ID, 0 ) ) {
264             selectedFormId = Integer.parseInt( getFieldAttribute( db, FORM_ID, 0) );
265         }
266
267     }
268
269     public TKBaseField getTarget(String JavaDoc fieldPath, String JavaDoc prefix)
270     {
271         //--- eine form wurde selected ----//
272 if(field == null)
273             checkField( showName, fieldName);
274
275         return field.getTarget(fieldPath, prefix);
276
277     }
278
279     public int insertDataIntoDB( TKContentDBData db, Object JavaDoc data, int contentId, int leftNr )
280     {
281         return field.insertDataIntoDB(db, data, contentId, leftNr);
282
283     }
284
285     public Object JavaDoc getDataFromDB( TKContentDBData db )
286     {
287         checkField( showName, fieldName);
288         return field.getDataFromDB(db);
289     }
290
291     public void checkField(String JavaDoc thisShowName, String JavaDoc thisName)
292     {
293         if(field == null) {
294             try {
295                 //---- Formdata holen ----//
296 TKFormDBData data = new TKFormDBData( selectedFormId);
297                 TKFormDBInterface.Get( data );
298                 field = TKFieldRegistry.getFieldFromDB( data );
299
300                 this.fragmentName = field.getName();
301                 this.fragmentShowName = field.getShowName();
302
303                 field.setName( thisShowName, thisName );
304             }
305             catch( Exception JavaDoc e ) {
306                 LOG.error("ERROR:", e);
307             }
308         }
309     }
310
311     /**
312      * Checks wether this object and the specified object
313      * may be treated as equal.
314      *
315      * @param object the object to checked for equality.
316      * @return <CODE>true</CODE> if this object and the
317      * specified object may be treated as equal, otherwise
318      * <CODE>false</CODE>.
319      */
320     public boolean equals (Object JavaDoc object)
321     {
322         if (! super.equals(object))
323         {
324             return false;
325         }
326
327         TKFragmentField field = (TKFragmentField) object;
328
329         return (this.selectedFormId == field.selectedFormId) &&
330                (this.fragmentName == null ? field.fragmentName == null : this.fragmentName.equals(field.fragmentName)) &&
331                (this.fragmentShowName == null ? field.fragmentShowName == null : this.fragmentShowName.equals(field.fragmentShowName)) &&
332                (this.field == null ? field.field == null : this.field.equals(field.field));
333     }
334
335     /**
336      * Returns the hash code for this object.
337      *
338      * @return the hash code for this object.
339      */
340     public int hashCode ()
341     {
342         // Implementation for JTest only ;-(
343 return super.hashCode();
344     }
345
346 }
347
Free Books   Free Magazines  
Popular Tags