001: package com.teamkonzept.field;
002:
003: import java.sql.*;
004: import com.teamkonzept.lib.*;
005: import com.teamkonzept.publishing.markups.*;
006: import com.teamkonzept.web.*;
007: import com.teamkonzept.field.db.*;
008: import com.teamkonzept.international.LanguageManager;
009: import org.apache.log4j.Category;
010: import org.w3c.dom.*;
011:
012: /**
013: * The fragment field control.
014: *
015: * @author $Author: uli $
016: * @version $Revision: 1.27 $
017: */
018: public class TKFragmentField extends TKBaseField {
019: // $Id: TKFragmentField.java,v 1.27 2002/02/27 11:07:04 uli Exp $
020:
021: private static final Category LOG = Category
022: .getInstance(TKFragmentField.class);
023:
024: public static final String CLASS_ID = "FRAGMENT";
025: public static final String FORM_ID = "FORM_ID";
026: public static final String SELECTED_FORM = "SELECTED_FORM";
027:
028: int selectedFormId;
029: TKBaseField field;
030:
031: /**
032: * The name of the fragment.
033: */
034: protected String fragmentName = null;
035:
036: /**
037: * The description of the fragment.
038: */
039: protected String fragmentShowName = null;
040:
041: /**
042: * Konstruktor 1
043: */
044: public TKFragmentField() {
045: };
046:
047: /**
048: * Konstruktor 2
049: *
050: * @param String Name, ein beliebiger Name
051: */
052: public TKFragmentField(String name) {
053: this (name, null);
054: }
055:
056: /**
057: * Konstruktor 3
058: *
059: * @param String Name, ein beliebiger Name
060: * @param String showName, Name, den der Benuzer fuer das Feld gewaehlt hat
061: */
062: public TKFragmentField(String name, String showName) {
063: this (name, showName, 0);
064: }
065:
066: /**
067: * Konstruktor 4
068: */
069: public TKFragmentField(String name, String showName,
070: int selectedFormId) {
071: initFragmentField(CLASS_ID, name, showName, selectedFormId);
072: }
073:
074: /**
075: * Funktionalitaet eines Konstruktors
076: *
077: * @param String type, CLASS_ID
078: * @param String Name, ein beliebiger Name
079: * @param String showName, Name, den der Benuzer fuer das Feld gewaehlt hat
080: * @param int selectedFormId, eine ausgeaehlte id einer Form (switch)
081: */
082: public final void initFragmentField(String type, String name,
083: String showName, int selectedFormId) {
084: initBaseField(type, name, showName);
085: this .selectedFormId = selectedFormId;
086:
087: this .field = null;
088: }
089:
090: /*
091: * Das zu bearbeitende field wird global zur Verfuegung gestellt
092: *
093: * @param String fieldType, CLASS_ID
094: * @param Object initData, Strukturparameter
095: */
096: public void init(String fieldType, Object initData)
097: throws TKUnregisteredClassException,
098: ClassNotFoundException, InstantiationException,
099: IllegalAccessException {
100: super .init(fieldType, initData);
101: TKHashtable data = (TKHashtable) initData;
102:
103: selectedFormId = Integer.parseInt((String) data.get(FORM_ID));
104: // fieldShowName = data.get("SHOWNAME").toString();
105: // fieldName = data.get("NAME").toString();
106: checkField(showName, fieldName);
107: }
108:
109: /**
110: * Methode zur Definition eines Fragmenfeldes
111: * Die Struktur eines Fragmen-Feldes besteht aus einer Gruppe von zwei Inputfeldern, mit
112: * denen Name und Beschreibung festgelegt werden und eines Selectfeldes, welches die
113: * aus der DB eingelesenen Forms beinhaltet.
114: *
115: * @param allSwich, wird hier nicht benoetigt
116: * @param allSwitchList, wird hier nicht benoetigt
117: *
118: * @return eine Gruppe die die Definition des Fragmenfeldes enthaelt
119: */
120: public TKFieldGroup getDefGroup(TKFieldSwitch allSwitch,
121: TKFieldSwitchList allSwitchList) {
122:
123: //---- static: liest forms aus der DB ----//
124: TKReadFormFromDB readForms = new TKReadFormFromDB();
125: readForms.getForms();
126:
127: TKBaseField[] fragmentArray = {
128: new TKInputField(TKFragmentField.NAME_KEY,
129: TKInputField.SMALL_DEFAULT_SIZE,
130: TKInputField.SMALL_DEFAULT_LENGTH,
131: LanguageManager.getText(LANGUAGE_CONTEXT,
132: "FRAGMENT_NAME"),
133: TKInputField.CHECK_STRING),
134: new TKInputField(TKFragmentField.SHOW_NAME_KEY,
135: TKInputField.LARGE_DEFAULT_SIZE,
136: TKInputField.LARGE_DEFAULT_LENGTH,
137: LanguageManager.getText(LANGUAGE_CONTEXT,
138: "FRAGMENT_SHOWNAME"),
139: TKInputField.CHECK_STRING),
140: new TKSelectField(FORM_ID, LanguageManager.getText(
141: LANGUAGE_CONTEXT, "FRAGMENT_FORMS"),
142: readForms.formVector, 1, false)
143:
144: };
145:
146: TKFieldGroup fragmentGroup = new TKFieldGroup(
147: TKFragmentField.CLASS_ID, new TKVector(fragmentArray),
148: LanguageManager.getText(LANGUAGE_CONTEXT,
149: TKFragmentField.CLASS_ID));
150: return fragmentGroup;
151: }
152:
153: /**
154: * Es existiert keine interne Representation fuer ein Fragment.
155: * und dem Ablageverzeichnis
156: *
157: * @return den Default des naechsten fields oder die der mutter
158: */
159: public Object getDefault() {
160: if (field == null) {
161: checkField(showName, fieldName);
162: }
163: return field.getDefault();
164: }
165:
166: /**
167: * Interne Repraesentation der realen Daten des naechsten Feldes.
168: *
169: * @param prefix, der prefix
170: * @param data, die realen Daten die das Fragment weitergibt fals ein field vorhanden
171: *
172: * @return result, die realen Daten
173: */
174: public Object compileData(String prefix, TKHashtable data,
175: TKHashtable context) {
176: //--- eine form wurde selected ----//
177: if (field == null) {
178: checkField(showName, fieldName);
179: }
180:
181: Object result = field.compileData(prefix, data, context);
182: return result;
183: }
184:
185: public Object compileData(String prefix, TKMarkupNode data,
186: TKHashtable context) {
187: TKXmlMarkup markup = data == null ? null
188: : (TKXmlMarkup) data.markup;
189: if (markup == null) {
190: return null;
191: }
192:
193: if (!markup.name.equals(getName())) {
194: return null;
195: }
196: Object result = field.compileData(prefix, data, context);
197: return result;
198: }
199:
200: /**
201: * Die ausgewaehlte Form in der Struktur wird in einem Hash gespeichert.
202: *
203: * @return result, enhaelt die uebergabe aus der Struktur
204: */
205: public Object toData() {
206: TKHashtable result = (TKHashtable) super .toData();
207: result.put(FORM_ID, new Integer(selectedFormId));
208: return result;
209: }
210:
211: /*
212: * Das naechste field wird angezeigt. falls dies nicht existier, wird die
213: * Mutter angezeigt
214: *
215: * @param t, ein Template
216: * @param value, Hasch mit Filename und Upbaseverzeichnis
217: * @param prefix, der aktuelle Prefix
218: */
219: public void fillIntoTemplate(TKHTMLTemplate t, Object data,
220: String prefix) {
221: field.fillIntoTemplate(t, data, prefix);
222: }
223:
224: public void fillIntoDOM(Document doc, Element node, Object data)
225: throws DOMException {
226: field.fillIntoDOM(doc, node, data);
227: }
228:
229: public void fillIntoPresentation(TKHTMLTemplate t, Object data,
230: String scope) {
231: field.fillIntoPresentation(t, data, scope);
232: }
233:
234: /**
235: * Der Event wird an das field weitergegeben
236: *
237: * @param action, die aktuelle Aktion, MODIFY
238: * @param t, ein Template
239: * @param params, der Parameterhash
240: * @param fieldPath, sas zuletzt ausgewaehlte File im Pulldownmenue
241: */
242: public Object modify(String action, String fieldPath, Object data,
243: String prefix, StringBuffer destination) {
244: field.modify(action, fieldPath, data, prefix, destination);
245:
246: return data;
247: }
248:
249: //**********************************************************************
250: public int realInsertIntoDB(TKFormDBData db, int formId) {
251: if (super .realInsertIntoDB(db, formId) == -1)
252: return -1;
253: insertNewFieldAttribute(db, formId, FORM_ID, 0, String
254: .valueOf(selectedFormId));
255:
256: return fieldId;
257: }
258:
259: //**********************************************************************
260: public void initFromDB(String classId, TKFormDBData db,
261: TKVector otherFields) throws TKUnregisteredClassException,
262: ClassNotFoundException, InstantiationException,
263: IllegalAccessException {
264: //--- eigenen SHOW_NAME merken, vor super ----//
265: //fieldShowName = ((TKFieldTableData)db.field.get( 0 )).field_show_name;
266: //fieldName = ((TKFieldTableData)db.field.get( 0 )).field_name;
267:
268: super .initFromDB(classId, db, otherFields);
269:
270: if (hasFieldAttribute(db, FORM_ID, 0)) {
271: selectedFormId = Integer.parseInt(getFieldAttribute(db,
272: FORM_ID, 0));
273: }
274:
275: }
276:
277: public TKBaseField getTarget(String fieldPath, String prefix) {
278: //--- eine form wurde selected ----//
279: if (field == null)
280: checkField(showName, fieldName);
281:
282: return field.getTarget(fieldPath, prefix);
283:
284: }
285:
286: public int insertDataIntoDB(TKContentDBData db, Object data,
287: int contentId, int leftNr) {
288: return field.insertDataIntoDB(db, data, contentId, leftNr);
289:
290: }
291:
292: public Object getDataFromDB(TKContentDBData db) {
293: checkField(showName, fieldName);
294: return field.getDataFromDB(db);
295: }
296:
297: public void checkField(String this ShowName, String this Name) {
298: if (field == null) {
299: try {
300: //---- Formdata holen ----//
301: TKFormDBData data = new TKFormDBData(selectedFormId);
302: TKFormDBInterface.Get(data);
303: field = TKFieldRegistry.getFieldFromDB(data);
304:
305: this .fragmentName = field.getName();
306: this .fragmentShowName = field.getShowName();
307:
308: field.setName(this ShowName, this Name);
309: } catch (Exception e) {
310: LOG.error("ERROR:", e);
311: }
312: }
313: }
314:
315: /**
316: * Checks wether this object and the specified object
317: * may be treated as equal.
318: *
319: * @param object the object to checked for equality.
320: * @return <CODE>true</CODE> if this object and the
321: * specified object may be treated as equal, otherwise
322: * <CODE>false</CODE>.
323: */
324: public boolean equals(Object object) {
325: if (!super .equals(object)) {
326: return false;
327: }
328:
329: TKFragmentField field = (TKFragmentField) object;
330:
331: return (this .selectedFormId == field.selectedFormId)
332: && (this .fragmentName == null ? field.fragmentName == null
333: : this .fragmentName.equals(field.fragmentName))
334: && (this .fragmentShowName == null ? field.fragmentShowName == null
335: : this .fragmentShowName
336: .equals(field.fragmentShowName))
337: && (this .field == null ? field.field == null
338: : this .field.equals(field.field));
339: }
340:
341: /**
342: * Returns the hash code for this object.
343: *
344: * @return the hash code for this object.
345: */
346: public int hashCode() {
347: // Implementation for JTest only ;-(
348: return super.hashCode();
349: }
350:
351: }
|