KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > htmlparser > tags > ObjectTag


1 // HTMLParser Library $Name: v1_5_20050313 $ - A java-based parser for HTML
2 // http://sourceforge.org/projects/htmlparser
3 // Copyright (C) 2004 Enrico Triolo
4 //
5 // Revision Control Information
6 //
7 // $Source: /cvsroot/htmlparser/htmlparser/src/org/htmlparser/tags/ObjectTag.java,v $
8 // $Author: derrickoswald $
9 // $Date: 2004/07/02 00:49:29 $
10 // $Revision: 1.2 $
11 //
12 // This library is free software; you can redistribute it and/or
13 // modify it under the terms of the GNU Lesser General Public
14 // License as published by the Free Software Foundation; either
15 // version 2.1 of the License, or (at your option) any later version.
16 //
17 // This library is distributed in the hope that it will be useful,
18 // but WITHOUT ANY WARRANTY; without even the implied warranty of
19 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 // Lesser General Public License for more details.
21 //
22 // You should have received a copy of the GNU Lesser General Public
23 // License along with this library; if not, write to the Free Software
24 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 //
26
27 package org.htmlparser.tags;
28
29 import java.util.Enumeration JavaDoc;
30 import java.util.Hashtable JavaDoc;
31 import java.util.Vector JavaDoc;
32
33 import org.htmlparser.Attribute;
34 import org.htmlparser.Node;
35 import org.htmlparser.Tag;
36 import org.htmlparser.nodes.TextNode;
37 import org.htmlparser.nodes.TagNode;
38 import org.htmlparser.util.NodeList;
39 import org.htmlparser.util.SimpleNodeIterator;
40
41 /**
42  * ObjectTag represents an <Object> tag.
43  * It extends a basic tag by providing accessors to the
44  * type, codetype, codebase, classid, data, height, width, standby attributes and parameters.
45  */
46 public class ObjectTag extends CompositeTag
47 {
48     /**
49      * The set of names handled by this tag.
50      */
51     private static final String JavaDoc[] mIds = new String JavaDoc[] {"OBJECT"};
52
53     /**
54      * The set of end tag names that indicate the end of this tag.
55      */
56     private static final String JavaDoc[] mEndTagEnders = new String JavaDoc[] {"BODY", "HTML"};
57
58     /**
59      * Create a new object tag.
60      */
61     public ObjectTag ()
62     {
63     }
64
65     /**
66      * Return the set of names handled by this tag.
67      * @return The names to be matched that create tags of this type.
68      */
69     public String JavaDoc[] getIds ()
70     {
71         return (mIds);
72     }
73
74     /**
75      * Return the set of end tag names that cause this tag to finish.
76      * @return The names of following end tags that stop further scanning.
77      */
78     public String JavaDoc[] getEndTagEnders ()
79     {
80         return (mEndTagEnders);
81     }
82
83     /**
84      * Extract the object <code>PARAM</code> tags from the child list.
85      * @return The list of object parameters (keys and values are String objects).
86      */
87     public Hashtable JavaDoc createObjectParamsTable ()
88     {
89         NodeList kids;
90         Node node;
91         Tag tag;
92         String JavaDoc paramName;
93         String JavaDoc paramValue;
94         Hashtable JavaDoc ret;
95
96         ret = new Hashtable JavaDoc ();
97         kids = getChildren ();
98         if (null != kids)
99             for (int i = 0; i < kids.size (); i++)
100             {
101                 node = children.elementAt(i);
102                 if (node instanceof Tag)
103                 {
104                     tag = (Tag)node;
105                     if (tag.getTagName().equals ("PARAM"))
106                     {
107                         paramName = tag.getAttribute ("NAME");
108                         if (null != paramName && 0 != paramName.length ())
109                         {
110                             paramValue = tag.getAttribute ("VALUE");
111                             ret.put (paramName.toUpperCase(),paramValue);
112                         }
113                     }
114                 }
115             }
116
117         return (ret);
118     }
119
120     /**
121      * Get the classid of the object.
122      * @return The value of the <code>CLASSID</code> attribute.
123      */
124     public String JavaDoc getObjectClassId ()
125     {
126         return getAttribute ("CLASSID");
127     }
128
129     /**
130      * Get the codebase of the object.
131      * @return The value of the <code>CODEBASE</code> attribute.
132      */
133     public String JavaDoc getObjectCodeBase ()
134     {
135         return getAttribute ("CODEBASE");
136     }
137     
138     /**
139      * Get the codetype of the object.
140      * @return The value of the <code>CODETYPE</code> attribute.
141      */
142     public String JavaDoc getObjectCodeType ()
143     {
144         return getAttribute ("CODETYPE");
145     }
146     
147     /**
148      * Get the data of the object.
149      * @return The value of the <code>DATA</code> attribute.
150      */
151     public String JavaDoc getObjectData ()
152     {
153         return getAttribute ("DATA");
154     }
155     
156     /**
157      * Get the height of the object.
158      * @return The value of the <code>HEIGHT</code> attribute.
159      */
160     public String JavaDoc getObjectHeight ()
161     {
162         return getAttribute ("HEIGHT");
163     }
164     
165     /**
166      * Get the standby of the object.
167      * @return The value of the <code>STANDBY</code> attribute.
168      */
169     public String JavaDoc getObjectStandby ()
170     {
171         return getAttribute ("STANDBY");
172     }
173     
174     /**
175      * Get the type of the object.
176      * @return The value of the <code>TYPE</code> attribute.
177      */
178     public String JavaDoc getObjectType ()
179     {
180         return getAttribute ("TYPE");
181     }
182     
183     /**
184      * Get the width of the object.
185      * @return The value of the <code>WIDTH</code> attribute.
186      */
187     public String JavaDoc getObjectWidth ()
188     {
189         return getAttribute ("WIDTH");
190     }
191     
192     /**
193      * Get the object parameters.
194      * @return The list of parameter values (keys and values are String objects).
195      */
196     public Hashtable JavaDoc getObjectParams ()
197     {
198         return createObjectParamsTable ();
199     }
200     
201     /**
202      * Get the <code>PARAM<code> tag with the given name.
203      * @param key The object parameter name to get.
204      * @return The value of the parameter or <code>null</code> if there is no parameter of that name.
205      */
206     public String JavaDoc getParameter (String JavaDoc key)
207     {
208         return ((String JavaDoc)(getObjectParams ().get (key.toUpperCase ())));
209     }
210     
211     /**
212      * Get an enumeration over the (String) parameter names.
213      * @return An enumeration of the <code>PARAM<code> tag <code>NAME<code> attributes.
214      */
215     public Enumeration JavaDoc getParameterNames ()
216     {
217         return getObjectParams ().keys ();
218     }
219     
220     /**
221      * Set the <code>CLASSID<code> attribute.
222      * @param newClassId The new classid.
223      */
224     public void setObjectClassId (String JavaDoc newClassId)
225     {
226         setAttribute ("CLASSID", newClassId);
227     }
228     
229     /**
230      * Set the <code>CODEBASE<code> attribute.
231      * @param newCodeBase The new codebase.
232      */
233     public void setObjectCodeBase (String JavaDoc newCodeBase)
234     {
235         setAttribute ("CODEBASE", newCodeBase);
236     }
237     
238     /**
239      * Set the <code>CODETYPE<code> attribute.
240      * @param newCodeType The new codetype.
241      */
242     public void setObjectCodeType (String JavaDoc newCodeType)
243     {
244         setAttribute ("CODETYPE", newCodeType);
245     }
246     
247     /**
248      * Set the <code>DATA<code> attribute.
249      * @param newData The new data.
250      */
251     public void setObjectData (String JavaDoc newData)
252     {
253         setAttribute ("DATA", newData);
254     }
255     
256     /**
257      * Set the <code>HEIGHT<code> attribute.
258      * @param newHeight The new height.
259      */
260     public void setObjectHeight (String JavaDoc newHeight)
261     {
262         setAttribute ("HEIGHT", newHeight);
263     }
264     
265     /**
266      * Set the <code>STANDBY<code> attribute.
267      * @param newStandby The new standby.
268      */
269     public void setObjectStandby (String JavaDoc newStandby)
270     {
271         setAttribute ("STANDBY", newStandby);
272     }
273     
274     /**
275      * Set the <code>TYPE<code> attribute.
276      * @param newType The new type.
277      */
278     public void setObjectType (String JavaDoc newType)
279     {
280         setAttribute ("TYPE", newType);
281     }
282     
283     /**
284      * Set the <code>WIDTH<code> attribute.
285      * @param newWidth The new width.
286      */
287     public void setObjectWidth (String JavaDoc newWidth)
288     {
289         setAttribute ("WIDTH", newWidth);
290     }
291     
292     /**
293      * Set the enclosed <code>PARAM<code> children.
294      * @param newObjectParams The new parameters.
295      */
296     public void setObjectParams (Hashtable JavaDoc newObjectParams)
297     {
298         NodeList kids;
299         Node node;
300         Tag tag;
301         String JavaDoc paramName;
302         String JavaDoc paramValue;
303         Vector JavaDoc attributes;
304         TextNode string;
305         
306         kids = getChildren ();
307         if (null == kids)
308             kids = new NodeList ();
309         else
310             // erase objectParams from kids
311 for (int i = 0; i < kids.size (); )
312             {
313                 node = kids.elementAt (i);
314                 if (node instanceof Tag)
315                     if (((Tag)node).getTagName ().equals ("PARAM"))
316                     {
317                         kids.remove (i);
318                         // remove whitespace too
319 if (i < kids.size ())
320                         {
321                             node = kids.elementAt (i);
322                             if (node instanceof TextNode)
323                             {
324                                 string = (TextNode)node;
325                                 if (0 == string.getText ().trim ().length ())
326                                     kids.remove (i);
327                             }
328                         }
329                     }
330                     else
331                         i++;
332                 else
333                     i++;
334             }
335         
336         // add newObjectParams to kids
337 for (Enumeration JavaDoc e = newObjectParams.keys (); e.hasMoreElements (); )
338         {
339             attributes = new Vector JavaDoc (); // should the tag copy the attributes?
340 paramName = (String JavaDoc)e.nextElement ();
341             paramValue = (String JavaDoc)newObjectParams.get (paramName);
342             attributes.addElement (new Attribute ("PARAM", null));
343             attributes.addElement (new Attribute (" "));
344             attributes.addElement (new Attribute ("VALUE", paramValue, '"'));
345             attributes.addElement (new Attribute (" "));
346             attributes.addElement (new Attribute ("NAME", paramName.toUpperCase (), '"'));
347             tag = new TagNode (null, 0, 0, attributes);
348             kids.add (tag);
349         }
350         
351         //set kids as new children
352 setChildren (kids);
353     }
354     
355     /**
356      * Output a string representing this object tag.
357      * @return A string showing the contents of the object tag.
358      */
359     public String JavaDoc toString ()
360     {
361         Hashtable JavaDoc parameters;
362         Enumeration JavaDoc params;
363         String JavaDoc paramName;
364         String JavaDoc paramValue;
365         boolean found;
366         Node node;
367         StringBuffer JavaDoc ret;
368         
369         ret = new StringBuffer JavaDoc (500);
370         ret.append ("Object Tag\n");
371         ret.append ("**********\n");
372         ret.append ("ClassId = ");
373         ret.append (getObjectClassId ());
374         ret.append ("\n");
375         ret.append ("CodeBase = ");
376         ret.append (getObjectCodeBase ());
377         ret.append ("\n");
378         ret.append ("CodeType = ");
379         ret.append (getObjectCodeType ());
380         ret.append ("\n");
381         ret.append ("Data = ");
382         ret.append (getObjectData ());
383         ret.append ("\n");
384         ret.append ("Height = ");
385         ret.append (getObjectHeight ());
386         ret.append ("\n");
387         ret.append ("Standby = ");
388         ret.append (getObjectStandby ());
389         ret.append ("\n");
390         ret.append ("Type = ");
391         ret.append (getObjectType ());
392         ret.append ("\n");
393         ret.append ("Width = ");
394         ret.append (getObjectWidth ());
395         ret.append ("\n");
396         parameters = getObjectParams ();
397         params = parameters.keys ();
398         if (null == params)
399             ret.append ("No Params found.\n");
400         else
401             for (int cnt = 0; params.hasMoreElements (); cnt++)
402             {
403                 paramName = (String JavaDoc)params.nextElement ();
404                 paramValue = (String JavaDoc)parameters.get (paramName);
405                 ret.append (cnt);
406                 ret.append (": Parameter name = ");
407                 ret.append (paramName);
408                 ret.append (", Parameter value = ");
409                 ret.append (paramValue);
410                 ret.append ("\n");
411             }
412         found = false;
413         for (SimpleNodeIterator e = children (); e.hasMoreNodes ();)
414         {
415             node = e.nextNode ();
416             if (node instanceof Tag)
417                 if (((Tag)node).getTagName ().equals ("PARAM"))
418                     continue;
419             if (!found)
420                 ret.append ("Miscellaneous items :\n");
421             else
422                 ret.append (" ");
423             found = true;
424             ret.append (node.toString ());
425         }
426         if (found)
427             ret.append ("\n");
428         ret.append ("End of Object Tag\n");
429         ret.append ("*****************\n");
430         
431         return (ret.toString ());
432     }
433 }
434
Popular Tags