View Javadoc

1   // ========================================================================
2   // $Id: Element.java,v 1.10 2005/08/13 00:01:23 gregwilkins Exp $
3   // Copyright 1996-2004 Mort Bay Consulting Pty. Ltd.
4   // ------------------------------------------------------------------------
5   // Licensed under the Apache License, Version 2.0 (the "License");
6   // you may not use this file except in compliance with the License.
7   // You may obtain a copy of the License at 
8   // http://www.apache.org/licenses/LICENSE-2.0
9   // Unless required by applicable law or agreed to in writing, software
10  // distributed under the License is distributed on an "AS IS" BASIS,
11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  // See the License for the specific language governing permissions and
13  // limitations under the License.
14  // ========================================================================
15  
16  package org.mortbay.html;
17  import java.io.IOException;
18  import java.io.OutputStream;
19  import java.io.OutputStreamWriter;
20  import java.io.StringWriter;
21  import java.io.Writer;
22  import java.util.Enumeration;
23  import java.util.Hashtable;
24  
25  import org.mortbay.log.Log;
26  
27  
28  /* -------------------------------------------------------------------- */
29  /** HTML Element.
30   * <p>This abstract class is the base for all HTML Elements.
31   * The feature of an abstract HTML Element is that it can be added to
32   * HTML Pages, HTML Composites and several other HTML Elements derivations.
33   * Elements may also have attributes set, which are handled by the derived
34   * Element.
35   * @deprecated Unless somebody steps forward to update and maintain this package
36   * @see Page
37   * @see Composite
38   * @version $Id: Element.java,v 1.10 2005/08/13 00:01:23 gregwilkins Exp $
39   * @author Greg Wilkins
40  */
41  public abstract class Element
42  {
43  
44      /* ----------------------------------------------------------------- */
45      public static final String
46          noAttributes="",
47          ALIGN="align",
48          LEFT="left",
49          RIGHT="right",
50          CENTER="center",
51          VALIGN="valign",
52          TOP="top",
53          BOTTOM="bottom",
54          MIDDLE="middle",
55          WIDTH="width",
56          HEIGHT="height",
57          SIZE="size",
58          COLOR="color",
59          BGCOLOR="bgcolor",
60          STYLE="style",
61          CLASS="class",
62          ID="id";
63      
64          
65      
66      /* ----------------------------------------------------------------- */
67      /** Dimensions >=0 if set*/
68      private int width=-1;
69      private int height=-1;
70      private int size=-1;
71  
72      /* ----------------------------------------------------------------- */
73      /** The space separated string of HTML element attributes.
74       */
75      private String attributes=null;
76      protected Hashtable attributeMap=null;
77  
78      /* ----------------------------------------------------------------- */
79      /** Default constructor.
80       */
81      public Element(){}
82  
83      /* ----------------------------------------------------------------- */
84      /** Construct with attributes.
85       * @param attributes The initial attributes of the element
86       */
87      public Element(String attributes)
88      {
89          attribute(attributes);
90      }
91  
92      /* ----------------------------------------------------------------- */
93      /** Write element to a Writer.
94       * This abstract method is called by the Page or other containing
95       * Element to write the HTML for this element. This must be implemented
96       * by the derived Element classes.
97       * @param out Writer to write the element to.
98       */
99      public abstract void write(Writer out)
100          throws IOException;
101 
102     /* ----------------------------------------------------------------- */
103     /** Write Element to an OutputStream.
104      * Calls print(Writer) and checks errors
105      * Elements that override this method should also override
106      * write(Writer) to avoid infinite recursion.
107      * @param out OutputStream to write the element to.
108      */
109     public void write(OutputStream out)
110          throws IOException
111     {
112         Writer writer = new OutputStreamWriter(out);
113         write(writer);
114         writer.flush();
115     }
116     
117     /* ----------------------------------------------------------------- */
118     /** Write Element to an OutputStream.
119      * Calls print(Writer) and checks errors
120      * Elements that override this method should also override
121      * write(Writer) to avoid infinite recursion.
122      * @param out OutputStream to write the element to.
123      */
124     public void write(OutputStream out, String encoding)
125          throws IOException
126     {
127         Writer writer = new OutputStreamWriter(out,encoding);
128         write(writer);
129         writer.flush();
130     }
131 
132     /* ----------------------------------------------------------------- */
133     public String attributes()
134     {
135         if (attributes==null && attributeMap==null)
136             return noAttributes;
137 
138         StringBuffer buf = new StringBuffer(128);
139         synchronized(buf)
140         {
141             if (attributeMap!=null)
142             {
143                 Enumeration e = attributeMap.keys();
144                 while (e.hasMoreElements())
145                 {
146                     buf.append(' ');
147                     String a = (String)e.nextElement();
148                     buf.append(a);
149                     buf.append('=');
150                     buf.append(attributeMap.get(a).toString());
151                 }
152             }
153             
154             if(attributes!=null && attributes.length()>0)
155             {
156                 if (!attributes.startsWith(" "))
157                     buf.append(' ');
158                 buf.append(attributes);
159             }
160         }
161 
162         return buf.toString();
163     }
164 
165     /* ----------------------------------------------------------------- */
166     /** Add element Attributes.
167      * The attributes are added to the Element attributes (separated with
168      * a space). The attributes are available to the derived class in the
169      * protected member String <I>attributes</I>
170      * @deprecated Use attribute(String).
171      * @param attributes String of HTML attributes to add to the element.
172      * @return This Element so calls can be chained.
173      */
174     public Element attributes(String attributes)
175     {
176         if (attributes==null)
177         {
178             this.attributes=null;
179             return this;
180         }
181         
182         if (attributes==noAttributes)
183             return this;
184         
185         if (this.attributes==null)
186             this.attributes=attributes;
187         else
188             this.attributes += ' '+attributes;
189         return this;
190     }
191 
192     /* ------------------------------------------------------------ */
193     /** Set attributes from another Element.
194      * @param e Element
195      * @return This Element
196      */
197     public Element setAttributesFrom(Element e)
198     {
199         attributes=e.attributes;
200         attributeMap=(Hashtable)e.attributeMap.clone();
201         return this;
202     }
203 
204     
205     /* ----------------------------------------------------------------- */
206     /** Add element Attributes.
207      * The attributes are added to the Element attributes (separated with
208      * a space). The attributes are available to the derived class in the
209      * protected member String <I>attributes</I>
210      * @param attributes String of HTML attributes to add to the element.
211      * A null attribute clears the current attributes.
212      * @return This Element so calls can be chained.
213      */
214     public Element attribute(String attributes)
215     {
216         if (attributes==null ||
217             this.attributes==null ||
218             this.attributes==noAttributes ||
219             this.attributes.length()==0)
220             this.attributes=attributes;
221         else
222             this.attributes += ' '+attributes;
223         return this;
224     }
225     
226     /* ----------------------------------------------------------------- */
227     /** Add quoted element Attributes and value.
228      * @param attribute String of HTML attribute tag
229      * @param value String value of the attribute to be quoted
230      * @return This Element so calls can be chained.
231      */
232     public Element attribute(String attribute, Object value)
233     {
234         if (attributeMap==null)
235             attributeMap=new Hashtable(10);
236         
237         if (value!=null)
238         {
239             if (value instanceof String && ((String)value).indexOf('"')!=-1)
240             {
241                 String s=(String)value;
242                 int q=0;
243                 while((q=s.indexOf('"',q))>=0)
244                 {
245                     s=s.substring(0,q)+"&quot;"+s.substring(++q);
246                     q+=6;
247                 }
248                 value=s;
249             }
250             
251             attributeMap.put(attribute,"\""+value+'"');
252         }
253         return this;
254     }
255     
256     /* ----------------------------------------------------------------- */
257     /** Add quoted element Attributes and value.
258      * @param attribute String of HTML attribute tag
259      * @param value String value of the attribute to be quoted
260      * @return This Element so calls can be chained.
261      */
262     public Element attribute(String attribute, long value)
263     {
264         if (attributeMap==null)
265             attributeMap=new Hashtable(10);
266         
267         attributeMap.put(attribute,Long.toString(value));
268         return this;
269     }
270 
271     /* ----------------------------------------------------------------- */
272     /** Convert Element to String.
273      * Uses write() to convert the HTML Element to a string.
274      * @return String of the HTML element
275      */
276     public String toString()
277     {
278         try{
279             StringWriter out = new StringWriter();
280             write(out);
281             out.flush();
282             return out.toString();
283         }
284         catch(IOException e){
285             Log.ignore(e);
286         }
287         return null;    
288     }
289     
290     /* ----------------------------------------------------------------- */
291     /** left justify.
292      * Convenience method equivalent to attribute("align","left"). Not
293      * applicable to all Elements.
294      */
295     public Element left()
296     {
297         return attribute(ALIGN,LEFT);
298     }
299     
300     /* ----------------------------------------------------------------- */
301     /** right justify.
302      * Convenience method equivalent to attribute("align","right"). Not
303      * applicable to all Elements.
304      */
305     public Element right()
306     {
307         return attribute(ALIGN,RIGHT);
308     }
309     
310     /* ----------------------------------------------------------------- */
311     /** Center.
312      * Convenience method equivalent to attribute("align","center"). Not
313      * applicable to all Elements.
314      */
315     public Element center()
316     {
317         return attribute(ALIGN,CENTER);
318     }
319     
320     /* ----------------------------------------------------------------- */
321     /** Top align.
322      * Convenience method equivalent to attribute("valign","top"). Not
323      * applicable to all Elements.
324      */
325     public Element top()
326     {
327         return attribute(VALIGN,TOP);
328     }
329     
330     /* ----------------------------------------------------------------- */
331     /** Bottom align.
332      * Convenience method equivalent to attribute("valign","bottom"). Not
333      * applicable to all Elements.
334      */
335     public Element bottom()
336     {
337         return attribute(VALIGN,BOTTOM);
338     }
339     
340     /* ----------------------------------------------------------------- */
341     /** Middle align.
342      * Convenience method equivalent to attribute("valign","middle"). Not
343      * applicable to all Elements.
344      */
345     public Element middle()
346     {
347         return attribute(VALIGN,MIDDLE);
348     }
349     
350     /* ----------------------------------------------------------------- */
351     /** set width.
352      * Convenience method equivalent to attribute("width",w). Not
353      * applicable to all Elements.
354      */
355     public Element width(int w)
356     {
357         width=w;
358         return attribute(WIDTH,w);
359     }
360     
361     /* ----------------------------------------------------------------- */
362     /** set width.
363      * Convenience method equivalent to attribute("width",w). Not
364      * applicable to all Elements.
365      */
366     public Element width(String w)
367     {
368         width=-1;
369         return attribute(WIDTH,w);
370     }
371     
372     /* ----------------------------------------------------------------- */
373     public int width()
374     {
375         return width;
376     }
377     
378     /* ----------------------------------------------------------------- */
379     /** set height.
380      * Convenience method equivalent to attribute("height",h). Not
381      * applicable to all Elements.
382      */
383     public Element height(int h)
384     {
385         height=h;
386         return attribute(HEIGHT,h);
387     }
388     
389     /* ----------------------------------------------------------------- */
390     /** set height.
391      * Convenience method equivalent to attribute("height",h). Not
392      * applicable to all Elements.
393      */
394     public Element height(String h)
395     {
396         height=-1;
397         return attribute(HEIGHT,h);
398     }
399     
400     /* ----------------------------------------------------------------- */
401     public int height()
402     {
403         return height;
404     }
405     
406     /* ----------------------------------------------------------------- */
407     /** set size.
408      * Convenience method equivalent to attribute("size",s). Not
409      * applicable to all Elements.
410      */
411     public Element size(int s)
412     {
413         size=s;
414         return attribute(SIZE,s);
415     }
416     
417     /* ----------------------------------------------------------------- */
418     /** set size.
419      * Convenience method equivalent to attribute("size",s). Not
420      * applicable to all Elements.
421      */
422     public Element size(String s)
423     {
424         size=-1;
425         return attribute(SIZE,s);
426     }
427     
428     /* ----------------------------------------------------------------- */
429     public int size()
430     {
431         return size;
432     }
433     
434     /* ----------------------------------------------------------------- */
435     /** set color.
436      * Convenience method equivalent to attribute("color",color). Not
437      * applicable to all Elements.
438      */
439     public Element color(String color)
440     {
441         return attribute(COLOR,color);
442     }
443     
444     /* ----------------------------------------------------------------- */
445     /** set BGCOLOR.
446      * Convenience method equivalent to attribute("bgcolor",color). Not
447      * applicable to all Elements.
448      */
449     public Element bgColor(String color)
450     {
451         return attribute(BGCOLOR,color);
452     }
453     
454     /* ----------------------------------------------------------------- */
455     /** set CSS CLASS.
456      */
457     public Element cssClass(String c)
458     {
459         return attribute(CLASS,c);
460     }
461     
462     /* ----------------------------------------------------------------- */
463     /** set CSS ID.
464      * Convenience method equivalent to attribute("id",id).
465      */
466     public Element cssID(String id)
467     {
468         return attribute(ID,id);
469     }
470     
471     /* ----------------------------------------------------------------- */
472     /** set Style.
473      * Convenience method equivalent to attribute("style",style).
474      */
475     public Element style(String style)
476     {
477         return attribute(STYLE,style);
478     }
479 }
480 
481 
482 
483