?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixing an issue with output parameters that are of type IntPtr
[castle.git] / MonoRail / Castle.MonoRail.Framework.Views.NVelocity / NVelocityViewEngine.cs
blob0c72a5fbe6a79c9bcd39d3404d4609813247dba1
1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 using NVelocity;
16 using NVelocity.App;
17 using NVelocity.Context;
18 using NVelocity.Runtime;
19
20 namespace Castle.MonoRail.Framework.Views.NVelocity
21 {
22 using System;
23 using System.IO;
24 using System.Collections;
25 using System.Collections.Generic;
26 using System.Text;
27 using Castle.Core;
28 using Commons.Collections;
29 using JSGeneration;
30
31 /// <summary>
32 /// Implements a view engine using the popular Velocity syntax.
33 /// <para>
34 /// For details on the syntax, check the VTL Reference Guide
35 /// http://jakarta.apache.org/velocity/docs/vtl-reference-guide.html
36 /// </para>
37 /// </summary>
38 public class NVelocityViewEngine : ViewEngineBase, IInitializable
39 {
40 internal const String TemplateExtension = ".vm";
41 internal const String JsTemplateExtension = ".njs";
42 internal const String ServiceProvider = "service.provider";
43
44 protected readonly VelocityEngine velocity = new VelocityEngine();
45
46 private IServiceProvider provider;
47
48 #region IInitializable implementation
49
50 public void Initialize()
51 {
52 ExtendedProperties props = new ExtendedProperties();
53
54 if (ViewSourceLoader.HasSource("nvelocity.properties"))
55 {
56 using(Stream stream = ViewSourceLoader.GetViewSource("nvelocity.properties").OpenViewStream())
57 {
58 props.Load(stream);
59 }
60 }
61
62 // Set up a custom directive manager
63 props.SetProperty("directive.manager",
64 "Castle.MonoRail.Framework.Views.NVelocity.CustomDirectiveManager; Castle.MonoRail.Framework.Views.NVelocity");
65
66 InitializeVelocityProperties(props);
67
68 velocity.SetApplicationAttribute("service.provider", provider);
69
70 velocity.Init(props);
71 }
72
73 #endregion
74
75 #region IServiceEnabledComponent implementation
76
77 public override void Service(IServiceProvider provider)
78 {
79 base.Service(provider);
80 this.provider = provider;
81 }
82
83 #endregion
84
85 #region IViewEngine implementation
86
87 /// <summary>
88 /// Gets a value indicating whether the view engine
89 /// support the generation of JS.
90 /// </summary>
91 /// <value>
92 /// <c>true</c> if JS generation is supported; otherwise, <c>false</c>.
93 /// </value>
94 public override bool SupportsJSGeneration
95 {
96 get { return true; }
97 }
98
99 /// <summary>
100 /// Gets the view file extension.
101 /// </summary>
102 /// <value>The view file extension.</value>
103 public override string ViewFileExtension
104 {
105 get { return ".vm"; }
106 }
107
108 /// <summary>
109 /// Gets the JS generator file extension.
110 /// </summary>
111 /// <value>The JS generator file extension.</value>
112 public override string JSGeneratorFileExtension
113 {
114 get { return ".njs"; }
115 }
116
117 /// <summary>
118 /// Pendent.
119 /// </summary>
120 /// <param name="output">The output.</param>
121 /// <param name="context">The context.</param>
122 /// <param name="controller">The controller.</param>
123 /// <param name="controllerContext">The controller context.</param>
124 /// <param name="viewName">Name of the view.</param>
125 public override void Process(String viewName, TextWriter output, IEngineContext context,
126 IController controller, IControllerContext controllerContext)
127 {
128 IContext ctx = CreateContext(context, controller, controllerContext);
129
130 try
131 {
132 AdjustContentType(context);
133
134 bool hasLayout = controllerContext.LayoutNames != null && controllerContext.LayoutNames.Length != 0;
135
136 TextWriter writer;
137
138 if (hasLayout)
139 {
140 // Because we are rendering within a layout we need to catch it first
141 writer = new StringWriter();
142 }
143 else
144 {
145 // No layout so render direct to the output
146 writer = output;
147 }
148
149 String view = ResolveTemplateName(viewName);
150
151 Template template = velocity.GetTemplate(view);
152
153 PreSendView(controller, template);
154
155 BeforeMerge(velocity, template, ctx);
156 template.Merge(ctx, writer);
157
158 PostSendView(controller, template);
159
160 if (hasLayout)
161 {
162 ProcessLayoutRecursively((StringWriter) writer, context, controller, controllerContext, ctx, output);
163 }
164 }
165 catch(Exception ex)
166 {
167 if (Logger.IsErrorEnabled)
168 {
169 Logger.Error("Could not render view", ex);
170 }
171
172 throw;
173 }
174 }
175
176 public override void Process(string templateName, string layoutName,
177 TextWriter output, IDictionary<string, object> parameters)
178 {
179 IContext ctx = CreateContext(parameters);
180
181 try
182 {
183 bool hasLayout = layoutName != null;
184
185 TextWriter writer;
186
187 if (hasLayout)
188 {
189 // Because we are rendering within a layout we need to catch it first
190 writer = new StringWriter();
191 }
192 else
193 {
194 // No layout so render direct to the output
195 writer = output;
196 }
197
198 String view = ResolveTemplateName(templateName);
199
200 Template template = velocity.GetTemplate(view);
201
202 BeforeMerge(velocity, template, ctx);
203 template.Merge(ctx, writer);
204
205 if (hasLayout)
206 {
207 String contents = (writer as StringWriter).GetStringBuilder().ToString();
208 ProcessLayout(contents, layoutName, ctx, output);
209 }
210 }
211 catch(Exception ex)
212 {
213 if (Logger.IsErrorEnabled)
214 {
215 Logger.Error("Could not render view", ex);
216 }
217
218 throw;
219 }
220 }
221
222 public override void ProcessPartial(String partialName, TextWriter output, IEngineContext context,
223 IController controller, IControllerContext controllerContext)
224 {
225 IContext ctx = CreateContext(context, controller, controllerContext);
226 String view = ResolveTemplateName(partialName);
227
228 try
229 {
230 Template template = velocity.GetTemplate(view);
231 template.Merge(ctx, output);
232 }
233 catch(Exception ex)
234 {
235 if (Logger.IsErrorEnabled)
236 {
237 Logger.Error("Could not render partial", ex);
238 }
239
240 throw new MonoRailException("Could not render partial " + view, ex);
241 }
242 }
243
244 public override object CreateJSGenerator(JSCodeGeneratorInfo generatorInfo,
245 IEngineContext context, IController controller,
246 IControllerContext controllerContext)
247 {
248 return new JSGeneratorDuck(generatorInfo.CodeGenerator, generatorInfo.LibraryGenerator,
249 generatorInfo.Extensions, generatorInfo.ElementExtensions);
250 }
251
252 public override void GenerateJS(String templateName, TextWriter output, JSCodeGeneratorInfo generatorInfo,
253 IEngineContext context, IController controller,
254 IControllerContext controllerContext)
255 {
256 IContext ctx = CreateContext(context, controller, controllerContext);
257
258 object generator = CreateJSGenerator(generatorInfo, context, controller, controllerContext);
259
260 ctx.Put("page", generator);
261
262 AdjustJavascriptContentType(context);
263
264 String view = ResolveJSTemplateName(templateName);
265
266 try
267 {
268 Template template = velocity.GetTemplate(view);
269
270 StringWriter writer = new StringWriter();
271
272 template.Merge(ctx, writer);
273
274 output.WriteLine(generator);
275 }
276 catch(Exception ex)
277 {
278 if (Logger.IsErrorEnabled)
279 {
280 Logger.Error("Could not generate JS", ex);
281 }
282
283 throw new MonoRailException("Error generating JS. Template " + templateName, ex);
284 }
285 }
286
287 public override void RenderStaticWithinLayout(String contents, IEngineContext context, IController controller,
288 IControllerContext controllerContext)
289 {
290 IContext ctx = CreateContext(context, controller, controllerContext);
291 AdjustContentType(context);
292
293 bool hasLayout = controllerContext.LayoutNames != null && controllerContext.LayoutNames.Length != 0;
294
295 if (hasLayout)
296 {
297 ProcessLayout(contents, controller, controllerContext, ctx, context, context.Response.Output);
298 }
299 else
300 {
301 context.Response.Output.Write(contents);
302 }
303 }
304
305 #endregion
306
307 /// <summary>
308 /// Initializes basic velocity properties. The main purpose of this method is to
309 /// allow this logic to be overrided.
310 /// </summary>
311 /// <param name="props">The <see cref="ExtendedProperties"/> collection to populate.</param>
312 protected virtual void InitializeVelocityProperties(ExtendedProperties props)
313 {
314 velocity.SetApplicationAttribute(RuntimeConstants.RESOURCE_MANAGER_CLASS,
315 new CustomResourceManager(ViewSourceLoader));
316
317 LoadMacros(props);
318 }
319
320 /// <summary>
321 /// Resolves the layout template name into a velocity template file name.
322 /// </summary>
323 protected string ResolveLayoutTemplateName(string templateName)
324 {
325 if (templateName.StartsWith("/"))
326 {
327 // User is using a folder diferent than the layouts folder
328
329 return ResolveTemplateName(templateName);
330 }
331 else
332 {
333 return String.Format("{0}{1}{2}",
334 TemplateKeys.LayoutPath, Path.DirectorySeparatorChar,
335 ResolveTemplateName(templateName));
336 }
337 }
338
339 protected virtual void BeforeMerge(VelocityEngine velocityEngine, Template template, IContext context)
340 {
341 }
342
343 private void ProcessLayoutRecursively(StringWriter writer, IEngineContext context,
344 IController controller, IControllerContext controllerContext,
345 IContext ctx, TextWriter finalOutput)
346 {
347 for(int i = controllerContext.LayoutNames.Length - 1; i >= 0; i--)
348 {
349 string layoutName = ResolveLayoutTemplateName(controllerContext.LayoutNames[i]);
350
351 string contents = writer.GetStringBuilder().ToString();
352
353 BeforeApplyingLayout(layoutName, ref contents, controller, controllerContext, ctx, context);
354
355 writer.GetStringBuilder().Length = 0;
356
357 RenderLayout(layoutName, contents, ctx, i == 0 ? finalOutput : writer);
358 }
359 }
360
361 private void ProcessLayout(String contents, string layoutName, IContext ctx, TextWriter output)
362 {
363 RenderLayout(layoutName, contents, ctx, output);
364 }
365
366 private void ProcessLayout(String contents, IController controller, IControllerContext controllerContext, IContext ctx,
367 IEngineContext context, TextWriter output)
368 {
369 String layout = ResolveLayoutTemplateName(controllerContext.LayoutNames[0]);
370
371 BeforeApplyingLayout(layout, ref contents, controller, controllerContext, ctx, context);
372
373 RenderLayout(layout, contents, ctx, output);
374 }
375
376 protected virtual void BeforeApplyingLayout(string layout, ref string contents,
377 IController controller, IControllerContext controllerContext,
378 IContext ctx, IEngineContext context)
379 {
380 }
381
382 protected void RenderLayout(string layoutName, string contents, IContext ctx, TextWriter output)
383 {
384 ctx.Put(TemplateKeys.ChildContent, contents);
385
386 Template template = velocity.GetTemplate(layoutName);
387
388 BeforeMerge(velocity, template, ctx);
389
390 template.Merge(ctx, output);
391 }
392
393 private IContext CreateContext(IDictionary<string, object> parameters)
394 {
395 Hashtable innerContext = new Hashtable(StringComparer.InvariantCultureIgnoreCase);
396
397 foreach(KeyValuePair<string, object> pair in parameters)
398 {
399 innerContext[pair.Key] = pair.Value;
400 }
401
402 return new VelocityContext(innerContext);
403 }
404
405 private IContext CreateContext(IEngineContext context, IController controller, IControllerContext controllerContext)
406 {
407 IRequest request = context.Request;
408
409 Hashtable innerContext = new Hashtable(StringComparer.InvariantCultureIgnoreCase);
410
411 innerContext.Add(TemplateKeys.Controller, controller);
412 innerContext.Add(TemplateKeys.Context, context);
413 innerContext.Add(TemplateKeys.Request, context.Request);
414 innerContext.Add(TemplateKeys.Response, context.Response);
415 innerContext.Add(TemplateKeys.Session, context.Session);
416
417 if (controllerContext.Resources != null)
418 {
419 foreach(String key in controllerContext.Resources.Keys)
420 {
421 innerContext[key] = controllerContext.Resources[key];
422 }
423 }
424
425 foreach(String key in request.QueryString.AllKeys)
426 {
427 if (key == null) continue;
428 object value = request.QueryString[key];
429 if (value == null) continue;
430 innerContext[key] = value;
431 }
432 foreach(String key in request.Form.AllKeys)
433 {
434 if (key == null) continue;
435 object value = request.Form[key];
436 if (value == null) continue;
437 innerContext[key] = value;
438 }
439
440 // list from : http://msdn2.microsoft.com/en-us/library/hfa3fa08.aspx
441 object[] builtInHelpers =
442 new object[]
443 {
444 new StaticAccessorHelper<Byte>(),
445 new StaticAccessorHelper<SByte>(),
446 new StaticAccessorHelper<Int16>(),
447 new StaticAccessorHelper<Int32>(),
448 new StaticAccessorHelper<Int64>(),
449 new StaticAccessorHelper<UInt16>(),
450 new StaticAccessorHelper<UInt32>(),
451 new StaticAccessorHelper<UInt64>(),
452 new StaticAccessorHelper<Single>(),
453 new StaticAccessorHelper<Double>(),
454 new StaticAccessorHelper<Boolean>(),
455 new StaticAccessorHelper<Char>(),
456 new StaticAccessorHelper<Decimal>(),
457 new StaticAccessorHelper<String>(),
458 new StaticAccessorHelper<Guid>(),
459 new StaticAccessorHelper<DateTime>()
460 };
461
462 foreach(object helper in builtInHelpers)
463 {
464 innerContext[helper.GetType().GetGenericArguments()[0].Name] = helper;
465 }
466
467 if (controllerContext.Helpers != null)
468 {
469 foreach(object key in controllerContext.Helpers.Keys)
470 {
471 innerContext[key] = controllerContext.Helpers[key];
472 }
473 }
474
475 // Adding flash as a collection and each individual item
476
477 if (context.Flash != null)
478 {
479 innerContext[Flash.FlashKey] = context.Flash;
480
481 foreach(DictionaryEntry entry in context.Flash)
482 {
483 if (entry.Value == null) continue;
484 innerContext[entry.Key] = entry.Value;
485 }
486 }
487
488 if (controllerContext.PropertyBag != null)
489 {
490 foreach(DictionaryEntry entry in controllerContext.PropertyBag)
491 {
492 if (entry.Value == null) continue;
493 innerContext[entry.Key] = entry.Value;
494 }
495 }
496
497 innerContext[TemplateKeys.SiteRoot] = context.ApplicationPath;
498
499 return new VelocityContext(innerContext);
500 }
501
502 private void LoadMacros(ExtendedProperties props)
503 {
504 String[] macros = ViewSourceLoader.ListViews("macros",this.ViewFileExtension,this.JSGeneratorFileExtension);
505
506 ArrayList macroList = new ArrayList(macros);
507
508 if (macroList.Count > 0)
509 {
510 object libPropValue = props.GetProperty(RuntimeConstants.VM_LIBRARY);
511
512 if (libPropValue is ICollection)
513 {
514 macroList.AddRange((ICollection) libPropValue);
515 }
516 else if (libPropValue is string)
517 {
518 macroList.Add(libPropValue);
519 }
520
521 props.AddProperty(RuntimeConstants.VM_LIBRARY, macroList);
522 }
523
524 props.AddProperty(RuntimeConstants.VM_LIBRARY_AUTORELOAD, true);
525 }
526 }
527 }
Git import of castle svn