MonoRail/Castle.MonoRail.Framework/Configuration/ViewEngineConfig.cs

   1 // Copyright 2004-2007 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 namespace Castle.MonoRail.Framework.Configuration
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Configuration;
  20         using System.IO;
  21         using System.Xml;
  22         using Castle.MonoRail.Framework.Internal;
  23
  24         /// <summary>
  25         /// Represents the view engines configuration
  26         /// </summary>
  27         public class ViewEngineConfig : ISerializedConfig
  28         {
  29                 private String viewPathRoot;
  30                 private AssemblySourceInfo[] sources = new AssemblySourceInfo[0];
  31                 private ViewEngineInfo[] viewEngines = new ViewEngineInfo[0];
  32
  33                 #region ISerializedConfig implementation
  34
  35                 /// <summary>
  36                 /// Deserializes the specified section.
  37                 /// </summary>
  38                 /// <param name="section">The section.</param>
  39                 public void Deserialize(XmlNode section)
  40                 {
  41                         XmlElement engines = (XmlElement) section.SelectSingleNode("viewEngines");
  42
  43                         if (engines != null)
  44                         {
  45                                 ConfigureMultipleViewEngines(engines);
  46                         }
  47                         else
  48                         {
  49                                 // Backward compatibility
  50
  51                                 ConfigureSingleViewEngine(section);
  52                         }
  53
  54                         LoadAdditionalSources(section);
  55                         ResolveViewPath();
  56                 }
  57
  58                 #endregion
  59
  60                 /// <summary>
  61                 /// Gets or sets the view path root.
  62                 /// </summary>
  63                 /// <value>The view path root.</value>
  64                 public String ViewPathRoot
  65                 {
  66                         get { return viewPathRoot; }
  67                         set { viewPathRoot = value; }
  68                 }
  69
  70                 /// <summary>
  71                 /// Gets the view engines.
  72                 /// </summary>
  73                 /// <value>The view engines.</value>
  74                 public ViewEngineInfo[] ViewEngines
  75                 {
  76                         get { return viewEngines; }
  77                 }
  78
  79                 /// <summary>
  80                 /// Gets or sets the additional assembly sources.
  81                 /// </summary>
  82                 /// <value>The sources.</value>
  83                 public AssemblySourceInfo[] Sources
  84                 {
  85                         get { return sources; }
  86                         set { sources = value; }
  87                 }
  88
  89                 private void ConfigureMultipleViewEngines(XmlElement engines)
  90                 {
  91                         viewPathRoot = engines.GetAttribute("viewPathRoot");
  92
  93                         if (viewPathRoot == null || viewPathRoot == String.Empty)
  94                         {
  95                                 viewPathRoot = "views";
  96                         }
  97
  98                         ArrayList viewEnginesList = new ArrayList();
  99
 100                         foreach (XmlElement addNode in engines.SelectNodes("add"))
 101                         {
 102                                 string typeName = addNode.GetAttribute("type");
 103                                 string xhtmlVal = addNode.GetAttribute("xhtml");
 104
 105                                 if (typeName == null || typeName.Length == 0)
 106                                 {
 107                                         String message = "The attribute 'type' is required for the element 'add' under 'viewEngines'";
 108                                         throw new ConfigurationErrorsException(message);
 109                                 }
 110
 111                                 Type engine = TypeLoadUtil.GetType(typeName, true);
 112
 113                                 if (engine == null)
 114                                 {
 115                                         String message = "The type '" + typeName + "' could not be loaded";
 116                                         throw new ConfigurationErrorsException(message);
 117                                 }
 118
 119                                 viewEnginesList.Add(new ViewEngineInfo(engine, xhtmlVal == "true"));
 120                         }
 121
 122                         if (viewEnginesList.Count == 0)
 123                         {
 124                                 ConfigureDefaultViewEngine();
 125                         }
 126                         else
 127                         {
 128                                 viewEngines = new ViewEngineInfo[viewEnginesList.Count];
 129                                 viewEnginesList.CopyTo(viewEngines);
 130                         }
 131                 }
 132
 133                 private void ResolveViewPath()
 134                 {
 135                         if (!Path.IsPathRooted(viewPathRoot))
 136                         {
 137                                 viewPathRoot = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, viewPathRoot);
 138                         }
 139                 }
 140
 141                 /// <summary>
 142                 /// Configures the default view engine.
 143                 /// </summary>
 144                 private void ConfigureDefaultViewEngine()
 145                 {
 146                         viewPathRoot = "views";
 147
 148                         Type engineType = typeof(Castle.MonoRail.Framework.Views.Aspx.WebFormsViewEngine);
 149
 150                         viewEngines = new ViewEngineInfo[] {new ViewEngineInfo(engineType, false)};
 151                 }
 152
 153                 private void ConfigureSingleViewEngine(XmlNode section)
 154                 {
 155                         section = section.SelectSingleNode("viewEngine");
 156
 157                         if (section == null)
 158                         {
 159                                 ConfigureDefaultViewEngine();
 160
 161                                 return;
 162                         }
 163
 164                         XmlAttribute viewPath = section.Attributes["viewPathRoot"];
 165
 166                         if (viewPath == null)
 167                         {
 168                                 viewPathRoot = "views";
 169                         }
 170                         else
 171                         {
 172                                 viewPathRoot = viewPath.Value;
 173                         }
 174
 175                         XmlAttribute xhtmlRendering = section.Attributes["xhtmlRendering"];
 176
 177                         bool enableXhtmlRendering = false;
 178
 179                         if (xhtmlRendering != null)
 180                         {
 181                                 try
 182                                 {
 183                                         enableXhtmlRendering = xhtmlRendering.Value.ToLowerInvariant() == "true";
 184                                 }
 185                                 catch(FormatException ex)
 186                                 {
 187                                         String message = "The xhtmlRendering attribute of the views node must be a boolean value.";
 188                                         throw new ConfigurationErrorsException(message, ex);
 189                                 }
 190                         }
 191
 192                         XmlAttribute customEngineAtt = section.Attributes["customEngine"];
 193
 194                         Type engineType = typeof(Castle.MonoRail.Framework.Views.Aspx.WebFormsViewEngine);
 195
 196                         if (customEngineAtt != null)
 197                         {
 198                                 engineType = TypeLoadUtil.GetType(customEngineAtt.Value);
 199                         }
 200
 201                         viewEngines = new ViewEngineInfo[] {new ViewEngineInfo(engineType, enableXhtmlRendering)};
 202
 203                 }
 204
 205                 private void LoadAdditionalSources(XmlNode section)
 206                 {
 207                         ArrayList items = new ArrayList();
 208
 209                         foreach(XmlElement assemblyNode in section.SelectNodes("/monorail/*/additionalSources/assembly"))
 210                         {
 211                                 String assemblyName = assemblyNode.GetAttribute("name");
 212                                 String ns = assemblyNode.GetAttribute("namespace");
 213
 214                                 items.Add(new AssemblySourceInfo(assemblyName, ns));
 215                         }
 216
 217                         sources = (AssemblySourceInfo[]) items.ToArray(typeof(AssemblySourceInfo));
 218                 }
 219         }
 220 }