##### Coverage Report - org.apache.turbine.services.pull.tools.UITool

Classes in this File | Line Coverage | Branch Coverage | Complexity
UITool |
27% | 13/47
10% | 1/10
| 1.25;1,25

1 |  |
     package org.apache.turbine.services.pull.tools;
2 |  |
3 |  |
     /*
4 |  |
      * Licensed to the Apache Software Foundation (ASF) under one
5 |  |
      * or more contributor license agreements.  See the NOTICE file
6 |  |
      * distributed with this work for additional information
7 |  |
      * regarding copyright ownership.  The ASF licenses this file
8 |  |
      * to you under the Apache License, Version 2.0 (the
9 |  |
      * "License"); you may not use this file except in compliance
10 |  |
      * with the License.  You may obtain a copy of the License at
11 |  |
      *
12 |  |
      *   http://www.apache.org/licenses/LICENSE-2.0
13 |  |
      *
14 |  |
      * Unless required by applicable law or agreed to in writing,
15 |  |
      * software distributed under the License is distributed on an
16 |  |
      * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17 |  |
      * KIND, either express or implied.  See the License for the
18 |  |
      * specific language governing permissions and limitations
19 |  |
      * under the License.
20 |  |
      */
21 |  |
22 |  |
     import org.apache.commons.logging.Log;
23 |  |
     import org.apache.commons.logging.LogFactory;
24 |  |
     import org.apache.turbine.om.security.User;
25 |  |
     import org.apache.turbine.pipeline.PipelineData;
26 |  |
     import org.apache.turbine.services.pull.ApplicationTool;
27 |  |
     import org.apache.turbine.services.ui.TurbineUI;
28 |  |
     import org.apache.turbine.services.ui.UIService;
29 |  |
     import org.apache.turbine.util.RunData;
30 |  |
     import org.apache.turbine.util.ServerData;
31 |  |
32 |  |
     /**
33 |  |
      * Manages all UI elements for a Turbine Application. Any UI element can be
34 |  |
      * accessed in any template using the $ui handle (assuming you use the default
35 |  |
      * PullService configuration). So, for example, you could access the background
36 |  |
      * color for your pages by using $ui.bgcolor
37 |  |
      * <p>
38 |  |
      * This implementation provides a single level of inheritance in that if a
39 |  |
      * property does not exist in a non-default skin, the value from the default
40 |  |
      * skin will be used. By only requiring values different to those stored in
41 |  |
      * the default skin to appear in the non-default skins the amount of memory
42 |  |
      * consumed in cases where the UserManager instance is used at a non-global
43 |  |
      * scope will potentially be reduced due to the fact that a shared instance of
44 |  |
      * the default skin properties can be used. Note that this inheritance only
45 |  |
      * applies to property values - it does not apply to any images or stylesheets
46 |  |
      * that may form part of your skins.
47 |  |
      * <p>
48 |  |
      * This is an application pull tool for the template system. You should not
49 |  |
      * use it in a normal application!  Within Java code you should use TurbineUI.
50 |  |
      * <p>
51 |  |
      *
52 |  |
      * This is an application pull tool for the template system. You should
53 |  |
      * <strong>only</strong> use it in a normal application to set the skin
54 |  |
      * attribute for a user (setSkin(User user, String skin)) and to initialize it
55 |  |
      * for the user, otherwise use TurbineUI is probably the way to go.
56 |  |
      *
57 |  |
      * @author <a href="mailto:jvanzyl@periapt.com">Jason van Zyl</a>
58 |  |
      * @author <a href="mailto:james_coltman@majorband.co.uk">James Coltman</a>
59 |  |
      * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
60 |  |
      * @author <a href="mailto:seade@backstagetech.com.au">Scott Eade</a>
61 |  |
      * @version $Id$
62 |  |
      * @see UIService
63 |  |
      */
64 | 17 |
     public class UITool implements ApplicationTool
