001: package de.webman.template.xslt;
002:
003: import java.util.Enumeration;
004: import java.io.*;
005: import javax.xml.parsers.DocumentBuilder;
006: import javax.xml.parsers.DocumentBuilderFactory;
007: import javax.xml.transform.Transformer;
008: import javax.xml.transform.dom.DOMSource;
009: import javax.xml.transform.stream.StreamResult;
010: import com.teamkonzept.lib.*;
011: import com.teamkonzept.lib.templates.*;
012: import de.webman.template.jsp.*;
013: import de.webman.util.xslt.XSLTTemplateCache;
014: import org.w3c.dom.Document;
015: import org.w3c.dom.Element;
016: import org.apache.log4j.Category;
017: import javax.servlet.http.HttpServletRequest;
018:
019: /**
020: * Implementierung der XSLT-Templates.
021: * <P>
022: * XSLT Templates werden vorcompiliert gehalten...
023: *
024: * @author $Author: uli $
025: * @version $Revision: 1.9 $
026: */
027: public class XSLTTemplate implements TemplateBasic, TemplateTypes
028:
029: {
030:
031: /**
032: * The logging category.
033: */
034: private static Category cat = Category
035: .getInstance(XSLTTemplate.class);
036:
037: /** Name des Templates */
038: private String name;
039:
040: /** erzeugter Text */
041: private String text;
042:
043: /** Basisdirectory */
044: private String rootDir;
045:
046: private DOMTemplateData data;
047:
048: /**
049: * The absolute path name of the template.
050: */
051: private String path = null;
052:
053: /**
054: * Creates a new JSP template.
055: *
056: * @param _docRoot the document root.
057: * @param _name the template source name.
058: * @param _editor the template editing mode.
059: * @throws TKTemplateSyntaxException if the specified template source is errornous.
060: */
061: public XSLTTemplate(String _docRoot, String _name, boolean _editor)
062: throws TKTemplateSyntaxException {
063: try {
064: rootDir = _docRoot;
065: name = _name;
066: // Build absolute path name.
067: this .path = rootDir + File.separator;
068: if (_editor)
069: path += TemplateUtils.getWebmanTemplateDirectory()
070: + File.separator;
071: else
072: path += TemplateUtils.getGenerationDirectory();
073: path += name;
074:
075: data = new DOMTemplateData();
076: } catch (Exception e) {
077: cat.error("XSLT constructor: ", e);
078: }
079: }
080:
081: public void setOriginalRequest(HttpServletRequest request) {
082: }
083:
084: public String getType() {
085: return JSP_TEMPLATE;
086: }
087:
088: void init() throws TKTemplateSyntaxException {
089: }
090:
091: /**
092: setzt Daten in die Root
093: */
094: public void set(TKHashtable aSubst) {
095: data.set(aSubst);
096: }
097:
098: public void set(String key, Object val) {
099: data.set(key, val);
100: }
101:
102: protected void resetData() {
103: try {
104: data = new DOMTemplateData();
105: } catch (Exception e) {
106: cat.error("Unable to reset Data", e);
107: }
108: }
109:
110: public synchronized void sendData(Element node, PrintWriter out) {
111: try {
112: // Lookup transformer for stylesheet and perform transformation.
113: XSLTTemplateCache.getTransformer(this .path).transform(
114: new DOMSource(node), new StreamResult(out));
115:
116: // Flush result.
117: out.flush();
118: } catch (Exception e) {
119: cat.error("sendData: " + e.getMessage(), e);
120: } finally {
121: resetData();
122: }
123: }
124:
125: /**
126: * Das substituierte Template wird als String zurueckgegeben.
127: * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
128: * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
129: * substituiert werden.
130: * @return einen String des substituierten Templates
131: */
132: public String getText() {
133: return text;
134: }
135:
136: /**
137: * Das Template wird in den PrintStream geschrieben.
138: * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
139: * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
140: * substituiert werden.
141: *
142: */
143: public void printTemplate(PrintStream out) {
144: sendData(data.getRoot(), new PrintWriter(out));
145: }
146:
147: /**
148: * Das Template wird in den Writer geschrieben.
149: * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
150: * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
151: * substituiert werden.
152: *
153: */
154: public void printTemplate(Writer writer) throws IOException {
155: sendData(data.getRoot(), new PrintWriter(writer));
156: }
157:
158: /**
159: * Das substituierte Template wird in ein File geschrieben werden.
160: * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
161: * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
162: * substituiert werden.
163: *
164: * Bsp. Reihenfolge der Aufrufe:
165: * TKTemplateObject.doTagSubstitution();
166: * TKTemplateObject.doCleanup();
167: * TKTemplateObject.printTemplate(String file)
168: *
169: * @param String file, der Filename des zu speichernden templates
170: */
171: public void printTemplate(String file) throws IOException {
172: FileWriter w = new FileWriter(file);
173: sendData(data.getRoot(), new PrintWriter(w));
174: }
175:
176: /**
177: * Das Template wird auf stdout geschrieben.
178: * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
179: * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
180: * substituiert werden.
181: *
182: */
183: public void printTemplate() {
184: throw new RuntimeException("Method not implemented !");
185: }
186:
187: public DOMTemplateData getDOMData() {
188: return data;
189: }
190:
191: /**
192: * Durch den Aufruf der Methode doMainSubstitution enthaelt die
193: * Instanzvariable "text" das Template mit den substituierten TKTags.
194: * Die nicht vollstaendigen Pfade werden ersetzt.
195: *
196: * Die URL-Base ist gestzt, wenn Images ausserhalb des CGI-Verzeichnisses
197: * abgelegt sind. Fuer diese Bilder muss der vollstaendige Pfad im
198: * Template gesetzt werden.
199: */
200: public void doTagSubstitution() throws TKTemplateSyntaxException {
201: doMainSubstitutions();
202: }
203:
204: /**
205: * Die Instanzvariable "text" enthaelt das Template mit den
206: * substituierten TKTags
207: *
208: *
209: */
210: public void doMainSubstitutions() throws TKTemplateSyntaxException {
211: /*
212: StringWriter w = new StringWriter();
213: sendData(data.getRoot(), new PrintWriter(w));
214: text = w.toString();*/
215: }
216:
217: }
|