KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > de > webman > template > xslt > XSLTTemplate


1 package de.webman.template.xslt;
2
3 import java.util.Enumeration JavaDoc;
4 import java.io.*;
5 import javax.xml.parsers.DocumentBuilder JavaDoc;
6 import javax.xml.parsers.DocumentBuilderFactory JavaDoc;
7 import javax.xml.transform.Transformer JavaDoc;
8 import javax.xml.transform.dom.DOMSource JavaDoc;
9 import javax.xml.transform.stream.StreamResult JavaDoc;
10 import com.teamkonzept.lib.*;
11 import com.teamkonzept.lib.templates.*;
12 import de.webman.template.jsp.*;
13 import de.webman.util.xslt.XSLTTemplateCache;
14 import org.w3c.dom.Document JavaDoc;
15 import org.w3c.dom.Element JavaDoc;
16 import org.apache.log4j.Category;
17 import javax.servlet.http.HttpServletRequest JavaDoc;
18
19 /**
20  * Implementierung der XSLT-Templates.
21  * <P>
22  * XSLT Templates werden vorcompiliert gehalten...
23  *
24  * @author $Author: uli $
25  * @version $Revision: 1.9 $
26  */
27 public class XSLTTemplate
28     implements TemplateBasic,
29                TemplateTypes
30
31 {
32
33     /**
34      * The logging category.
35      */
36     private static Category cat = Category.getInstance(XSLTTemplate.class);
37
38     /** Name des Templates */
39     private String JavaDoc name;
40
41     /** erzeugter Text */
42     private String JavaDoc text;
43
44     /** Basisdirectory */
45     private String JavaDoc rootDir;
46
47     private DOMTemplateData data;
48
49     /**
50      * The absolute path name of the template.
51      */
52     private String JavaDoc path = null;
53
54     /**
55      * Creates a new JSP template.
56      *
57      * @param _docRoot the document root.
58      * @param _name the template source name.
59      * @param _editor the template editing mode.
60      * @throws TKTemplateSyntaxException if the specified template source is errornous.
61      */
62     public XSLTTemplate (String JavaDoc _docRoot,
63                          String JavaDoc _name,
64                          boolean _editor)
65         throws TKTemplateSyntaxException
66     {
67         try
68         {
69             rootDir = _docRoot;
70             name = _name;
71             // Build absolute path name.
72 this.path = rootDir + File.separator;
73             if (_editor)
74                 path += TemplateUtils.getWebmanTemplateDirectory() + File.separator;
75             else
76                 path += TemplateUtils.getGenerationDirectory();
77             path += name;
78
79             data = new DOMTemplateData();
80         }
81         catch (Exception JavaDoc e)
82         {
83             cat.error("XSLT constructor: " , e);
84         }
85     }
86
87     public void setOriginalRequest(HttpServletRequest JavaDoc request)
88     {
89     }
90
91     public String JavaDoc getType()
92     {
93         return JSP_TEMPLATE;
94     }
95
96     void init() throws TKTemplateSyntaxException
97     {
98     }
99
100     /**
101         setzt Daten in die Root
102     */
103     public void set( TKHashtable aSubst )
104     {
105         data.set(aSubst);
106     }
107
108     public void set( String JavaDoc key, Object JavaDoc val )
109     {
110         data.set(key, val);
111     }
112
113     protected void resetData()
114     {
115         try
116         {
117             data = new DOMTemplateData();
118         }
119         catch (Exception JavaDoc e)
120         {
121             cat.error("Unable to reset Data", e);
122         }
123     }
124
125     public synchronized void sendData (Element JavaDoc node, PrintWriter out)
126     {
127         try
128         {
129             // Lookup transformer for stylesheet and perform transformation.
130 XSLTTemplateCache.getTransformer(this.path)
131                              .transform(new DOMSource JavaDoc(node), new StreamResult JavaDoc(out));
132
133             // Flush result.
134 out.flush();
135         }
136         catch (Exception JavaDoc e)
137         {
138             cat.error("sendData: " + e.getMessage(), e);
139         }
140         finally
141         {
142             resetData();
143         }
144     }
145
146     /**
147      * Das substituierte Template wird als String zurueckgegeben.
148      * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
149      * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
150      * substituiert werden.
151      * @return einen String des substituierten Templates
152      */
153     public String JavaDoc getText()
154     {
155         return text;
156     }
157
158     /**
159      * Das Template wird in den PrintStream geschrieben.
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      */
165     public void printTemplate( PrintStream out )
166     {
167         sendData(data.getRoot(), new PrintWriter(out));
168     }
169
170     /**
171      * Das Template wird in den Writer geschrieben.
172      * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
173      * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
174      * substituiert werden.
175      *
176      */
177     public void printTemplate( Writer writer ) throws IOException
178     {
179         sendData(data.getRoot(), new PrintWriter(writer));
180     }
181
182     /**
183      * Das substituierte Template wird in ein File geschrieben werden.
184      * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
185      * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
186      * substituiert werden.
187      *
188      * Bsp. Reihenfolge der Aufrufe:
189      * TKTemplateObject.doTagSubstitution();
190      * TKTemplateObject.doCleanup();
191      * TKTemplateObject.printTemplate(String file)
192      *
193      * @param String file, der Filename des zu speichernden templates
194      */
195     public void printTemplate(String JavaDoc file) throws IOException
196     {
197         FileWriter w = new FileWriter(file);
198         sendData(data.getRoot(), new PrintWriter(w));
199     }
200
201     /**
202      * Das Template wird auf stdout geschrieben.
203      * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates
204      * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst
205      * substituiert werden.
206      *
207      */
208     public void printTemplate()
209     {
210         throw new RuntimeException JavaDoc("Method not implemented !");
211     }
212
213     public DOMTemplateData getDOMData()
214     {
215         return data;
216     }
217
218     /**
219      * Durch den Aufruf der Methode doMainSubstitution enthaelt die
220      * Instanzvariable "text" das Template mit den substituierten TKTags.
221      * Die nicht vollstaendigen Pfade werden ersetzt.
222      *
223      * Die URL-Base ist gestzt, wenn Images ausserhalb des CGI-Verzeichnisses
224      * abgelegt sind. Fuer diese Bilder muss der vollstaendige Pfad im
225      * Template gesetzt werden.
226      */
227     public void doTagSubstitution() throws TKTemplateSyntaxException
228     {
229         doMainSubstitutions();
230     }
231
232     /**
233      * Die Instanzvariable "text" enthaelt das Template mit den
234      * substituierten TKTags
235      *
236      *
237      */
238     public void doMainSubstitutions() throws TKTemplateSyntaxException
239     {
240         /*
241         StringWriter w = new StringWriter();
242         sendData(data.getRoot(), new PrintWriter(w));
243         text = w.toString();*/
244     }
245
246 }
247
Popular Tags