65 |  |
     {
66 |  |
         /** Logging */
67 | 15 |
         private static Log log = LogFactory.getLog(UITool.class);
68 |  |
69 |  |
         /**
70 |  |
          * Attribute name of skinName value in User's temp hashmap.
71 |  |
          */
72 | 15 |
         public static final String SKIN_ATTRIBUTE = UITool.class.getName()+ ".skin";
73 |  |
74 |  |
         /**
75 |  |
          * The actual skin being used for the webapp.
76 |  |
          */
77 |  |
         private String skinName;
78 |  |
79 |  |
         /**
80 |  |
          * Refresh the tool.
81 |  |
          */
82 |  |
         @Override
83 |  |
         public void refresh()
84 |  |
         {
85 | 10 |
             TurbineUI.refresh(getSkin());
86 | 10 |
             log.debug("UITool refreshed for skin: " + getSkin());
87 | 10 |
         }
88 |  |
89 |  |
         /**
90 |  |
          * Provide access to the list of available skin names.
91 |  |
          *
92 |  |
          * @return the available skin names.
93 |  |
          */
94 |  |
         public String[] getSkinNames()
95 |  |
         {
96 | 0 |
             return TurbineUI.getSkinNames();
97 |  |
         }
98 |  |
99 |  |
         /**
100 |  |
          * Get the name of the default skin name for the web application from the
101 |  |
          * TurbineResources.properties file. If the property is not present the
102 |  |
          * name of the default skin will be returned.  Note that the web application
103 |  |
          * skin name may be something other than default, in which case its
104 |  |
          * properties will default to the skin with the name "default".
105 |  |
          *
106 |  |
          * @return the name of the default skin for the web application.
107 |  |
          */
108 |  |
         public String getWebappSkinName()
109 |  |
         {
110 | 0 |
             return TurbineUI.getWebappSkinName();
111 |  |
         }
112 |  |
113 |  |
         /**
114 |  |
          * Retrieve a skin property.  If the property is not defined in the current
115 |  |
          * skin the value for the default skin will be provided.  If the current
116 |  |
          * skin does not exist then the skin configured for the webapp will be used.
117 |  |
          * If the webapp skin does not exist the default skin will be used.  If the
118 |  |
          * default skin does not exist then <code>null</code> will be returned.
119 |  |
          *
120 |  |
          * @param key the key to retrieve from the skin.
121 |  |
          * @return the value of the property for the named skin (defaulting to the
122 |  |
          * default skin), the webapp skin, the default skin or <code>null</code>,
123 |  |
          * depending on whether or not the property or skins exist.
124 |  |
          */
125 |  |
         public String get(String key)
126 |  |
         {
127 | 0 |
             return TurbineUI.get(getSkin(), key);
128 |  |
         }
129 |  |
130 |  |
         /**
131 |  |
          * Retrieve the skin name.
132 |  |
          * @return the selected skin name
133 |  |
          */
134 |  |
         public String getSkin()
135 |  |
         {
136 | 20 |
             return skinName;
137 |  |
         }
138 |  |
139 |  |
         /**
140 |  |
          * Set the skin name to the skin from the TurbineResources.properties file.
141 |  |
          * If the property is not present use the "default" skin.
142 |  |
          */
143 |  |
         public void setSkin()
144 |  |
         {
145 | 17 |
             skinName = TurbineUI.getWebappSkinName();
146 | 17 |
         }
147 |  |
148 |  |
         /**
149 |  |
          * Set the skin name to the specified skin.
150 |  |
          *
151 |  |
          * @param skinName the skin name to use.
152 |  |
          */
153 |  |
         public void setSkin(String skinName)
154 |  |
         {
155 | 0 |
             this.skinName = skinName;
156 | 0 |
         }
157 |  |
158 |  |
         /**
159 |  |
          * Set the skin name when the tool is configured to be loaded on a
160 |  |
          * per-request basis. By default it calls getSkin to return the skin
161 |  |
          * specified in TurbineResources.properties. Developers can write a subclass
162 |  |
          * of UITool that overrides this method to determine the skin to use based
163 |  |
          * on information held in the request.
164 |  |
          *
165 |  |
          * @param data a RunData instance
166 |  |
          */
167 |  |
         protected void setSkin(RunData data)
168 |  |
         {
169 | 0 |
             setSkin();
170 | 0 |
         }
171 |  |
172 |  |
         /**
173 |  |
          * Set the skin name when the tool is configured to be loaded on a
174 |  |
          * per-session basis. If the user's temp hashmap contains a value in the
175 |  |
          * attribute specified by the String constant SKIN_ATTRIBUTE then that is
176 |  |
          * returned. Otherwise it calls getSkin to return the skin specified in
177 |  |
          * TurbineResources.properties.
178 |  |
          *
179 |  |
          * @param user a User instance
180 |  |
          */
181 |  |
         protected void setSkin(User user)
182 |  |
         {
183 | 0 |
             if (user.getTemp(SKIN_ATTRIBUTE) == null)
184 |  |
             {
185 | 0 |
                 setSkin();
186 |  |
             }
187 |  |
             else
188 |  |
             {
189 | 0 |
                 setSkin((String) user.getTemp(SKIN_ATTRIBUTE));
190 |  |
             }
191 | 0 |
         }
192 |  |
193 |  |
         /**
194 |  |
          * Set the skin name in the user's temp hashmap for the current session.
195 |  |
          *
196 |  |
          * @param user a User instance
197 |  |
          * @param skin the skin name for the session
198 |  |
          */
199 |  |
         public static void setSkin(User user, String skin)
200 |  |
         {
201 | 0 |
             user.setTemp(SKIN_ATTRIBUTE, skin);
202 | 0 |
         }
203 |  |
204 |  |
         /**
205 |  |
          * Retrieve the URL for an image that is part of the skin. The images are
206 |  |
          * stored in the WEBAPP/resources/ui/skins/[SKIN]/images directory.
207 |  |
          *
208 |  |
          * <p>Use this if for some reason your server name, server scheme, or server
209 |  |
          * port change on a per request basis. I'm not sure if this would happen in
210 |  |
          * a load balanced situation. I think in most cases the image(String image)
211 |  |
          * method would probably be enough, but I'm not absolutely positive.
212 |  |
          *
213 |  |
          * @param imageId the id of the image whose URL will be generated.
214 |  |
          * @param data the RunData to use as the source of the ServerData to use as
215 |  |
          * the basis for the URL.
216 |  |
          * @return the image URL
217 |  |
          */
218 |  |
         public String image(String imageId, RunData data)
219 |  |
         {
220 | 0 |
             return image(imageId, data.getServerData());
221 |  |
         }
222 |  |
223 |  |
         /**
224 |  |
          * Retrieve the URL for an image that is part of the skin. The images are
225 |  |
          * stored in the WEBAPP/resources/ui/skins/[SKIN]/images directory.
226 |  |
          *
227 |  |
          * <p>Use this if for some reason your server name, server scheme, or server
228 |  |
          * port change on a per request basis. I'm not sure if this would happen in
229 |  |
          * a load balanced situation. I think in most cases the image(String image)
230 |  |
          * method would probably be enough, but I'm not absolutely positive.
231 |  |
          *
232 |  |
          * @param imageId the id of the image whose URL will be generated.
233 |  |
          * @param serverData the serverData to use as the basis for the URL.
234 |  |
          * @return the image URL
235 |  |
          */
236 |  |
         public String image(String imageId, ServerData serverData)
237 |  |
         {
238 | 0 |
             return TurbineUI.image(getSkin(), imageId, serverData);
239 |  |
         }
240 |  |
241 |  |
         /**
242 |  |
          * Retrieve the URL for an image that is part of the skin. The images are
243 |  |
          * stored in the WEBAPP/resources/ui/skins/[SKIN]/images directory.
244 |  |
          *
245 |  |
          * @param imageId the id of the image whose URL will be generated.
246 |  |
          * @return the image URL
247 |  |
          */
248 |  |
         public String image(String imageId)
249 |  |
         {
250 | 0 |
             return TurbineUI.image(getSkin(), imageId);
251 |  |
         }
252 |  |
253 |  |
         /**
254 |  |
          * Retrieve the URL for the style sheet that is part of the skin. The style
255 |  |
          * is stored in the WEBAPP/resources/ui/skins/[SKIN] directory with the
256 |  |
          * filename skin.css
257 |  |
          *
258 |  |
          * <p>Use this if for some reason your server name, server scheme, or server
259 |  |
          * port change on a per request basis. I'm not sure if this would happen in
260 |  |
          * a load balanced situation. I think in most cases the style() method would
261 |  |
          * probably be enough, but I'm not absolutely positive.
262 |  |
          *
263 |  |
          * @param data the RunData to use as the source of the ServerData to use as
264 |  |
          * the basis for the URL.
265 |  |
          * @return the CSS URL
266 |  |
          */
267 |  |
         public String getStylecss(RunData data)
268 |  |
         {
269 | 0 |
             return getStylecss(data.getServerData());
270 |  |
         }
271 |  |
272 |  |
         /**
273 |  |
          * Retrieve the URL for the style sheet that is part of the skin. The style
274 |  |
          * is stored in the WEBAPP/resources/ui/skins/[SKIN] directory with the
275 |  |
          * filename skin.css
276 |  |
          *
277 |  |
          * <p>Use this if for some reason your server name, server scheme, or server
278 |  |
          * port change on a per request basis. I'm not sure if this would happen in
279 |  |
          * a load balanced situation. I think in most cases the style() method would
280 |  |
          * probably be enough, but I'm not absolutely positive.
281 |  |
          *
282 |  |
          * @param serverData the serverData to use as the basis for the URL.
283 |  |
          * @return the CSS URL
284 |  |
          */
285 |  |
         public String getStylecss(ServerData serverData)
286 |  |
         {
287 | 0 |
             return TurbineUI.getStylecss(getSkin(), serverData);
288 |  |
         }
289 |  |
290 |  |
         /**
291 |  |
          * Retrieve the URL for the style sheet that is part of the skin. The style
292 |  |
          * is stored in the WEBAPP/resources/ui/skins/[SKIN] directory with the
293 |  |
          * filename skin.css
294 |  |
          * @return the CSS URL
295 |  |
          */
296 |  |
         public String getStylecss()
297 |  |
         {
298 | 0 |
             return TurbineUI.getStylecss(getSkin());
299 |  |
         }
300 |  |
301 |  |
         /**
302 |  |
          * Retrieve the URL for a given script that is part of the skin. The script
303 |  |
          * is stored in the WEBAPP/resources/ui/skins/[SKIN] directory.
304 |  |
          *
305 |  |
          * <p>Use this if for some reason your server name, server scheme, or server
306 |  |
          * port change on a per request basis. I'm not sure if this would happen in
307 |  |
          * a load balanced situation. I think in most cases the image(String image)
308 |  |
          * method would probably be enough, but I'm not absolutely positive.
309 |  |
          *
310 |  |
          * @param filename the name of the script file whose URL will be generated.
311 |  |
          * @param data the RunDate to use as the source of the ServerData to use as
312 |  |
          * the basis for the URL.
313 |  |
          * @return the script URL
314 |  |
          */
315 |  |
         public String getScript(String filename, RunData data)
316 |  |
         {
317 | 0 |
             return getScript(filename, data.getServerData());
318 |  |
         }
319 |  |
320 |  |
         /**
321 |  |
          * Retrieve the URL for a given script that is part of the skin. The script
322 |  |
          * is stored in the WEBAPP/resources/ui/skins/[SKIN] directory.
323 |  |
          *
324 |  |
          * <p>Use this if for some reason your server name, server scheme, or server
325 |  |
          * port change on a per request basis. I'm not sure if this would happen in
326 |  |
          * a load balanced situation. I think in most cases the image(String image)
327 |  |
          * method would probably be enough, but I'm not absolutely positive.
328 |  |
          *
329 |  |
          * @param filename the name of the script file whose URL will be generated.
330 |  |
          * @param serverData the serverData to use as the basis for the URL.
331 |  |
          * @return the script URL
332 |  |
          */
333 |  |
         public String getScript(String filename, ServerData serverData)
334 |  |
         {
335 | 0 |
             return TurbineUI.getScript(getSkin(), filename, serverData);
336 |  |
         }
337 |  |
338 |  |
         /**
339 |  |
          * Retrieve the URL for a given script that is part of the skin. The script
340 |  |
          * is stored in the WEBAPP/resources/ui/skins/[SKIN] directory.
341 |  |
          *
342 |  |
          * @param filename the name of the script file whose URL will be generated.
343 |  |
          * @return the script URL
344 |  |
          */
345 |  |
         public String getScript(String filename)
346 |  |
         {
347 | 0 |
             return TurbineUI.getScript(getSkin(), filename);
348 |  |
         }
349 |  |
350 |  |
         /**
351 |  |
          * Initialize the UITool object.
352 |  |
          *
353 |  |
          * @param data This is null, RunData or User depending upon specified tool
354 |  |
          * scope.
355 |  |
          */
356 |  |
         @Override
357 |  |
         public void init(Object data)
358 |  |
         {
359 | 17 |
             if (data == null)
360 |  |
             {
361 | 17 |
                 log.debug("UITool scope is global");
362 | 17 |
                 setSkin();
363 |  |
             }
364 | 0 |
             else if (data instanceof RunData)
365 |  |
             {
366 | 0 |
                 log.debug("UITool scope is request");
367 | 0 |
                 setSkin((RunData) data);
368 |  |
             }
369 | 0 |
             else if (data instanceof PipelineData)
370 |  |
             {
371 | 0 |
                 PipelineData pipelineData = (PipelineData) data;
372 | 0 |
                 RunData runData = (RunData)pipelineData;
373 | 0 |
                 log.debug("UITool scope is request");
374 | 0 |
                 setSkin(runData);
375 | 0 |
             }
376 | 0 |
             else if (data instanceof User)
377 |  |
             {
378 | 0 |
                 log.debug("UITool scope is session");
379 | 0 |
                 setSkin((User) data);
380 |  |
             }
381 | 17 |
         }
382 |  |
383 |  |
     }