KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > opencms > defaults > 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 JavaDoc;
46 import java.util.Hashtable JavaDoc;
47 import java.util.Iterator JavaDoc;
48 import java.util.List JavaDoc;
49 import java.util.StringTokenizer JavaDoc;
50 import java.util.Vector JavaDoc;
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 JavaDoc templateFile, String JavaDoc elementName, Hashtable JavaDoc parameters, String JavaDoc 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 JavaDoc buildNav(CmsObject cms, A_CmsXmlContent doc, Object JavaDoc userObject, List JavaDoc resources)
91         throws CmsException {
92
93         // get uri, currentfolder,servletpath and template file
94
String JavaDoc 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 JavaDoc result = new StringBuffer JavaDoc();
99         int size = resources.size();
100
101         String JavaDoc navLink[] = new String JavaDoc[size];
102         String JavaDoc navText[] = new String JavaDoc[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 JavaDoc(i+1).toString());
112             template.setData("navlevel", new Integer JavaDoc(extractLevel(cms, navLink[i])).toString());
113             // check whether it is a folder or file
114
String JavaDoc link="";
115             if (navLink[i].endsWith("/")) {
116                 // read the property of folder to find the link file.
117
String JavaDoc 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 JavaDoc buildNavFold(CmsObject cms, CmsXmlTemplateFile template, Object JavaDoc userObject, List JavaDoc resources, String JavaDoc requestedUri, String JavaDoc currentFolder, String JavaDoc servletPath, int level, int[] count)
165         throws CmsException {
166
167         StringBuffer JavaDoc result = new StringBuffer JavaDoc();
168         // arrays of navigation position, text and link
169
int size = resources.size();
170         String JavaDoc navLink[] = new String JavaDoc[size];
171         String JavaDoc navText[] = new String JavaDoc[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 JavaDoc(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 JavaDoc(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 JavaDoc link="";
194                 // check whether the link is folder
195
if (navLink[i].endsWith("/")) {
196                     // read the property of link file
197
String JavaDoc 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 JavaDoc all=cms.getSubFolders(navLink[i]);
231                     List JavaDoc files=cms.getFilesInFolder(navLink[i]);
232                     // register this folder for changes (if it is a folder!)
233
if (navLink[i].endsWith("/")) {
234                         Vector JavaDoc vfsDeps = new Vector JavaDoc();
235                         vfsDeps.add(cms.readFolder(navLink[i]));
236                         registerVariantDeps(cms, template.getAbsoluteFilename(), null, null,
237                                         (Hashtable JavaDoc)userObject, vfsDeps, null, null);
238                     }
239                     ((ArrayList JavaDoc)all).ensureCapacity(all.size() + files.size());
240                     Iterator JavaDoc 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 JavaDoc buildNavTree(CmsObject cms, CmsXmlTemplateFile template, Object JavaDoc userObject, List JavaDoc resources, String JavaDoc requestedUri, String JavaDoc currentFolder, String JavaDoc servletPath, int level, int depth, boolean depthIsNull, int[] count)
272         throws CmsException {
273
274         StringBuffer JavaDoc result = new StringBuffer JavaDoc();
275         // define some array for link,text and position of
276
// the elements of navigation
277
int size = resources.size();
278         String JavaDoc navLink[] = new String JavaDoc[size];
279         String JavaDoc navText[] = new String JavaDoc[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 JavaDoc(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 JavaDoc(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 JavaDoc 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 JavaDoc 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 JavaDoc all=cms.getSubFolders(navLink[i]);
349                         List JavaDoc files=cms.getFilesInFolder(navLink[i]);
350                         // register this folder for changes
351
Vector JavaDoc vfsDeps = new Vector JavaDoc();
352                         vfsDeps.add(cms.readFolder(navLink[i]));
353                         registerVariantDeps(cms, template.getAbsoluteFilename(), null, null,
354                                         (Hashtable JavaDoc)userObject, vfsDeps, null, null);
355                         ((ArrayList JavaDoc)all).ensureCapacity(all.size() + files.size());
356                         Iterator JavaDoc 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 JavaDoc extractFolder(CmsObject cms, int level, String JavaDoc exact)
378         throws CmsException {
379
380         // get uri and requested uri
381
String JavaDoc 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 JavaDoc err) {
386             navIndex=C_NAVINDEX;
387         }
388         String JavaDoc uri=CmsResource.getFolderPath(cms.getRequestContext().getUri())+navIndex;
389         String JavaDoc requestedUri=cms.getRequestContext().getUri();
390         // get count of folder
391
String JavaDoc currentFolder="/";
392         StringTokenizer JavaDoc st = new StringTokenizer JavaDoc(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 JavaDoc folder)
428         throws CmsException {
429         StringTokenizer JavaDoc st = new StringTokenizer JavaDoc(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 JavaDoc resources, String JavaDoc[] navLink, String JavaDoc[] navText, float[] navPos)
446         throws CmsException {
447
448         String JavaDoc 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 JavaDoc path = cms.getSitePath(currentResource);
459             String JavaDoc pos = cms.readProperty(path, CmsPropertyDefinition.PROPERTY_NAVPOS);
460             String JavaDoc 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 JavaDoc(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 JavaDoc getFolderCurrent(CmsObject cms, String JavaDoc tagcontent, A_CmsXmlContent doc, Object JavaDoc userObject)
490             throws CmsException {
491
492         String JavaDoc 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 JavaDoc getFolderParent(CmsObject cms, String JavaDoc tagcontent, A_CmsXmlContent doc, Object JavaDoc 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 JavaDoc 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 JavaDoc e) {
525                 level=1;
526                 exact=tagcontent.toLowerCase();
527                 if (!exact.equals("true")) {
528                     exact="false";
529                 }
530             }
531         }
532         String JavaDoc currentFolder=extractFolder(cms, ((-1)*level), exact);
533         if (currentFolder.equals(""))
534             return "".getBytes();
535         String JavaDoc 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 JavaDoc getFolderRoot(CmsObject cms, String JavaDoc tagcontent, A_CmsXmlContent doc, Object JavaDoc userObject)
549             throws CmsException {
550
551         int level=1;
552         String JavaDoc 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 JavaDoc e) {
564                 level=1;
565                 exact=tagcontent.toLowerCase();
566                 if (!exact.equals("true")) {
567                     exact="false";
568                 }
569             }
570         }
571         String JavaDoc currentFolder=extractFolder(cms, level, exact);
572         if (currentFolder.equals(""))
573             return "".getBytes();
574         String JavaDoc 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 JavaDoc getNavCurrent(CmsObject cms, String JavaDoc tagcontent, A_CmsXmlContent doc, Object JavaDoc 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 JavaDoc currentFolder=CmsResource.getFolderPath(cms.getRequestContext().getUri());
596         int level=extractLevel(cms, currentFolder)+1;
597         String JavaDoc 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 JavaDoc 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 JavaDoc st = new StringTokenizer JavaDoc(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 JavaDoc vfsDeps = new Vector JavaDoc();
633         vfsDeps.add(cms.readFolder(currentFolder));
634         registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null,
635                         (Hashtable JavaDoc)userObject, vfsDeps, null, null);
636         // get all resources in current folder
637
List JavaDoc resources=cms.getSubFolders(currentFolder);
638         List JavaDoc allFile=cms.getFilesInFolder(currentFolder);
639         ((ArrayList JavaDoc)resources).ensureCapacity(resources.size() + allFile.size());
640         Iterator JavaDoc 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 JavaDoc getNavFold(CmsObject cms, String JavaDoc tagcontent, A_CmsXmlContent doc, Object JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc folder=extractFolder(cms, level, exact);
693         if (folder.equals(""))
694             return "".getBytes();
695         //}
696
// get uri, current folder, servletpath
697
String JavaDoc requestedUri = cms.getRequestContext().getUri();
698         String JavaDoc currentFolder=CmsResource.getFolderPath(cms.getRequestContext().getUri());
699         String JavaDoc servletPath = CmsXmlTemplateLoader.getRequest(cms.getRequestContext()).getServletUrl();
700         // register this folder for changes
701
Vector JavaDoc vfsDeps = new Vector JavaDoc();
702         vfsDeps.add(cms.readFolder(folder));
703         registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null,
704                         (Hashtable JavaDoc)userObject, vfsDeps, null, null);
705         // get all resources
706
List JavaDoc resources=cms.getSubFolders(folder);
707         List JavaDoc allFile=cms.getFilesInFolder(folder);
708         ((ArrayList JavaDoc)resources).ensureCapacity(resources.size() + allFile.size());
709         Iterator JavaDoc e = allFile.iterator();
710         while (e.hasNext()) {
711             resources.add(e.next());
712         }
713
714         String JavaDoc 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 JavaDoc getNavParent(CmsObject cms, String JavaDoc tagcontent, A_CmsXmlContent doc, Object JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc currentFolder=extractFolder(cms, ((-1)*level), exact);
774         if (currentFolder.equals(""))
775             return "".getBytes();
776         // register this folder for changes
777
Vector JavaDoc vfsDeps = new Vector JavaDoc();
778         vfsDeps.add(cms.readFolder(currentFolder));
779         registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null,
780                         (Hashtable JavaDoc)userObject, vfsDeps, null, null);
781         List JavaDoc resources=cms.getSubFolders(currentFolder);
782         List JavaDoc allFile=cms.getFilesInFolder(currentFolder);
783
784         ((ArrayList JavaDoc)resources).ensureCapacity(resources.size() + allFile.size());
785         Iterator JavaDoc 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 JavaDoc getNavRoot(CmsObject cms, String JavaDoc tagcontent, A_CmsXmlContent doc, Object JavaDoc 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 JavaDoc 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 JavaDoc e) {
828                 level=1;
829                 exact=tagcontent.toLowerCase();
830                 if (!exact.equals("true")) {
831                     exact="false";
832                 }
833             }
834         }
835         String JavaDoc currentFolder=extractFolder(cms, level, exact);
836         if (currentFolder.equals(""))
837             return "".getBytes();
838         // register this folder for changes
839
Vector JavaDoc vfsDeps = new Vector JavaDoc();
840         vfsDeps.add(cms.readFolder(currentFolder));
841         registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null,
842                         (Hashtable JavaDoc)userObject, vfsDeps, null, null);
843         // get all resources, it means all files and folders.
844
List JavaDoc resources=cms.getSubFolders(currentFolder);
845         List JavaDoc allFile=cms.getFilesInFolder(currentFolder);
846         ((ArrayList JavaDoc)resources).ensureCapacity(resources.size() + allFile.size());
847         Iterator JavaDoc 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 JavaDoc getNavPath(CmsObject cms, String JavaDoc tagcontent, A_CmsXmlContent doc, Object JavaDoc userObject) throws CmsException {
881         // the result string holding the entire generated navigation path
882
String JavaDoc 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 JavaDoc tagContentTokenizer = new StringTokenizer JavaDoc(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 JavaDoc e) {
930                         requestedNavLevels = 1;
931                     }
932                 }
933             }
934         }
935         
936         // get the requested folder
937
String JavaDoc 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 JavaDoc currentFolder = extractFolder(cms, i, "false");
954             
955             // register the current folder for changes in the beloved element cache
956
Vector JavaDoc vfsDeps = new Vector JavaDoc();
957             vfsDeps.add(cms.readFolder(currentFolder));
958             registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null, (Hashtable JavaDoc)userObject, vfsDeps, null, null);
959             
960             // add the current folder as the unique resource
961
Vector JavaDoc resources = new Vector JavaDoc();
962             resources.addElement(cms.readFolder(currentFolder, CmsResourceFilter.ALL));
963             
964             // build the navigation for the current folder and append to the path
965
String JavaDoc 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 JavaDoc getNavMap(CmsObject cms, String JavaDoc tagcontent, A_CmsXmlContent doc, Object JavaDoc userObject) throws CmsException {
985         // the result string holding the entire generated HTML of the navigation map
986
String JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc buildMap(CmsObject cms, A_CmsXmlContent doc, Object JavaDoc userObject, String JavaDoc currentFolder, String JavaDoc datablock, int currentResursionLevel, int maxRecursionLevel) throws CmsException {
1052        StringBuffer JavaDoc result = new StringBuffer JavaDoc();
1053        CmsXmlTemplateFile template = (CmsXmlTemplateFile)doc;
1054        boolean isFolder = false;
1055        
1056        // register the current folder for changes in the beloved element cache
1057
Vector JavaDoc vfsDeps = new Vector JavaDoc();
1058        vfsDeps.add(cms.readFolder(currentFolder));
1059        registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null, (Hashtable JavaDoc)userObject, vfsDeps, null, null);
1060     
1061        // collect all files and subfolders
1062
List JavaDoc resources = cms.getSubFolders(currentFolder);
1063        List JavaDoc files = cms.getFilesInFolder(currentFolder);
1064        ((ArrayList JavaDoc)resources).ensureCapacity(resources.size() + files.size());
1065        
1066        Iterator JavaDoc 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 JavaDoc navLink[] = new String JavaDoc[size];
1074        String JavaDoc navText[] = new String JavaDoc[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 JavaDoc currentNavLink = null;
1081            
1082            // set the navigation data/properties in the template
1083
template.setData("navtext", navText[i]);
1084            template.setData("navcount", new Integer JavaDoc(i+1).toString());
1085            template.setData("navlevel", new Integer JavaDoc(extractLevel(cms, navLink[i])).toString());
1086            
1087            if (navLink[i].endsWith("/")) {
1088                // the current resource is a folder
1089
isFolder = true;
1090                
1091                String JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc getNavTree(CmsObject cms, String JavaDoc tagcontent, A_CmsXmlContent doc, Object JavaDoc 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 JavaDoc 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 JavaDoc st = new StringTokenizer JavaDoc(tagcontent, ",");
1163            String JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc vfsDeps = new Vector JavaDoc();
1206        vfsDeps.add(cms.readFolder(folder));
1207        registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null,
1208                        (Hashtable JavaDoc)userObject, vfsDeps, null, null);
1209        // get all folders in specified folder
1210
List JavaDoc resources=cms.getSubFolders(folder);
1211        // get all files in specified folder
1212
List JavaDoc allFile=cms.getFilesInFolder(folder);
1213        // get a vector of all files und folders
1214
((ArrayList JavaDoc)resources).ensureCapacity(resources.size() + allFile.size());
1215        Iterator JavaDoc e = allFile.iterator();
1216        while (e.hasNext()) {
1217            resources.add(e.next());
1218        }
1219        // get the uri,servletpath and current folder
1220
String JavaDoc requestedUri = cms.getRequestContext().getUri();
1221        String JavaDoc currentFolder=CmsResource.getFolderPath(cms.getRequestContext().getUri());
1222        String JavaDoc servletPath = CmsXmlTemplateLoader.getRequest(cms.getRequestContext()).getServletUrl();
1223
1224        String JavaDoc 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 JavaDoc getPropertyCurrent(CmsObject cms, String JavaDoc tagcontent, A_CmsXmlContent doc, Object JavaDoc userObject)
1252        throws CmsException {
1253        String JavaDoc property="";
1254        // tagcontent must contain the property definition name.
1255
if (!tagcontent.equals("")) {
1256            String JavaDoc 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 JavaDoc vfsDeps = new Vector JavaDoc();
1261            vfsDeps.add(cms.readFolder(currentFolder));
1262            registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null,
1263                            (Hashtable JavaDoc)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 JavaDoc getPropertyParent(CmsObject cms, String JavaDoc tagcontent, A_CmsXmlContent doc, Object JavaDoc userObject)
1280        throws CmsException {
1281        int level=1;
1282        String JavaDoc property="";
1283        // tagcontent determines the parent folder starting from current folder and
1284
// the property definition name sparated by a comma.
1285
String JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc vfsDeps = new Vector JavaDoc();
1314            vfsDeps.add(cms.readFolder(currentFolder));
1315            registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null,
1316                            (Hashtable JavaDoc)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 JavaDoc getPropertyRoot(CmsObject cms, String JavaDoc tagcontent, A_CmsXmlContent doc, Object JavaDoc userObject)
1332        throws CmsException {
1333        int level=1;
1334        String JavaDoc property="";
1335        String JavaDoc 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 JavaDoc e) {
1347                level=1;
1348                exact=tagcontent.toLowerCase();
1349                if (!exact.equals("true")) {
1350                    exact="false";
1351                }
1352            }
1353            String JavaDoc 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 JavaDoc vfsDeps = new Vector JavaDoc();
1360            vfsDeps.add(cms.readFolder(currentFolder));
1361            registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null,
1362                            (Hashtable JavaDoc)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 JavaDoc getPropertyUri(CmsObject cms, String JavaDoc tagcontent, A_CmsXmlContent doc, Object JavaDoc userObject)
1379        throws CmsException {
1380        String JavaDoc property="";
1381        String JavaDoc requestedUri = cms.getRequestContext().getUri();
1382        property=cms.readProperty(requestedUri, tagcontent);
1383        property=(property!=null?property:"");
1384        // register this folder for changes
1385
Vector JavaDoc vfsDeps = new Vector JavaDoc();
1386        vfsDeps.add(cms.readResource(requestedUri));
1387        registerVariantDeps(cms, doc.getAbsoluteFilename(), null, null,
1388                        (Hashtable JavaDoc)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 JavaDoc templateFile, String JavaDoc elementName, Hashtable JavaDoc parameters, String JavaDoc 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 JavaDoc getNavPop(CmsObject cms, String JavaDoc tagcontent, A_CmsXmlContent doc, Object JavaDoc userObject) throws CmsException {
1424        String JavaDoc currentFolder = "";
1425        StringBuffer JavaDoc sRet = new StringBuffer JavaDoc();
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 JavaDoc st = new StringTokenizer JavaDoc(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 JavaDoc 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 JavaDoc resources = cms.getSubFolders(currentFolder);
1466        List JavaDoc allFile = cms.getFilesInFolder(currentFolder);
1467        ((ArrayList JavaDoc)resources).ensureCapacity(resources.size() + allFile.size());
1468        Iterator JavaDoc e = allFile.iterator();
1469
1470        List JavaDoc resources2 = null;
1471        List JavaDoc allFile2 = null;
1472        Iterator JavaDoc e2 = null;
1473        Object JavaDoc oBuffer2 = null;
1474
1475        List JavaDoc resources3 = null;
1476        List JavaDoc allFile3 = null;
1477        Iterator JavaDoc e3 = null;
1478        Object JavaDoc oBuffer1 = null;
1479        Object JavaDoc oBuffer3 = null;
1480
1481        Vector JavaDoc resources4 = new Vector JavaDoc();
1482        ArrayList JavaDoc alLink = new ArrayList JavaDoc();
1483        ArrayList JavaDoc alPos = new ArrayList JavaDoc();
1484        ArrayList JavaDoc alLink2 = new ArrayList JavaDoc();
1485        ArrayList JavaDoc alPos2 = new ArrayList JavaDoc();
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 JavaDoc navLink[] = new String JavaDoc[size];
1497            String JavaDoc navText[] = new String JavaDoc[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 JavaDoc(iCount));
1506                    resources2 = cms.getSubFolders(navLink[iCount]);
1507                    allFile2 = cms.getFilesInFolder(navLink[iCount]);
1508                    ((ArrayList JavaDoc)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 JavaDoc navLink2[] = new String JavaDoc[size2];
1525                    String JavaDoc navText2[] = new String JavaDoc[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 JavaDoc(iCount3));
1533                    }
1534
1535                }
1536            }
1537        }
1538
1539        if (deep > 2) {
1540            int size2 = resources4.size();
1541            String JavaDoc[] navLink = new String JavaDoc[size2];
1542            String JavaDoc[] navText = new String JavaDoc[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 JavaDoc)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 JavaDoc 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 JavaDoc) alLink.get(iCounter3)).equals(sLinkDummy)) {
1568                            iArrayPos = ((Integer JavaDoc) 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 JavaDoc) alLink2.get(iCounter3)).equals(sLinkDummy)) {
1575                            iArrayPos2 = ((Integer JavaDoc) 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 JavaDoc buildNavPop(CmsObject cms, A_CmsXmlContent doc, Object JavaDoc userObject, List JavaDoc resources, StringBuffer JavaDoc result2, int iDirLevel, int lPos, int lPos2, int iMaxDeep) throws CmsException {
1609        String JavaDoc requestedUri = cms.getRequestContext().getUri();
1610        String JavaDoc currentFolder = CmsResource.getFolderPath(cms.getRequestContext().getUri());
1611        String JavaDoc servletPath = CmsXmlTemplateLoader.getRequest(cms.getRequestContext()).getServletUrl();
1612
1613        CmsXmlTemplateFile xmlDataBlock = (CmsXmlTemplateFile) doc;
1614        StringBuffer JavaDoc result = null;
1615        if (result2 == null) {
1616            result = new StringBuffer JavaDoc();
1617        } else {
1618            result = result2;
1619        }
1620
1621        int size = resources.size();
1622
1623        String JavaDoc navLink[] = new String JavaDoc[size];
1624        String JavaDoc navText[] = new String JavaDoc[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 JavaDoc resources2 = cms.getSubFolders(navLink[i]);
1648                    List JavaDoc allFile2 = cms.getFilesInFolder(navLink[i]);
1649                    ((ArrayList JavaDoc)resources2).ensureCapacity(resources2.size() + allFile2.size());
1650                    Iterator JavaDoc e2 = allFile2.iterator();
1651                    while (e2.hasNext()) {
1652                        resources2.add(e2.next());
1653                    }
1654                    int size2 = resources2.size();
1655                    String JavaDoc navLink2[] = new String JavaDoc[size2];
1656                    String JavaDoc navText2[] = new String JavaDoc[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 JavaDoc(i + 1).toString());
1667                xmlDataBlock.setData("level", new Integer JavaDoc(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 JavaDoc 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 JavaDoc sFolder = "";
1696                String JavaDoc 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 JavaDoc 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 JavaDoc getLanguagePath(CmsObject cms, String JavaDoc tagcontent, A_CmsXmlContent doc, Object JavaDoc userObject) throws CmsException {
1741        String JavaDoc sLanguageToken = "_lang_";
1742        String JavaDoc sLanguageIdent = "";
1743        String JavaDoc sNoFoundLink = "";
1744        String JavaDoc sTokenReplaceType = "0";
1745        String JavaDoc sLinkLeftSide = "/";
1746        String JavaDoc currentFolder = cms.getRequestContext().getUri();
1747        String JavaDoc sReturnPath = "";
1748        int iParamCount;
1749        String JavaDoc sParam = "";
1750
1751        if (!tagcontent.equals("")) {
1752            try {
1753                StringTokenizer JavaDoc st = new StringTokenizer JavaDoc(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 JavaDoc 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 JavaDoc 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
Popular Tags