CmsXmlNav


1   /*
2   * File   : $Source: /usr/local/cvs/opencms/src-modules/com/opencms/defaults/CmsXmlNav.java,v $
3   * Date   : $Date: 2005/06/27 23:22:23 $
4   * Version: $Revision: 1.4 $
5   *
6   * This library is part of OpenCms -
7   * the Open Source Content Mananagement System
8   *
9   * Copyright (C) 2001  The OpenCms Group
10  *
11  * This library is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * This library is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * Lesser General Public License for more details.
20  *
21  * For further information about OpenCms, please see the
22  * OpenCms Website: http://www.opencms.org
23  *
24  * You should have received a copy of the GNU Lesser General Public
25  * License along with this library; if not, write to the Free Software
26  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
27  */
28  
29  package com.opencms.defaults;
30  
31  import org.opencms.file.CmsObject;
32  import org.opencms.file.CmsPropertyDefinition;
33  import org.opencms.file.CmsResource;
34  import org.opencms.file.CmsResourceFilter;
35  import org.opencms.main.CmsException;
36  import org.opencms.main.OpenCms;
37  import org.opencms.workplace.CmsWorkplace;
38  
39  import com.opencms.legacy.CmsLegacyException;
40  import com.opencms.legacy.CmsXmlTemplateLoader;
41  import com.opencms.template.A_CmsXmlContent;
42  import com.opencms.template.CmsCacheDirectives;
43  import com.opencms.template.CmsXmlTemplateFile;
44  
45  import java.util.ArrayList  ;
46  import java.util.Hashtable  ;
47  import java.util.Iterator  ;
48  import java.util.List  ;
49  import java.util.StringTokenizer  ;
50  import java.util.Vector  ;
51  
52  /**
53   * This class builds the default Navigation.
54   *
55   * @author Alexander Kandzior
56   * @author Waruschan Babachan
57   * @author Thomas Weckert
58   * @version $Revision: 1.4 $ $Date: 2005/06/27 23:22:23 $
59   * 
60   * @deprecated Will not be supported past the OpenCms 6 release.
61   */
62  public class CmsXmlNav extends A_CmsNavBase {
63  
64      /**
65       * Indicates if the results of this class are cacheable.
66       *
67       * @param cms CmsObject Object for accessing system resources
68       * @param templateFile Filename of the template file
69       * @param elementName Element name of this template in our parent template.
70       * @param parameters Hashtable with all template class parameters.
71       * @param templateSelector template section that should be processed.
72       * @return <EM>true</EM> if cacheable, <EM>false</EM> otherwise.
73       */
74      public boolean isCacheable(CmsObject cms, String   templateFile, String   elementName, Hashtable   parameters, String   templateSelector) {
75          return true;
76      }
77  
78  
79  
80      /**
81       * Builds the navigation.<p>
82       *
83       * @param cms CmsObject Object for accessing system resources
84       * @param doc Reference to the A_CmsXmlContent object of the initiating XLM document
85       * @param resources a vector that contains the elements of navigation
86       * @param userObject Hashtable with parameters
87       * @return String that contains the navigation
88       * @throws CmsException if something goes wrong
89       */
90      protected String   buildNav(CmsObject cms, A_CmsXmlContent doc, Object   userObject, List   resources)
91          throws CmsException {
92  
93          // get uri, currentfolder,servletpath and template file
94          String   requestedUri = cms.getRequestContext().getUri();
95          // String currentFolder=cms.readPath(cms.getRequestContext().currentFolder());
96          // String servletPath = CmsXmlTemplateLoader.getRequest(cms.getRequestContext()).getServletUrl();
97          CmsXmlTemplateFile template=(CmsXmlTemplateFile)doc;
98          StringBuffer   result = new StringBuffer  ();
99          int size = resources.size();
100 
101         String   navLink[] = new String  [size];
102         String   navText[] = new String  [size];
103         float navPos[] = new float[size];
104         // extract the navigation according to navigation position and nav text
105         int max=extractNav(cms, resources, navLink, navText, navPos);
106         // The arrays folderNames and folderTitles now contain all folders
107         // that should appear in the nav.
108         // Loop through all folders and generate output
109         for (int i=0; i<max; i++) {
110             template.setData("navtext", navText[i]);
111             template.setData("navcount", new Integer  (i+1).toString());
112             template.setData("navlevel", new Integer  (extractLevel(cms, navLink[i])).toString());
113             // check whether it is a folder or file
114             String   link="";
115             if (navLink[i].endsWith("/")) {
116                 // read the property of folder to find the link file.
117                 String   navIndex=cms.readProperty(navLink[i], C_PROPERTY_NAVINDEX);
118                 // if there is not defined a property then take C_NAVINDEX constant
119                 if (navIndex==null) {
120                     navIndex=C_NAVINDEX;
121                 }
122                 try {
123                     cms.readFile(navLink[i] + navIndex);
124                     link=navLink[i] + navIndex;
125                     template.setData("navlink", OpenCms.getLinkManager().substituteLink(cms, navLink[i] + navIndex));
126                 } catch (CmsException e) {
127                     template.setData("navlink", OpenCms.getLinkManager().substituteLink(cms, requestedUri));
128                 }
129             } else {
130                 try {
131                     cms.readFile(navLink[i]);
132                     link=navLink[i];
133                     template.setData("navlink", OpenCms.getLinkManager().substituteLink(cms, navLink[i]));
134                 } catch (CmsException e) {
135                     template.setData("navlink", OpenCms.getLinkManager().substituteLink(cms, requestedUri));
136                 }
137             }
138             // Check if nav is current nav
139             //if (navLink[i].equals(currentFolder) || navLink[i].equals(requestedUri)) {
140             if (link.equals(requestedUri)) {
141                 result.append(template.getProcessedDataValue("navcurrent", this, userObject));
142             } else {
143                 result.append(template.getProcessedDataValue("naventry", this, userObject));
144             }
145         }
146         return result.toString();
147     }
148     
149     /**
150      * Builds the navigation that could be closed or opened.<p>
151      *
152      * @param cms CmsObject Object for accessing system resources
153      * @param template Reference to the CmsXmTemplateFile object of the initiating XLM document
154      * @param resources a vector that contains the elements of navigation
155      * @param userObject Hashtable with parameters
156      * @param requestedUri The absolute path of current requested file
157      * @param currentFolder The currenet folder
158      * @param servletPath The absolute path of servlet
159      * @param level An Integer that shows how many folders must be displayed.
160      * @param count the nav count
161      * @return String that contains the navigation
162      * @throws CmsException if soemthing goes wrong
163      */
164     protected String   buildNavFold(CmsObject cms, CmsXmlTemplateFile template, Object   userObject, List   resources, String   requestedUri, String   currentFolder, String   servletPath, int level, int[] count)
165         throws CmsException {
166 
167         StringBuffer   result = new StringBuffer  ();
168         // arrays of navigation position, text and link
169         int size = resources.size();
170         String   navLink[] = new String  [size];
171         String   navText[] = new String  [size];
172         float navPos[] = new float[size];
173         // extract the navigation according
174         int max=extractNav(cms, resources, navLink, navText, navPos);
175         if (max>0) {
176             result.append(template.getProcessedDataValue("navstart", this, userObject));
177             for (int i=0; i<max; i++) {
178                 count[0]++;
179                 template.setData("navtext", navText[i]);
180                 template.setData("navcount", new Integer  (count[0]).toString());
181                 // this part is to set the level starting from specified level given as tagcontent
182                 // there it must be make a difference between extracted level and the given level
183                 int extractedLevel=extractLevel(cms, navLink[i]);
184                 template.setData("navlevel", new Integer  (extractedLevel).toString());
185                 /*int rightLevel=extractedLevel;
186                 if (level!=0) {
187                     rightLevel=(extractedLevel-level);
188                     if (rightLevel>=0) {
189                         rightLevel++;
190                     }
191                 }
192                 template.setData("navlevel", new Integer(rightLevel).toString());*/
193                 String   link="";
194                 // check whether the link is folder
195                 if (navLink[i].endsWith("/")) {
196                     // read the property of link file
197                     String   navIndex=cms.readProperty(navLink[i], C_PROPERTY_NAVINDEX);
198                     // if the property is not defined then take C_NAVINDEX constant
199                     if (navIndex==null) {
200                         navIndex=C_NAVINDEX;
201                     }
202                     // read the file, if the file does'nt exist then write the uri as a link
203                     try {
204                         cms.readFile(navLink[i] + navIndex);
205                         link=navLink[i] + navIndex;
206                         template.setData("navlink", OpenCms.getLinkManager().substituteLink(cms, navLink[i] + navIndex));
207                     } catch (CmsException e) {
208                         link=requestedUri;
209                         template.setData("navlink", OpenCms.getLinkManager().substituteLink(cms, requestedUri));
210                     }
211                 } else {
212                     // read the file, if the file does'nt exist then write the uri as a link
213                     try {
214                         cms.readFile(navLink[i]);
215                         link=navLink[i];
216                         template.setData("navlink", OpenCms.getLinkManager().substituteLink(cms, navLink[i]));
217                     } catch (CmsException e) {
218                         link=requestedUri;
219                         template.setData("navlink", OpenCms.getLinkManager().substituteLink(cms, requestedUri));
220                     }
221                 }
222                 // Check if nav is current nav
223                 if (link.equals(requestedUri)) {
224                     result.append(template.getProcessedDataValue("navcurrent", this, userObject));
225                 } else {
226                     result.append(template.getProcessedDataValue("naventry", this, userObject));
227                 }
228                 // if the folder was clicked
229                 if (requestedUri.indexOf(navLink[i])!=-1) {
230                     List   all=cms.getSubFolders(navLink[i]);
231                     List   files=cms.getFilesInFolder(navLink[i]);
232                     // register this folder for changes (if it is a folder!)
233                     if (navLink[i].endsWith("/")) {
234                         Vector   vfsDeps = new Vector  ();
235                         vfsDeps.add(cms.readFolder(navLink[i]));
236                         registerVariantDeps(cms, template.getAbsoluteFilename(), null, null,
237                                         (Hashtable  )userObject, vfsDeps, null, null);
238                     }
239                     ((ArrayList  )all).ensureCapacity(all.size() + files.size());
240                     Iterator   e = files.iterator();
241                     while (e.hasNext()) {
242                         all.add(e.next());
243                     }
244                     result.append(buildNavFold(cms, template, userObject, all, requestedUri, currentFolder, servletPath, level, count));
245                 }
246             }
247             result.append(template.getProcessedDataValue("navend", this, userObject));
248         }
249 
250         return result.toString();
251 
252     }
253 
254     /**
255      * Builds the tree of navigation.
256      *
257      * @param cms CmsObject Object for accessing system resources
258      * @param template Reference to the CmsXmTemplateFile object of the initiating XML document
259      * @param resources a vector that contains the elements of navigation
260      * @param userObject Hashtable with parameters
261      * @param requestedUri The absolute path of current requested file
262      * @param currentFolder The currenet folder
263      * @param servletPath The absolute path of servlet
264      * @param level The starting level
265      * @param depth An Integer that shows how many folders must be displayed
266      * @param depthIsNull a boolean that determines whether the depth is given in tagcontent
267      * @param count the nav count
268      * @return String that contains the navigation
269      * @throws CmsException if something goes wrong
270      */
271     protected String   buildNavTree(CmsObject cms, CmsXmlTemplateFile template, Object   userObject, List   resources, String   requestedUri, String   currentFolder, String   servletPath, int level, int depth, boolean depthIsNull, int[] count)
272         throws CmsException {
273 
274         StringBuffer   result = new StringBuffer  ();
275         // define some array for link,text and position of
276         // the elements of navigation
277         int size = resources.size();
278         String   navLink[] = new String  [size];
279         String   navText[] = new String  [size];
280         float navPos[] = new float[size];
281         // extract the navigation from the given resources, i.e. it will be showed
282         // if the elements of that resources must be showed in navigation, i.e.
283         // wheather navigation Text und navigation position are defined for an element
284         int max=extractNav(cms, resources, navLink, navText, navPos);
285         // check wheather there is some elements
286         if (max>0) {
287             result.append(template.getProcessedDataValue("navstart", this, userObject));
288             for (int i=0; i<max; i++) {
289                 // set the templates
290                 count[0]++;
291                 template.setData("navtext", navText[i]);
292                 template.setData("navcount", new Integer  (count[0]).toString());
293                 // this part is to set the level starting from specified level given as tagcontent
294                 // there it must be make a difference between extracted level and the given level
295                 int extractedLevel=extractLevel(cms, navLink[i]);
296                 template.setData("navlevel", new Integer  (extractedLevel).toString());
297                 /*int rightLevel=extractedLevel;
298                 if (level!=0) {
299                     rightLevel=(extractedLevel-level);
300                     if (rightLevel>=0) {
301                         rightLevel++;
302                     }
303                 }
304                 template.setData("navlevel", new Integer(rightLevel).toString());*/
305                 String   link="";
306                 // Check whether the link is a folder
307                 if (navLink[i].endsWith("/")) {
308                     // read the property of folder to find the link file.
309                     String   navIndex=cms.readProperty(navLink[i], C_PROPERTY_NAVINDEX);
310                     // if there is not defined a property then take C_NAVINDEX constant
311                     if (navIndex==null || (navIndex!=null && navIndex.equals(""))) {
312                         navIndex=C_NAVINDEX;
313                     }
314                     // check whether the file exist, if not then the link is current uri
315                     try {
316                         cms.readFile(navLink[i] + navIndex);
317                         link=navLink[i] + navIndex;
318                         template.setData("navlink", OpenCms.getLinkManager().substituteLink(cms, navLink[i] + navIndex));
319                     } catch (CmsException e) {
320                         link=requestedUri;
321                         template.setData("navlink", OpenCms.getLinkManager().substituteLink(cms, requestedUri));
322                     }
323                 } else {
324                     // check whether the file exist, if not then the link is current uri
325                     try {
326                         cms.readFile(navLink[i]);
327                         link=navLink[i];
328                         template.setData("navlink", OpenCms.getLinkManager().substituteLink(cms, navLink[i]));
329                     } catch (CmsException e) {
330                         link=requestedUri;
331                         template.setData("navlink", OpenCms.getLinkManager().substituteLink(cms, requestedUri));
332                     }
333                 }
334                 // Check if nav is current nav
335                 if (link.equals(requestedUri)) {
336                     result.append(template.getProcessedDataValue("navcurrent", this, userObject));
337                 } else {
338                     result.append(template.getProcessedDataValue("naventry", this, userObject));
339                 }
340                 // redurce the depth and test if it is now zero or is the depth
341                 // given as tagcontent or not.
342                 // if the depth is not given in tagcontent then the depth variable must be ignored
343                 // the user don't want to give depth otherwise the depth must be considered
344                 // because it must not be exceeded the limit that user has defined.
345                 depth--;
346                 if (depthIsNull || depth>=0) {
347                     if (navLink[i].endsWith("/")) {
348                         List   all=cms.getSubFolders(navLink[i]);
349                         List   files=cms.getFilesInFolder(navLink[i]);
350                         // register this folder for changes
351                         Vector   vfsDeps = new Vector  ();
352                         vfsDeps.add(cms.readFolder(navLink[i]));
353                         registerVariantDeps(cms, template.getAbsoluteFilename(), null, null,
354                                         (Hashtable  )userObject, vfsDeps, null, null);
355                         ((ArrayList  )all).ensureCapacity(all.size() + files.size());
356                         Iterator   e = files.iterator();
357                         while (e.hasNext()) {
358                             all.add(e.next());
359                         }
360                         result.append(buildNavTree(cms, template, userObject, all, requestedUri, currentFolder, servletPath, level, depth, depthIsNull, count));
361                     }
362                 }
363             }
364             result.append(template.getProcessedDataValue("navend", this, userObject));
365         }
366         return result.toString();
367     }
368     /**
369      * Builds the link to folder determined by level.
370      *
371      * @param cms CmsObject Object for accessing system resources
372      * @param level The level of folder
373      * @param exact this parameter determines wheater exact level of folder must be exctracted
374      * @return String that contains the path of folder determind by level
375      * @throws CmsException if something goes wrong
376      */
377     protected String   extractFolder(CmsObject cms, int level, String   exact)
378         throws CmsException {
379 
380         // get uri and requested uri
381         String   navIndex=C_NAVINDEX;
382         try {
383             navIndex=cms.readProperty(CmsResource.getFolderPath(cms.getRequestContext().getUri()), C_PROPERTY_NAVINDEX);
384             navIndex=((navIndex==null || (navIndex!=null && navIndex.equals("")))?C_NAVINDEX:navIndex);
385         } catch (Exception   err) {
386             navIndex=C_NAVINDEX;
387         }
388         String   uri=CmsResource.getFolderPath(cms.getRequestContext().getUri())+navIndex;
389         String   requestedUri=cms.getRequestContext().getUri();
390         // get count of folder
391         String   currentFolder="/";
392         StringTokenizer   st = new StringTokenizer  (CmsResource.getFolderPath(cms.getRequestContext().getUri()), "/");
393         int count=st.countTokens()+1;
394         // if the level is negative then take the folder starting from
395         // current folder otherwise take the folder starting from root
396         if (level<0) {
397             level=(-1)*level;
398             level=count-level;
399         }
400         // increment count to get real level
401         if (exact.equals("true") && (level<=0 || level>count || (level==count && requestedUri.equals(uri)))) {
402             return "";
403         }
404         // ulrich.rueth@gmx.de: this seems to have been the reason for the navigation
405         // not displaying correctly in top-level index.html files!
406         //if (level==count && requestedUri.equals(uri)) {
407         //    level--;
408         //}
409         while (st.hasMoreTokens()) {
410             if (level>1) {
411                 currentFolder=currentFolder+st.nextToken()+"/";
412                 level--;
413             } else {
414                 break;
415             }
416         }
417         return currentFolder;
418     }
419     /**
420      * Extract the level of navigation.<p>
421      *
422      * @param cms Object for accessing system resources
423      * @param folder the folder to extract the level
424      * @return int that contains the level
425      * @throws CmsException if something goes wrong
426      */
427     protected int extractLevel(CmsObject cms, String   folder)
428         throws CmsException {
429         StringTokenizer   st = new StringTokenizer  (folder, "/");
430         int count=st.countTokens();
431         count=(count==0?1:count);
432         return count;
433     }
434     /**
435      * Extracts the navbar.<p>
436      *
437      * @param cms CmsObject Object for accessing system resources
438      * @param resources a vector that contains the elements of navigation
439      * @param navLink an array of navigation's link
440      * @param navText an array of navigation's Text
441      * @param navPos an array of position of navbar
442      * @return The maximum number of navbars in navigation
443      * @throws CmsException if something goes wrong
444      */
445     protected int extractNav(CmsObject cms, List   resources, String  [] navLink, String  [] navText, float[] navPos)
446         throws CmsException {
447 
448         String   requestedUri = cms.getRequestContext().getUri();
449 
450         int size = resources.size();
451         int max = 0;
452 
453         // First scan all subfolders of the root folder
454         // for any navigation metainformations and store
455         // the maximum position found
456         for (int i=0; i<size; i++) {
457             CmsResource currentResource = (CmsResource)resources.get(i);
458             String   path = cms.getSitePath(currentResource);
459             String   pos = cms.readProperty(path, CmsPropertyDefinition.PROPERTY_NAVPOS);
460             String   text = cms.readProperty(path, CmsPropertyDefinition.PROPERTY_NAVTEXT);
461             // Only list folders in the nav bar if they are not deleted!
462             if (currentResource.getState() != CmsResource.STATE_DELETED) {
463                 // don't list the temporary folders in the nav bar!
464                 if (pos != null && text != null && (!"".equals(pos)) && (!"".equals(text))
465                      && ((!currentResource.getName().startsWith(CmsWorkplace.TEMP_FILE_PREFIX)) || path.equals(requestedUri))) {
466                     navLink[max] = path;
467                     navText[max] = text;
468                     navPos[max] = new Float  (pos).floatValue();
469                     max++;
470                 }
471             }
472         }
473 
474         // Sort the navigation
475         sortNav(max, navLink, navText, navPos);
476 
477         return max;
478     }
479     /**
480      * Gets the current folder.<p>
481      *
482      * @param cms CmsObject Object for accessing system resources
483      * @param tagcontent Unused in this special case of a user method. Can be ignored
484      * @param doc Reference to the A_CmsXmlContent object of the initiating XLM document
485      * @param userObject Hashtable with parameters
486      * @return byte[] with the content of this subelement
487      * @throws CmsException if something goes wrong
488      */
489     public Object   getFolderCurrent(CmsObject cms, String   tagcontent, A_CmsXmlContent doc, Object   userObject)
490             throws CmsException {
491 
492         String   currentFolder=CmsResource.getFolderPath(cms.getRequestContext().getUri());
493         currentFolder=CmsXmlTemplateLoader.getRequest(cms.getRequestContext()).getServletUrl() + currentFolder;
494         return currentFolder.getBytes();
495     }
496     /**
497      * gets the parent folder.
498      *
499      * @param cms CmsObject Object for accessing system resources.
500      * @param tagcontent Unused in this special case of a user method. Can be ignored.
501      * @param doc Reference to the A_CmsXmlContent object of the initiating XLM document.
502      * @param userObject Hashtable with parameters.
503      * @return byte[] with the content of this subelement.
504      * @throws CmsException if something goes wrong
505      */
506     public Object   getFolderParent(CmsObject cms, String   tagcontent, A_CmsXmlContent doc, Object   userObject)
507             throws CmsException {
508 
509         int level=1;
510         // tagcontent determines the folder starting from parent folder.
511         // if tagcontent is null, zero or negative, then the navigation of current
512         // folder must be showed.
513         String   exact="false";
514         // tagcontent determines the folder starting from root folder.
515         // if tagcontent is null, then the navigation of root folder must be showed.
516         if (!tagcontent.equals("")) {
517             try {
518                 if (tagcontent.indexOf(",")!=-1) {
519                     level=Integer.parseInt(tagcontent.substring(0, tagcontent.indexOf(",")));
520                     exact=tagcontent.substring(tagcontent.indexOf(",")+1).toLowerCase();
521                 } else {
522                     level=Integer.parseInt(tagcontent);
523                 }
524             } catch (NumberFormatException   e) {
525                 level=1;
526                 exact=tagcontent.toLowerCase();
527                 if (!exact.equals("true")) {
528                     exact="false";
529                 }
530             }
531         }
532         String   currentFolder=extractFolder(cms, ((-1)*level), exact);
533         if (currentFolder.equals(""))
534             return "".getBytes();
535         String   parentFolder=CmsXmlTemplateLoader.getRequest(cms.getRequestContext()).getServletUrl() + currentFolder;
536         return parentFolder.getBytes();
537     }
538     /**
539      * gets the root folder.
540      *
541      * @param cms CmsObject Object for accessing system resources
542      * @param tagcontent Unused in this special case of a user method. Can be ignored
543      * @param doc Reference to the A_CmsXmlContent object of the initiating XLM document
544      * @param userObject Hashtable with parameters
545      * @return byte[] with the content of this subelement
546      * @throws CmsException if something goes wrong
547      */
548     public Object   getFolderRoot(CmsObject cms, String   tagcontent, A_CmsXmlContent doc, Object   userObject)
549             throws CmsException {
550 
551         int level=1;
552         String   exact="false";
553         // tagcontent determines the folder starting from root folder.
554         // if tagcontent is null, then the navigation of root folder must be showed.
555         if (!tagcontent.equals("")) {
556             try {
557                 if (tagcontent.indexOf(",")!=-1) {
558                     level=Integer.parseInt(tagcontent.substring(0, tagcontent.indexOf(",")));
559                     exact=tagcontent.substring(tagcontent.indexOf(",")+1).toLowerCase();
560                 } else {
561                     level=Integer.parseInt(tagcontent);
562                 }
563             } catch (NumberFormatException   e) {
564                 level=1;
565                 exact=tagcontent.toLowerCase();
566                 if (!exact.equals("true")) {
567                     exact="false";
568                 }
569             }
570         }
571         String   currentFolder=extractFolder(cms, level, exact);
572         if (currentFolder.equals(""))
573             return "".getBytes();
574         String   rootFolder=CmsXmlTemplateLoader.getRequest(cms.getRequestContext()).getServletUrl() + currentFolder;
575         return rootFolder.getBytes();
576     }
577     /**
578      * gets the navigation of current folder.<p>
579      *
580      * @param cms CmsObject Object for accessing system resources
581      * @param tagcontent Unused in this special case of a user method. Can be ignored
582      * @param doc Reference to the A_CmsXmlContent object of the initiating XLM document
583      * @param userObject Hashtable with parameters
584      * @return byte[] with the content of this subelement
585      * @throws CmsException if something goes wrong
586      */
587     public Object   getNavCurrent(CmsObject cms, String   tagcontent, A_CmsXmlContent doc, Object   userObject)
588             throws CmsException {
589         // template file
590         CmsXmlTemplateFile template=(CmsXmlTemplateFile)doc;
591         // check whether there exist entry datablock
592         if (!template.hasData("naventry")) {
593             return "".getBytes();
594         }
595         String   currentFolder=CmsResource.getFolderPath(cms.getRequestContext().getUri());
596         int level=extractLevel(cms, currentFolder)+1;
597         String   exact="false";
598         // tagcontent determines the folder starting from root folder.
599         // if tagcontent is null, then the navigation of root folder must be showed.
600         if (!tagcontent.equals("")) {
601             try {
602                 if (tagcontent.indexOf(",")!=-1) {
603                     level=Integer.parseInt(tagcontent.substring(0, tagcontent.indexOf(",")));
604                     exact=tagcontent.substring(tagcontent.indexOf(",")+1).toLowerCase();
605                 } else {
606                     level=Integer.parseInt(tagcontent);
607                 }
608             } catch (NumberFormatException   e) {
609                 level=extractLevel(cms, currentFolder)+1;
610                 exact=tagcontent.toLowerCase();
611                 if (!exact.equals("true")) {
612                     exact="false";
613                 }
614             }
615         }
616         // get the folder of level
617         currentFolder="/";
618         StringTokenizer   st = new StringTokenizer  (CmsResource.getFolderPath(cms.getRequestContext().getUri()), "/");
619         int count=st.countTokens()+1;
620         if (exact.equals("true") && level!=count) {
621             return "".getBytes();
622         }
623         while (st.hasMoreTokens()) {
624             if (level>1) {
625                 currentFolder=currentFolder+st.nextToken()+"/";
626                 level--;
627             } else {
628                 break;
629             }
630         }
631         // register this folder for changes
632         Vector   vfsDeps = new Vector  ();
633         vfsDeps.add(cms.readFolder(currentFolder));
634         registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null,
635                         (Hashtable  )userObject, vfsDeps, null, null);
636         // get all resources in current folder
637         List   resources=cms.getSubFolders(currentFolder);
638         List   allFile=cms.getFilesInFolder(currentFolder);
639         ((ArrayList  )resources).ensureCapacity(resources.size() + allFile.size());
640         Iterator   e = allFile.iterator();
641         while (e.hasNext()) {
642             resources.add(e.next());
643         }
644         // if there is not exist current datablock then take the entry datablock
645         if (!template.hasData("navcurrent")) {
646             template.setData("navcurrent", template.getData("naventry"));
647         }
648         return buildNav(cms, doc, userObject, resources).getBytes();
649     }
650     /**
651      * gets the navigation of files and folders,
652      * by folders it is showed closed, if the folder is clicked then it is opened.<p>
653      *
654      * @param cms CmsObject Object for accessing system resources
655      * @param tagcontent used in this special case of a user method. Can't be ignored
656      * @param doc Reference to the A_CmsXmlContent object of the initiating XLM document
657      * @param userObject Hashtable with parameters
658      * @return byte[] with the content of this subelement
659      * @throws CmsException if something goes wrong
660      */
661     public Object   getNavFold(CmsObject cms, String   tagcontent, A_CmsXmlContent doc, Object   userObject)
662             throws CmsException {
663         // template file
664         CmsXmlTemplateFile template=(CmsXmlTemplateFile)doc;
665         // check whether there exist entry datablock
666         if (!template.hasData("naventry")) {
667             return "".getBytes();
668         }
669         int level=1;
670         int[] count={0};
671         String   exact="false";
672         // if level is zero or null or negative then all folders recursive must
673         // be showed starting from root folder unless all folders stating from
674         // specified level of parent folder.
675         if (!tagcontent.equals("")) {
676             try {
677                 if (tagcontent.indexOf(",")!=-1) {
678                     level=Integer.parseInt(tagcontent.substring(0, tagcontent.indexOf(",")));
679                     exact=tagcontent.substring(tagcontent.indexOf(",")+1).toLowerCase();
680                 } else {
681                     level=Integer.parseInt(tagcontent);
682                 }
683             } catch (NumberFormatException   e) {
684                 level=1;
685                 exact=tagcontent.toLowerCase();
686                 if (!exact.equals("true")) {
687                     exact="false";
688                 }
689             }
690         }
691         // extract the folder
692         String   folder=extractFolder(cms, level, exact);
693         if (folder.equals(""))
694             return "".getBytes();
695         //}
696         // get uri, current folder, servletpath
697         String   requestedUri = cms.getRequestContext().getUri();
698         String   currentFolder=CmsResource.getFolderPath(cms.getRequestContext().getUri());
699         String   servletPath = CmsXmlTemplateLoader.getRequest(cms.getRequestContext()).getServletUrl();
700         // register this folder for changes
701         Vector   vfsDeps = new Vector  ();
702         vfsDeps.add(cms.readFolder(folder));
703         registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null,
704                         (Hashtable  )userObject, vfsDeps, null, null);
705         // get all resources
706         List   resources=cms.getSubFolders(folder);
707         List   allFile=cms.getFilesInFolder(folder);
708         ((ArrayList  )resources).ensureCapacity(resources.size() + allFile.size());
709         Iterator   e = allFile.iterator();
710         while (e.hasNext()) {
711             resources.add(e.next());
712         }
713 
714         String   result="";
715         // check wheather xml data blocks are defined.
716         if (!template.hasData("navcurrent")) {
717             template.setData("navcurrent", template.getData("naventry"));
718         }
719         if (!template.hasData("navstart")) {
720             template.setData("navstart", "");
721         }
722         if (!template.hasData("navend")) {
723             template.setData("navend", "");
724         }
725         result=buildNavFold(cms, template, userObject, resources, requestedUri, currentFolder, servletPath, level, count);
726 
727         return result.getBytes();
728     }
729     /**
730      * gets the navigation of specified level of parent folder.<p>
731      *
732      * @param cms CmsObject Object for accessing system resources
733      * @param tagcontent used in this special case of a user method. Can't be ignored
734      * @param doc Reference to the A_CmsXmlContent object of the initiating XLM document
735      * @param userObject Hashtable with parameters
736      * @return byte[] with the content of this subelement
737      * @throws CmsException if something goes wrong
738      */
739     public Object   getNavParent(CmsObject cms, String   tagcontent, A_CmsXmlContent doc, Object   userObject)
740             throws CmsException {
741 
742         // template file
743         CmsXmlTemplateFile template=(CmsXmlTemplateFile)doc;
744         // check whether there exist entry datablock
745         if (!template.hasData("naventry")) {
746             return "".getBytes();
747         }
748         int level=1;
749         String   exact="";
750         // tagcontent determines the folder starting from parent folder.
751         // if tagcontent is null, zero or negative, then the navigation of current
752         // folder must be showed.
753         if (!tagcontent.equals("")) {
754             try {
755                 if (tagcontent.indexOf(",")!=-1) {
756                     level=Integer.parseInt(tagcontent.substring(0, tagcontent.indexOf(",")));
757                     exact=tagcontent.substring(tagcontent.indexOf(",")+1).toLowerCase();
758                 } else {
759                     level=Integer.parseInt(tagcontent);
760                 }
761             } catch (NumberFormatException   e) {
762                 level=1;
763                 exact=tagcontent.toLowerCase();
764                 if (!exact.equals("true")) {
765                     exact="false";
766                 }
767             }
768         }
769         // level is converted to negative number, so I can use the method
770         // "extractFolder" for positive and negative numbers. Negative number
771         // determines the parent folder level starting from current folder and
772         // positive number determines the level starting ftom root folder.
773         String   currentFolder=extractFolder(cms, ((-1)*level), exact);
774         if (currentFolder.equals(""))
775             return "".getBytes();
776         // register this folder for changes
777         Vector   vfsDeps = new Vector  ();
778         vfsDeps.add(cms.readFolder(currentFolder));
779         registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null,
780                         (Hashtable  )userObject, vfsDeps, null, null);
781         List   resources=cms.getSubFolders(currentFolder);
782         List   allFile=cms.getFilesInFolder(currentFolder);
783 
784         ((ArrayList  )resources).ensureCapacity(resources.size() + allFile.size());
785         Iterator   e = allFile.iterator();
786         while (e.hasNext()) {
787             resources.add(e.next());
788         }
789         // if there is not exist current datablock then take the entry datablock
790         if (!template.hasData("navcurrent")) {
791             template.setData("navcurrent", template.getData("naventry"));
792         }
793         return buildNav(cms, doc, userObject, resources).getBytes();
794     }
795 
796     /**
797      * gets the navigation of root folder or parent folder starting from root folder.<p>
798      *
799      * @param cms CmsObject Object for accessing system resources
800      * @param tagcontent Unused in this special case of a user method. Can be ignored
801      * @param doc Reference to the A_CmsXmlContent object of the initiating XLM document
802      * @param userObject Hashtable with parameters
803      * @return byte[] with the content of this subelement
804      * @throws CmsException if something goes wrong
805      */
806     public Object   getNavRoot(CmsObject cms, String   tagcontent, A_CmsXmlContent doc, Object   userObject)
807             throws CmsException {
808 
809         // template file
810         CmsXmlTemplateFile template=(CmsXmlTemplateFile)doc;
811         // check whether there exist entry datablock
812         if (!template.hasData("naventry")) {
813             return "".getBytes();
814         }
815         int level=1;
816         String   exact="false";
817         // tagcontent determines the folder starting from root folder.
818         // if tagcontent is null, then the navigation of root folder must be showed.
819         if (!tagcontent.equals("")) {
820             try {
821                 if (tagcontent.indexOf(",")!=-1) {
822                     level=Integer.parseInt(tagcontent.substring(0, tagcontent.indexOf(",")));
823                     exact=tagcontent.substring(tagcontent.indexOf(",")+1).toLowerCase();
824                 } else {
825                     level=Integer.parseInt(tagcontent);
826                 }
827             } catch (NumberFormatException   e) {
828                 level=1;
829                 exact=tagcontent.toLowerCase();
830                 if (!exact.equals("true")) {
831                     exact="false";
832                 }
833             }
834         }
835         String   currentFolder=extractFolder(cms, level, exact);
836         if (currentFolder.equals(""))
837             return "".getBytes();
838         // register this folder for changes
839         Vector   vfsDeps = new Vector  ();
840         vfsDeps.add(cms.readFolder(currentFolder));
841         registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null,
842                         (Hashtable  )userObject, vfsDeps, null, null);
843         // get all resources, it means all files and folders.
844         List   resources=cms.getSubFolders(currentFolder);
845         List   allFile=cms.getFilesInFolder(currentFolder);
846         ((ArrayList  )resources).ensureCapacity(resources.size() + allFile.size());
847         Iterator   e = allFile.iterator();
848         while (e.hasNext()) {
849             resources.add(e.next());
850         }
851         // if there is not exist current datablock then take the entry datablock
852         if (!template.hasData("navcurrent")) {
853             template.setData("navcurrent", template.getData("naventry"));
854         }
855         return buildNav(cms, doc, userObject, resources).getBytes();
856     }
857     
858     /**
859      * Builds the path from the root folder down to the current folder. Usage:
860      * <p>
861      * Build the path from the root folder down to the current folder:  
862      * <pre>&lt;METHOD name="getNavPath"&gt;absolute,this,0&lt;/METHOD&gt;</pre>
863      * <p>
864      * Build the path from the root folder down to the parent of the current folder:
865      * <pre>&lt;METHOD name="getNavPath"&gt;absolute,parent,0&lt;/METHOD&gt;</pre>
866      * <p>
867      * Build the path for the last three navigation levels down to the parent of the current folder:
868      * <pre>&lt;METHOD name="getNavPath"&gt;relative,parent,3&lt;/METHOD&gt;</pre>
869      * <p>
870      * Build the path for the last three navigation levels down to the current folder: 
871      * <pre>&lt;METHOD name="getNavPath"&gt;relative,this,3&lt;/METHOD&gt;</pre>
872      * 
873      * @param cms CmsObject to access the VFS
874      * @param tagcontent includes the values for the start and end navigation level, comma separated
875      * @param doc the XML template
876      * @param userObject Hashtable with parameters (??)
877      * @return byte[] the HTML of this element
878      * @throws CmsException if something goes wrong
879      */
880     public Object   getNavPath(CmsObject cms, String   tagcontent, A_CmsXmlContent doc, Object   userObject) throws CmsException {        
881         // the result string holding the entire generated navigation path
882         String   navPath = "";
883 
884         // get the template file
885         CmsXmlTemplateFile template = (CmsXmlTemplateFile)doc;
886         
887         // start absolute from root, or relative from the current folder?
888         boolean startAbsolute = true;
889         
890         // the depth of the navigation path (= # of navigation levels)
891         int requestedNavLevels = 1;
892         
893         // include the current folder in the path or not
894         boolean includeCurrentFolder = true;
895         
896         // the navigation levels where we start and end to calculate the path
897         int startLevel = 0, endLevel = 0;
898       
899         
900         // if there is no "naventry" datablock in the template, return an empty string
901         if (!template.hasData("naventry")) {
902             return "".getBytes();
903         }    
904         
905         // if there is no "navcurrent" datablock in the template, use the "naventry" instead
906         if (!template.hasData("navcurrent")) {
907             template.setData("navcurrent", template.getData("naventry"));
908         }  
909         
910         // parse the tag content
911         if (!"".equals(tagcontent)) {
912             StringTokenizer   tagContentTokenizer = new StringTokenizer  (tagcontent, ",");
913             
914             if (tagContentTokenizer.countTokens()>=3) {
915                 // start absolute or relative?
916                 if (tagContentTokenizer.hasMoreTokens()) {
917                     startAbsolute = tagContentTokenizer.nextToken().trim().equalsIgnoreCase("absolute");
918                 }
919                 
920                 // include the current folder or not?
921                 if (tagContentTokenizer.hasMoreTokens()) {
922                     includeCurrentFolder = tagContentTokenizer.nextToken().trim().equalsIgnoreCase("this");
923                 }                
924                 
925                 // max. depth
926                 if (tagContentTokenizer.hasMoreTokens()) {
927                     try {
928                         requestedNavLevels = Integer.parseInt(tagContentTokenizer.nextToken());
929                     } catch (Exception   e) {
930                         requestedNavLevels = 1;
931                     }
932                 } 
933             }                       
934         }           
935         
936         // get the requested folder
937         String   requestedFolder = CmsResource.getFolderPath(cms.getRequestContext().getUri());
938         
939         // calculate the end navigation level in the path
940         endLevel = extractLevel(cms, requestedFolder);
941         if (includeCurrentFolder) {
942             endLevel++;
943         }        
944         
945         // calculate the start navigation level in the path
946         if (startAbsolute) {
947             startLevel = 1;
948         } else {
949             startLevel = endLevel - requestedNavLevels + 1;
950         }        
951                 
952         for (int i=startLevel; i<=endLevel; i++) {
953             String   currentFolder = extractFolder(cms, i, "false");
954             
955             // register the current folder for changes in the beloved element cache
956             Vector   vfsDeps = new Vector  ();
957             vfsDeps.add(cms.readFolder(currentFolder));
958             registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null, (Hashtable  )userObject, vfsDeps, null, null);
959             
960             // add the current folder as the unique resource
961             Vector   resources = new Vector  ();       
962             resources.addElement(cms.readFolder(currentFolder, CmsResourceFilter.ALL));                             
963             
964             // build the navigation for the current folder and append to the path
965             String   currentNav = buildNav(cms, doc, userObject, resources);
966             navPath += currentNav;          
967         }
968 
969         return navPath.getBytes();
970     }   
971     
972     /**
973      * Builds a catalogue or navigation sitemap. Usage: 
974      * <pre>&lt;method name="getNavMap"&gt;1,3&lt;/method&gt;</pre> to build
975      * a sitemap including everything between navigation levels 1 and 3.<p>
976      * 
977      * @param cms CmsObject to access the VFS
978      * @param tagcontent includes the values for the start and end navigation level, comma separated
979      * @param doc the XML template
980      * @param userObject Hashtable with parameters (??)
981      * @return byte[] the HTML of this element
982      * @throws CmsException if something goes wrong
983      */    
984     public Object   getNavMap(CmsObject cms, String   tagcontent, A_CmsXmlContent doc, Object   userObject) throws CmsException {                   
985         // the result string holding the entire generated HTML of the navigation map
986         String   navMap = "";   
987         
988         // the navigation level where the map starts
989         int startLevel = 1;
990         
991         // dito, where the map ends
992         int endLevel = 2; 
993         
994         // get the template file
995         CmsXmlTemplateFile template = (CmsXmlTemplateFile)doc;
996         
997         // if there is no "naventry" datablock in the template, return an empty string
998         if (!template.hasData("naventry")) {
999             return "".getBytes();
1000        }    
1001        
1002        // if there is no "navcurrent" datablock in the template, use the "naventry" instead
1003        if (!template.hasData("navcurrent")) {
1004            template.setData("navcurrent", template.getData("naventry"));
1005        }        
1006        
1007        
1008        // parse the tag content
1009        if (!"".equals(tagcontent)) {
1010            int commaIndex = tagcontent.indexOf(",");
1011            
1012            if (commaIndex!=-1 && tagcontent.length()>=3) {
1013                try {
1014                    startLevel = Integer.parseInt(tagcontent.substring(0, commaIndex));
1015                    endLevel = Integer.parseInt(tagcontent.substring(commaIndex+1));
1016                } catch (Exception   e) {
1017                    // use default values in case of an exception
1018                    startLevel = 1;
1019                    endLevel = 2; 
1020                }
1021            }
1022        }
1023        
1024        // # of navigation levels needed to build the map
1025        int recursion = endLevel - startLevel;
1026        
1027        // extract the folder at the right depth where we want to start
1028        String   currentFolder = extractFolder(cms, startLevel, "false");                         
1029        
1030        // build the map finally
1031        navMap = this.buildMap(cms, doc, userObject, currentFolder, "naventry", 0, recursion).toString();
1032        
1033        return navMap.getBytes();
1034    } 
1035    
1036    /**
1037     * This method invokes recursively itself to build a catalogue or map of the OpenCms
1038     * VFS structure. For each navigation level, it tries to process the datablock
1039     * naventry, naventrysub, naventrysubsub,...,naventry{n*times}sub for a depth of n levels.
1040     * 
1041     * @param cms CmsObject object for accessing the VFS
1042     * @param doc the XML template holding the datablock to process
1043     * @param userObject Hashtable with parameters
1044     * @param currentFolder the current folder for which we build the (sub) map 
1045     * @param datablock the name of the datablock in the XML template to generate the HTML for the current depth
1046     * @param currentResursionLevel the name says it all: the current recursion level (= curr. navigation level)
1047     * @param maxRecursionLevel dito, the max. recursion level (= navigation level depth)
1048     * @return byte[] the HTML of this element
1049     * @throws CmsException if something goes wrong
1050     */
1051    protected StringBuffer   buildMap(CmsObject cms, A_CmsXmlContent doc, Object   userObject, String   currentFolder, String   datablock, int currentResursionLevel, int maxRecursionLevel) throws CmsException {
1052        StringBuffer   result = new StringBuffer  ();
1053        CmsXmlTemplateFile template = (CmsXmlTemplateFile)doc;
1054        boolean isFolder = false;
1055        
1056        // register the current folder for changes in the beloved element cache
1057        Vector   vfsDeps = new Vector  ();
1058        vfsDeps.add(cms.readFolder(currentFolder));
1059        registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null, (Hashtable  )userObject, vfsDeps, null, null);        
1060     
1061        // collect all files and subfolders
1062        List   resources = cms.getSubFolders(currentFolder);       
1063        List   files = cms.getFilesInFolder(currentFolder);
1064        ((ArrayList  )resources).ensureCapacity(resources.size() + files.size());
1065        
1066        Iterator   allFiles = files.iterator();
1067        while (allFiles.hasNext()) {
1068            resources.add(allFiles.next());
1069        }    
1070        
1071        // evaluate the navigation properties properties
1072        int size = resources.size();
1073        String   navLink[] = new String  [size];
1074        String   navText[] = new String  [size];
1075        float navPos[] = new float[size];
1076        int navResourceCount = extractNav(cms, resources, navLink, navText, navPos);  
1077        
1078        for (int i=0; i<navResourceCount; i++) {
1079            isFolder = false;
1080            String   currentNavLink = null;
1081            
1082            // set the navigation data/properties in the template
1083            template.setData("navtext", navText[i]);
1084            template.setData("navcount", new Integer  (i+1).toString());
1085            template.setData("navlevel", new Integer  (extractLevel(cms, navLink[i])).toString());
1086            
1087            if (navLink[i].endsWith("/")) {
1088                // the current resource is a folder
1089                isFolder = true;
1090                
1091                String   navIndex = cms.readProperty(navLink[i], C_PROPERTY_NAVINDEX);
1092                if (navIndex==null) {
1093                    navIndex = C_NAVINDEX;
1094                }
1095                
1096                currentNavLink = navLink[i] + navIndex;
1097            } else {
1098                // the current resource is a file
1099                currentNavLink = navLink[i];
1100            }
1101            
1102            // test if the file exists or not to avoid broken links
1103            try {
1104                cms.readFile(currentNavLink);
1105                template.setData("navlink", OpenCms.getLinkManager().substituteLink(cms, currentNavLink));
1106            } catch (CmsException e) {
1107                template.setData("navlink", "#");
1108            }       
1109            
1110            // append the resource itself to the map
1111            result.append(template.getProcessedDataValue(datablock, this, userObject));
1112            
1113            // append the resource's submap, too
1114            if (isFolder && (currentResursionLevel + 1 <= maxRecursionLevel)) {
1115                String   subMapNavEntryDatablock = "naventry";
1116                for (int j = 0; j <= currentResursionLevel; j++) {
1117                    subMapNavEntryDatablock += "sub";
1118                }
1119                
1120                // if there is no "naventrysubsub..." datablock in the template, use the "naventry" instead
1121                if (!template.hasData(subMapNavEntryDatablock)) {
1122                    subMapNavEntryDatablock = "naventry";
1123                }                
1124
1125                StringBuffer   subMap = this.buildMap(cms, doc, userObject, navLink[i], subMapNavEntryDatablock, currentResursionLevel+1, maxRecursionLevel);               
1126                result.append(subMap.toString());
1127            }
1128        }          
1129        
1130        return result;      
1131    }    
1132    
1133    /**
1134     * gets the navigation of folders recursive.<p>
1135     *
1136     * @param cms CmsObject Object for accessing system resources
1137     * @param tagcontent Unused in this special case of a user method. Can be ignored
1138     * @param doc Reference to the A_CmsXmlContent object of the initiating XLM document
1139     * @param userObject Hashtable with parameters
1140     * @return byte[] with the content of this subelement
1141     * @throws CmsException if something goes wrong
1142     */
1143    public Object   getNavTree(CmsObject cms, String   tagcontent, A_CmsXmlContent doc, Object   userObject)
1144            throws CmsException {
1145
1146        // template file
1147        CmsXmlTemplateFile template=(CmsXmlTemplateFile)doc;
1148        // check whether there exist entry datablock
1149        if (!template.hasData("naventry")) {
1150            return "".getBytes();
1151        }
1152        int level=1;
1153        int depth=0;
1154        int[] count={0};
1155        String   exact="false";
1156        // if there is not any depth then it must not be tested in a if condition
1157        boolean depthIsNull=true;
1158        // if level is zero or null or negative then all folders recursive must
1159        // be showed starting from root folder unless all folders stating from
1160        // specified level of parent folder.
1161        if (!tagcontent.equals("")) {
1162            StringTokenizer   st = new StringTokenizer  (tagcontent, ",");
1163            String   token1="", token2="", token3="";
1164            if (st.hasMoreTokens())
1165                token1=st.nextToken();
1166            if (st.hasMoreTokens())
1167                token2=st.nextToken();
1168            if (st.hasMoreTokens())
1169                token3=st.nextToken();
1170            // now assign tokens to real values
1171            if (!token3.equals(""))
1172                exact=token3.toLowerCase();
1173            if (!token2.equals("")) {
1174                try {
1175                    depth=Integer.parseInt(token2);
1176                } catch (NumberFormatException   e) {
1177                    depth=0;
1178                    exact=token2.toLowerCase();
1179                    if (!exact.equals("true")) {
1180                        exact="false";
1181                    }
1182                }
1183            }
1184            if (!token1.equals("")) {
1185                try {
1186                    level=Integer.parseInt(token1);
1187                } catch (NumberFormatException   e) {
1188                    level=1;
1189                    exact=token1.toLowerCase();
1190                    if (!exact.equals("true")) {
1191                        exact="false";
1192                    }
1193                }
1194            }
1195        }
1196        // if level is not entered or it is less than zero then folder is the root folder
1197        // otherwise the folder must be extracted accordeing to the entered level.
1198        String   folder=extractFolder(cms, level, exact);
1199        if (folder.equals(""))
1200            return "".getBytes();
1201        if (depth>0) {
1202            depthIsNull=false;
1203        }
1204        // register this folder for changes
1205        Vector   vfsDeps = new Vector  ();
1206        vfsDeps.add(cms.readFolder(folder));
1207        registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null,
1208                        (Hashtable  )userObject, vfsDeps, null, null);
1209        // get all folders in specified folder
1210        List   resources=cms.getSubFolders(folder);
1211        // get all files in specified folder
1212        List   allFile=cms.getFilesInFolder(folder);
1213        // get a vector of all files und folders
1214        ((ArrayList  )resources).ensureCapacity(resources.size() + allFile.size());
1215        Iterator   e = allFile.iterator();
1216        while (e.hasNext()) {
1217            resources.add(e.next());
1218        }
1219        // get the uri,servletpath and current folder
1220        String   requestedUri = cms.getRequestContext().getUri();
1221        String   currentFolder=CmsResource.getFolderPath(cms.getRequestContext().getUri());
1222        String   servletPath = CmsXmlTemplateLoader.getRequest(cms.getRequestContext()).getServletUrl();
1223
1224        String   result="";
1225        // check whether xml data blocks are defined.
1226        // The main datablock is entry, it must be defined, the others will get
1227        // the same datablock if they don't exist.
1228        if (!template.hasData("navcurrent")) {
1229            template.setData("navcurrent", template.getData("naventry"));
1230        }
1231        if (!template.hasData("navstart")) {
1232            template.setData("navstart", "");
1233        }
1234        if (!template.hasData("navend")) {
1235            template.setData("navend", "");
1236        }
1237        result=buildNavTree(cms, template, userObject, resources, requestedUri, currentFolder, servletPath, level, depth, depthIsNull, count);
1238        return result.getBytes();
1239    }
1240
1241    /**
1242     * gets a specified property of current folder.<p>
1243     *
1244     * @param cms A_CmsObject Object for accessing system resources
1245     * @param tagcontent Unused in this special case of a user method. Can be ignored
1246     * @param doc Reference to the A_CmsXmlContent object of the initiating XLM document
1247     * @param userObject Hashtable with parameters
1248     * @return byte[] with the content of this subelement
1249     * @throws CmsException if something goes wrong
1250     */
1251    public Object   getPropertyCurrent(CmsObject cms, String   tagcontent, A_CmsXmlContent doc, Object   userObject)
1252        throws CmsException {
1253        String   property="";
1254        // tagcontent must contain the property definition name.
1255        if (!tagcontent.equals("")) {
1256            String   currentFolder=CmsResource.getFolderPath(cms.getRequestContext().getUri());
1257            property=cms.readProperty(currentFolder, tagcontent);
1258            property=(property!=null?property:"");
1259            // register this folder for changes
1260            Vector   vfsDeps = new Vector  ();
1261            vfsDeps.add(cms.readFolder(currentFolder));
1262            registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null,
1263                            (Hashtable  )userObject, vfsDeps, null, null);
1264        }
1265        return (property.getBytes());
1266    }
1267
1268
1269    /**
1270     * Gets a specified property of specified folder starting from current folder.<p>
1271     *
1272     * @param cms A_CmsObject Object for accessing system resources
1273     * @param tagcontent Unused in this special case of a user method. Can be ignored
1274     * @param doc Reference to the A_CmsXmlContent object of the initiating XLM document
1275     * @param userObject Hashtable with parameters
1276     * @return byte[] with the content of this subelement
1277     * @throws CmsException if something goes wrong
1278     */
1279    public Object   getPropertyParent(CmsObject cms, String   tagcontent, A_CmsXmlContent doc, Object   userObject)
1280        throws CmsException {
1281        int level=1;
1282        String   property="";
1283        // tagcontent determines the parent folder starting from current folder and
1284        // the property definition name sparated by a comma.
1285        String   exact="false";
1286        // tagcontent determines the folder starting from root folder.
1287        // if tagcontent is null, then the navigation of root folder must be showed.
1288        if (!tagcontent.equals("")) {
1289            try {
1290                if (tagcontent.indexOf(",")!=-1) {
1291                    level=Integer.parseInt(tagcontent.substring(0, tagcontent.indexOf(",")));
1292                    exact=tagcontent.substring(tagcontent.indexOf(",")+1).toLowerCase();
1293                } else {
1294                    level=Integer.parseInt(tagcontent);
1295                }
1296            } catch (NumberFormatException   e) {
1297                level=1;
1298                exact=tagcontent.toLowerCase();
1299                if (!exact.equals("true")) {
1300                    exact="false";
1301                }
1302            }
1303            // level is converted to negative number, so I can use the method
1304            // "extractFolder" for positive and negative numbers. Negative number
1305            // determines the parent folder level starting from current folder and
1306            // positive number determines the level starting ftom root folder.
1307            String   currentFolder=extractFolder(cms, ((-1)*level), exact);
1308            if (currentFolder.equals(""))
1309                return "".getBytes();
1310            property=cms.readProperty(currentFolder, tagcontent.substring(tagcontent.indexOf(",")+1));
1311            property=(property!=null?property:"");
1312            // register this folder for changes
1313            Vector   vfsDeps = new Vector  ();
1314            vfsDeps.add(cms.readFolder(currentFolder));
1315            registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null,
1316                            (Hashtable  )userObject, vfsDeps, null, null);
1317        }
1318        return (property.getBytes());
1319    }
1320
1321    /**
1322     * Gets a specified property of specified folder starting from root.<p>
1323     *
1324     * @param cms A_CmsObject Object for accessing system resources
1325     * @param tagcontent Unused in this special case of a user method. Can be ignored
1326     * @param doc Reference to the A_CmsXmlContent object of the initiating XLM document
1327     * @param userObject Hashtable with parameters
1328     * @return byte[] with the content of this subelement
1329     * @throws CmsException if something goes wrong
1330     */
1331    public Object   getPropertyRoot(CmsObject cms, String   tagcontent, A_CmsXmlContent doc, Object   userObject)
1332        throws CmsException {
1333        int level=1;
1334        String   property="";
1335        String   exact="false";
1336        // tagcontent determines the folder starting from root folder.
1337        // if tagcontent is null, then the navigation of root folder must be showed.
1338        if (!tagcontent.equals("")) {
1339            try {
1340                if (tagcontent.indexOf(",")!=-1) {
1341                    level=Integer.parseInt(tagcontent.substring(0, tagcontent.indexOf(",")));
1342                    exact=tagcontent.substring(tagcontent.indexOf(",")+1).toLowerCase();
1343                } else {
1344                    level=Integer.parseInt(tagcontent);
1345                }
1346            } catch (NumberFormatException   e) {
1347                level=1;
1348                exact=tagcontent.toLowerCase();
1349                if (!exact.equals("true")) {
1350                    exact="false";
1351                }
1352            }
1353            String   currentFolder=extractFolder(cms, level, exact);
1354            if (currentFolder.equals(""))
1355                return "".getBytes();
1356            property=cms.readProperty(currentFolder, tagcontent.substring(tagcontent.indexOf(",")+1));
1357            property=(property!=null?property:"");
1358            // register this folder for changes
1359            Vector   vfsDeps = new Vector  ();
1360            vfsDeps.add(cms.readFolder(currentFolder));
1361            registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null,
1362                            (Hashtable  )userObject, vfsDeps, null, null);
1363        }
1364        return (property.getBytes());
1365    }
1366
1367
1368    /**
1369     * gets a specified property of uri.<p>
1370     *
1371     * @param cms A_CmsObject Object for accessing system resources
1372     * @param tagcontent Unused in this special case of a user method. Can be ignored
1373     * @param doc Reference to the A_CmsXmlContent object of the initiating XLM document
1374     * @param userObject Hashtable with parameters
1375     * @return byte[] with the content of this subelement
1376     * @throws CmsException if somnething goes wrong
1377     */
1378    public Object   getPropertyUri(CmsObject cms, String   tagcontent, A_CmsXmlContent doc, Object   userObject)
1379        throws CmsException {
1380        String   property="";
1381        String   requestedUri = cms.getRequestContext().getUri();
1382        property=cms.readProperty(requestedUri, tagcontent);
1383        property=(property!=null?property:"");
1384        // register this folder for changes
1385        Vector   vfsDeps = new Vector  ();
1386        vfsDeps.add(cms.readResource(requestedUri));
1387        registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null,
1388                        (Hashtable  )userObject, vfsDeps, null, null);
1389        return (property.getBytes());
1390    }
1391
1392    /**
1393     * gets the caching information from the current template class.
1394     *
1395     * @param cms CmsObject Object for accessing system resources
1396     * @param templateFile Filename of the template file
1397     * @param elementName Element name of this template in our parent template.
1398     * @param parameters Hashtable with all template class parameters.
1399     * @param templateSelector template section that should be processed.
1400     * @return <EM>true</EM> if this class may stream it's results, <EM>false</EM> otherwise.
1401     */
1402    public CmsCacheDirectives getCacheDirectives(CmsObject cms, String   templateFile, String   elementName, Hashtable   parameters, String   templateSelector) {
1403
1404        // First build our own cache directives.
1405        CmsCacheDirectives result = new CmsCacheDirectives(true);
1406        result.setCacheUri(true);
1407        // we don't need the renewAfterPublish function becource we use the new dependencies feature.
1408        result.noAutoRenewAfterPublish();
1409        return result;
1410    }
1411    
1412    /**
1413     * This method retrieves max. three navigation levels per menu entry to 
1414     * build dynamic DHTML pop-up menus.<p>
1415     *
1416     * @param cms CmsObject Object for accessing system resources
1417     * @param tagcontent used in this special case of a user method. Can't be ignored
1418     * @param doc Reference to the A_CmsXmlContent object of the initiating XLM document
1419     * @param userObject Hashtable with parameters
1420     * @return byte[] with the content of this subelement
1421     * @throws CmsException if something goes wrong
1422     */
1423    public Object   getNavPop(CmsObject cms, String   tagcontent, A_CmsXmlContent doc, Object   userObject) throws CmsException {
1424        String   currentFolder = "";
1425        StringBuffer   sRet = new StringBuffer  ();
1426        // String currentFolder2 = cms.readPath(cms.getRequestContext().currentFolder());
1427        // int iLevel = extractLevel(cms, currentFolder2);
1428        int deep = 3;
1429        int level = -1;
1430
1431        if (!tagcontent.equals("")) {
1432            try {
1433                StringTokenizer   st = new StringTokenizer  (tagcontent.toString(), ",");
1434
1435                if (st.hasMoreTokens()) {
1436                    level = Integer.parseInt(st.nextToken().trim());
1437
1438                }
1439                if (st.hasMoreTokens()) {
1440                    deep = Integer.parseInt(st.nextToken().trim());
1441                }
1442            } catch (Exception   e) {
1443                throw new CmsLegacyException(e.getMessage());
1444            }
1445        }
1446        
1447        switch (level) {
1448            case -1 :
1449                currentFolder = CmsResource.getFolderPath(cms.getRequestContext().getUri());
1450                break;
1451        
1452            case 0 :
1453                currentFolder = cms.getSitePath(cms.readFolder("/"));
1454                break;
1455        
1456            default :
1457                if (extractFolder(cms, 1, "").equals("/")) {
1458                    currentFolder = extractFolder(cms, level + 1, "");
1459                } else {
1460                    currentFolder = extractFolder(cms, level, "");
1461                }
1462                break;
1463        }
1464
1465        List   resources = cms.getSubFolders(currentFolder);
1466        List   allFile = cms.getFilesInFolder(currentFolder);
1467        ((ArrayList  )resources).ensureCapacity(resources.size() + allFile.size());
1468        Iterator   e = allFile.iterator();
1469
1470        List   resources2 = null;
1471        List   allFile2 = null;
1472        Iterator   e2 = null;
1473        Object   oBuffer2 = null;
1474
1475        List   resources3 = null;
1476        List   allFile3 = null;
1477        Iterator   e3 = null;
1478        Object   oBuffer1 = null;
1479        Object   oBuffer3 = null;
1480
1481        Vector   resources4 = new Vector  ();
1482        ArrayList   alLink = new ArrayList  ();
1483        ArrayList   alPos = new ArrayList  ();
1484        ArrayList   alLink2 = new ArrayList  ();
1485        ArrayList   alPos2 = new ArrayList  ();
1486
1487        while (e.hasNext()) {
1488            oBuffer1 = e.next();
1489            resources.add(oBuffer1);
1490        }
1491
1492        sRet = buildNavPop(cms, doc, userObject, resources, null, 1, 0, 0, deep);
1493
1494        if (deep > 1) {
1495            int size = resources.size();
1496            String   navLink[] = new String  [size];
1497            String   navText[] = new String  [size];
1498            float navPos[] = new float[size];
1499
1500            int max = extractNav(cms, resources, navLink, navText, navPos);
1501
1502            for (int iCount = 0; iCount < max; iCount++) {
1503                if (navLink[iCount].endsWith("/") || navLink[iCount].endsWith("\\")) {
1504                    alLink.add(navLink[iCount]);
1505                    alPos.add(new Integer  (iCount));
1506                    resources2 = cms.getSubFolders(navLink[iCount]);
1507                    allFile2 = cms.getFilesInFolder(navLink[iCount]);
1508                    ((ArrayList  )resources2).ensureCapacity(resources2.size() + allFile2.size());
1509                    e2 = allFile2.iterator();
1510
1511                    while (e2.hasNext()) {
1512                        oBuffer2 = e2.next();
1513                        resources2.add(oBuffer2);
1514                    }
1515
1516                    for (int iResCounter = 0; iResCounter < resources2.size(); iResCounter++) {
1517                        resources4.addElement(resources2.get(iResCounter));
1518                    }
1519
1520                    sRet = buildNavPop(cms, doc, userObject, resources2, sRet, 2, iCount, 0, deep);
1521
1522                    // these arrays are now initialized with the correct length
1523                    int size2 = resources2.size();
1524                    String   navLink2[] = new String  [size2];
1525                    String   navText2[] = new String  [size2];
1526                    float navPos2[] = new float[size2];
1527
1528                    int max3 = extractNav(cms, resources2, navLink2, navText2, navPos2);
1529
1530                    for (int iCount3 = 0; iCount3 < max3; iCount3++) {
1531                        alLink2.add(navLink2[iCount3]);
1532                        alPos2.add(new Integer  (iCount3));
1533                    }
1534
1535                }
1536            }
1537        }
1538
1539        if (deep > 2) {
1540            int size2 = resources4.size();
1541            String  [] navLink = new String  [size2];
1542            String  [] navText = new String  [size2];
1543            float[] navPos = new float[size2];
1544            int iCounter3 = 0;
1545
1546            int max2 = extractNav(cms, resources4, navLink, navText, navPos);
1547
1548            for (int iCount = 0; iCount < max2; iCount++) {
1549                if (navLink[iCount].endsWith("/") || navLink[iCount].endsWith("\\")) {
1550                    resources3 = cms.getSubFolders(navLink[iCount]);
1551                    allFile3 = cms.getFilesInFolder(navLink[iCount]);
1552                    ((ArrayList  )resources3).ensureCapacity(resources3.size() + allFile3.size());
1553                    e3 = allFile3.iterator();
1554
1555                    while (e3.hasNext()) {
1556                        oBuffer3 = e3.next();
1557                        resources3.add(oBuffer3);
1558                    }
1559
1560                    int iArrayPos = -1;
1561                    int iArrayPos2 = -1;
1562                    String   sLinkDummy = "";
1563
1564                    for (iCounter3 = 0; iCounter3 < alLink.size(); iCounter3++) {
1565                        sLinkDummy = navLink[iCount].substring(0, navLink[iCount].lastIndexOf("/"));
1566                        sLinkDummy = sLinkDummy.substring(0, sLinkDummy.lastIndexOf("/") + 1);
1567                        if (((String  ) alLink.get(iCounter3)).equals(sLinkDummy)) {
1568                            iArrayPos = ((Integer  ) alPos.get(iCounter3)).intValue();
1569                        }
1570                    }
1571
1572                    for (iCounter3 = 0; iCounter3 < alLink2.size(); iCounter3++) {
1573                        sLinkDummy = navLink[iCount].substring(0, navLink[iCount].lastIndexOf("/") + 1);
1574                        if (((String  ) alLink2.get(iCounter3)).equals(sLinkDummy)) {
1575                            iArrayPos2 = ((Integer  ) alPos2.get(iCounter3)).intValue();
1576                        }
1577                    }
1578
1579                    if (navText.length > 0) {
1580                        sRet = buildNavPop(cms, doc, userObject, resources3, sRet, 3, iArrayPos, iArrayPos2, deep);
1581                    }
1582
1583                }
1584            }
1585
1586        }
1587
1588        return sRet.toString().getBytes();
1589    }
1590
1591    /**
1592     * Builds the navigation customized with additional data block menueLevel, 
1593     * Level1Pos and Level2Pos to build dynamic DHTML pop-up menus by using
1594     * getNavPop.<p>
1595     *
1596     * @param cms CmsObject Object for accessing system resources
1597     * @param doc Reference to the A_CmsXmlContent object of the initiating XLM document
1598     * @param userObject Hashtable with parameters
1599     * @param resources a vector that contains the elements of navigation
1600     * @param result2 ??
1601     * @param iDirLevel ??
1602     * @param lPos ??
1603     * @param lPos2 ?? 
1604     * @param iMaxDeep ??
1605     * @return String that contains the navigation
1606     * @throws CmsException if something goes wrong
1607     */
1608    protected StringBuffer   buildNavPop(CmsObject cms, A_CmsXmlContent doc, Object   userObject, List   resources, StringBuffer   result2, int iDirLevel, int lPos, int lPos2, int iMaxDeep) throws CmsException {
1609        String   requestedUri = cms.getRequestContext().getUri();
1610        String   currentFolder = CmsResource.getFolderPath(cms.getRequestContext().getUri());
1611        String   servletPath = CmsXmlTemplateLoader.getRequest(cms.getRequestContext()).getServletUrl();
1612
1613        CmsXmlTemplateFile xmlDataBlock = (CmsXmlTemplateFile) doc;
1614        StringBuffer   result = null;
1615        if (result2 == null) {
1616            result = new StringBuffer  ();
1617        } else {
1618            result = result2;
1619        }
1620
1621        int size = resources.size();
1622
1623        String   navLink[] = new String  [size];
1624        String   navText[] = new String  [size];
1625        float navPos[] = new float[size];
1626
1627        int max = extractNav(cms, resources, navLink, navText, navPos);
1628
1629        // The arrays folderNames and folderTitles now contain all folders
1630        // that should appear in the nav.
1631        // Loop through all folders and generate output
1632        if (xmlDataBlock.hasData("navEntry")) {
1633            if (!xmlDataBlock.hasData("navCurrent")) {
1634                xmlDataBlock.setData("navCurrent", xmlDataBlock.getData("navEntry"));
1635            }
1636
1637            xmlDataBlock.setData("menueLevel", iDirLevel + "");
1638            xmlDataBlock.setData("Level1Pos", lPos + 1 + "");
1639            xmlDataBlock.setData("Level2Pos", lPos2 + 1 + "");
1640
1641            result.append(xmlDataBlock.getProcessedDataValue("navStart" + iDirLevel, this, userObject));
1642
1643            boolean bHasSubFiles = false;
1644            for (int i = 0; i < max; i++) {
1645                bHasSubFiles = false;
1646                if (navLink[i].endsWith("/") || navLink[i].endsWith("\\")) {
1647                    List   resources2 = cms.getSubFolders(navLink[i]);
1648                    List   allFile2 = cms.getFilesInFolder(navLink[i]);
1649                    ((ArrayList  )resources2).ensureCapacity(resources2.size() + allFile2.size());
1650                    Iterator   e2 = allFile2.iterator();
1651                    while (e2.hasNext()) {
1652                        resources2.add(e2.next());
1653                    }
1654                    int size2 = resources2.size();
1655                    String   navLink2[] = new String  [size2];
1656                    String   navText2[] = new String  [size2];
1657                    float navPos2[] = new float[size2];
1658
1659                    if (extractNav(cms, resources2, navLink2, navText2, navPos2) > 0) {
1660                        bHasSubFiles = true;
1661                    }
1662
1663                }
1664
1665                xmlDataBlock.setData("navText", navText[i]);
1666                xmlDataBlock.setData("count", new Integer  (i + 1).toString());
1667                xmlDataBlock.setData("level", new Integer  (extractLevel(cms, navLink[i])).toString());
1668                // this if condition is necessary because of url parameter,
1669                // if there is no filename then the parameters are ignored, so I
1670                // can't use e.g. ?cmsframe=body.
1671                if (navLink[i].endsWith("/")) {
1672                    String   navIndex = cms.readProperty(navLink[i], C_PROPERTY_NAVINDEX);
1673                    if (navIndex == null) {
1674                        navIndex = C_NAVINDEX;
1675                    }
1676                    try {
1677                        cms.readFile(navLink[i] + navIndex);
1678                        xmlDataBlock.setData("navLink", servletPath + navLink[i] + navIndex);
1679                    } catch (CmsException e) {
1680                        xmlDataBlock.setData("navLink", servletPath + requestedUri);
1681                    }
1682                } else {
1683                    try {
1684                        cms.readFile(navLink[i]);
1685                        xmlDataBlock.setData("navLink", servletPath + navLink[i]);
1686                    } catch (CmsException e) {
1687                        xmlDataBlock.setData("navLink", servletPath + requestedUri);
1688                    }
1689                }
1690                // Check if nav is current nav
1691                xmlDataBlock.setData("data1", navLink[i]);
1692                xmlDataBlock.setData("data2", requestedUri);
1693                xmlDataBlock.setData("data3", currentFolder);
1694
1695                String   sFolder = "";
1696                String   sFolder2 = "";
1697                sFolder = navLink[i];
1698                if (currentFolder.length() >= sFolder.length()) {
1699                    if (currentFolder.length() > sFolder.length()) {
1700                        sFolder2 = currentFolder.substring(0, sFolder.length());
1701                    } else {
1702                        sFolder2 = currentFolder.substring(0);
1703                    }
1704                }
1705
1706                String   sSubExten = "";
1707                if (bHasSubFiles && iDirLevel < iMaxDeep) {
1708                    sSubExten = "ws";
1709                }
1710                if (sFolder2.equals(sFolder) || navLink[i].equals(currentFolder) || navLink[i].equals(requestedUri)) {
1711                    result.append(xmlDataBlock.getProcessedDataValue("navCurrent" + iDirLevel + sSubExten, this, userObject));
1712                } else {
1713                    result.append(xmlDataBlock.getProcessedDataValue("navEntry" + iDirLevel + sSubExten, this, userObject));
1714                }
1715
1716            }
1717            result.append(xmlDataBlock.getProcessedDataValue("navEnd" + iDirLevel, this, userObject));
1718        }
1719
1720        return result;
1721    }
1722
1723    /**
1724     * Can be used to build valid hrefs to switch the language. The parameter
1725     * list is contained in the body as a comma separated list:
1726     * <ul>
1727     * <li>language token to be replaced: <b>de</b>_lang_{foldername}/ -> <b>en</b>_lang_{foldername}/</li>
1728     * <li>token to split the language and the folder name, here _lang_</li>
1729     * <li>determines whether just the language token (0) or the entire folder name will be replaced (1)</li>
1730     * <li>URL of an error page if the page doesn't exist in the other language</li>
1731     * </ul>
1732     * 
1733     * @param cms CmsObject Object for accessing system resources
1734     * @param tagcontent the parameters for this tag
1735     * @param doc Reference to the A_CmsXmlContent object of the initiating XLM document
1736     * @param userObject Hashtable with parameters
1737     * @return String or byte[] with the content of this subelement
1738     * @throws CmsException if something goes wrong
1739     */
1740    public Object   getLanguagePath(CmsObject cms, String   tagcontent, A_CmsXmlContent doc, Object   userObject) throws CmsException {
1741        String   sLanguageToken = "_lang_";
1742        String   sLanguageIdent = "";
1743        String   sNoFoundLink = "";
1744        String   sTokenReplaceType = "0";
1745        String   sLinkLeftSide = "/";
1746        String   currentFolder = cms.getRequestContext().getUri();
1747        String   sReturnPath = "";
1748        int iParamCount;
1749        String   sParam = "";
1750
1751        if (!tagcontent.equals("")) {
1752            try {
1753                StringTokenizer   st = new StringTokenizer  (tagcontent.toString(), ",");
1754                iParamCount = st.countTokens();
1755
1756                if (iParamCount < 1) {
1757                    throw new CmsLegacyException("Not enough parameters!");
1758                }
1759
1760                if (st.hasMoreTokens()) {
1761                    sLanguageIdent = st.nextToken().trim();
1762                }
1763
1764                if (st.hasMoreTokens()) {
1765                    sParam = st.nextToken().trim();
1766                    if (!sParam.equals("")) {
1767                        sLanguageToken = sParam;
1768                    }
1769                }
1770
1771                if (st.hasMoreTokens()) {
1772                    sParam = st.nextToken().trim();
1773                    if (!sParam.equals("")) {
1774                        sTokenReplaceType = sParam;
1775                    }
1776                }
1777
1778                if (st.hasMoreTokens()) {
1779                    sParam = st.nextToken().trim();
1780                    if (!sParam.equals("")) {
1781                        sNoFoundLink = sParam;
1782                    }
1783                }
1784
1785            } catch (Exception   e) {
1786                throw new CmsLegacyException(e.getMessage());
1787            }
1788
1789            int ifound = 0;
1790
1791            if (sTokenReplaceType.equals("0")) {
1792                ifound = currentFolder.indexOf(sLanguageToken);
1793            } else {
1794                currentFolder = currentFolder.substring(1);
1795                ifound = currentFolder.indexOf("/");
1796            }
1797
1798            if (ifound > (-1)) {
1799                String   sTemp = currentFolder.substring(0, ifound);
1800                sLinkLeftSide = sTemp.substring(0, sTemp.lastIndexOf("/") + 1);
1801                sReturnPath = sLinkLeftSide + "" + sLanguageIdent + currentFolder.substring(ifound);
1802
1803                //check if the resource exists
1804                boolean resourceExists = false;
1805
1806                try {
1807                    CmsResource dummy = cms.readResource(sReturnPath);
1808
1809                    if (dummy != null) {
1810                        // the resource exists
1811                        resourceExists = true;
1812                    }
1813                } catch (CmsException e) {
1814                    // the resource doesn't exist
1815                    resourceExists = false;
1816                }
1817
1818                if (!resourceExists) {
1819                    if (iParamCount > 3) {
1820                        sReturnPath = "/" + sNoFoundLink;
1821                    } else {
1822                        sReturnPath = sReturnPath.substring(0, sReturnPath.lastIndexOf("/") + 1);
1823                    }
1824                }
1825            } else {
1826                currentFolder = cms.getRequestContext().getUri();
1827            }
1828        } else {
1829            throw new CmsLegacyException("Not enough parameters!");
1830        }
1831
1832        return CmsXmlTemplateLoader.getRequest(cms.getRequestContext()).getServletUrl() + sReturnPath;
1833    }   
1834}
1835
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Free Books Free Magazines
Popular Tags