Represents an attached template control, such as dataview or content.
Inheritance: Element
コード例 #1
0
ファイル: Block.cs プロジェクト: vc3/ExoWeb
		/// <summary>
		/// Determines whether the given control is a template (should have the sys-template class)
		/// </summary>
		/// <param name="control"></param>
		/// <returns></returns>
		private static bool IsTemplate(Control control)
		{
			bool result = false;

			// DataView and Template create a new template context
			if (control is DataView || control is Template)
				result = true;
			// Toggle creates a new template context if using render/dispose mode
			else if (control is Toggle)
				result = ((Toggle)control).IsTemplate();

			return result;
		}
コード例 #2
0
ファイル: Block.cs プロジェクト: vc3/ExoWeb
		/// <summary>
		/// Parses the children of the specified element into a list of template blocks.
		/// </summary>
		/// <param name="source">The original string source of the template.</param>
		/// <param name="element">The element to parse</param>
		/// <param name="withinTemplate">Indicates that the children of the given element are within a template control.</param>
		/// <param name="lastNestedTemplateIndex">Tracks the index of the last template element that was encountered. Passed through to recursive calls excluding templates.</param>
		/// <param name="nestedTemplates">Out parameter that returns the number of template controls represented by the children of the given element.</param>
		/// <returns>A list of template blocks.</returns>
		static List<Block> ParseChildren(string source, XmlElement element, bool withinTemplate, int lastNestedTemplateIndex, out int nestedTemplates)
		{
			// Track the blocks represented by the current element
			var blocks = new List<Block>();

			nestedTemplates = 0;

			// Process the child nodes of the current element
			foreach (XmlNode node in element.ChildNodes)
			{
				switch (node.NodeType)
				{
					// XML Element, which could be a control, bound element start tag, or just literal content
					case XmlNodeType.Element:

						var child = (XmlElement)node;

						// Control
						if (child.HasAttribute("sys:attach") ||
							child.HasAttribute("sys:if") ||
							child.HasAttribute("sys:content-template") ||
							child.HasAttribute("sys:id") ||
							child.HasAttribute("id"))
						{
							bool parseChildren = true;
							Control control;
							if (child.HasAttribute("sys:attach"))
							{
								switch (child.GetAttribute("sys:attach"))
								{
									// Template
									case "template":
										control = new Template()
										{
											Attributes = GetAttributes(child, "class", "sys:attach", "sys:if", "sys:content-template", "template:name", "template:kind", "template:datatype", "template:islist", "template:isreference"),
											Name = GetLiteralTokens(child, "template:name"),
											Source = source + " [" + child.GetAttribute("template:name") + "]" + (child.HasAttribute("template:datatype") ? " - " + child.GetAttribute("template:datatype") : ""),
											IsList = GetBoolean(child, "template:islist"),
											IsReference = GetBoolean(child, "template:isreference"),
											Kind = GetStringLiteral(child, "template:kind"),
											DataType = GetStringLiteral(child, "template:datatype"),
											Class = GetLiteralTokens(child, "class").Where(c => c.ToLower() != "sys-template").ToArray(),
											ContentTemplateNames = GetLiteralTokens(child, "sys:content-template")
										};
										break;

									// DataView
									case "dataview":
										control = new DataView()
										{
											Attributes = GetAttributes(child, "sys:attach", "sys:if", "sys:content-template", "dataview:data"),
											Data = GetBinding(child, "dataview:data"),
											Template = GetTemplate(child),
											ContentTemplate = GetBinding(child, "sys:content-template")
										};
										break;

									// Content
									case "content":
										control = new Content()
										{
											Attributes = GetAttributes(child, "sys:attach", "sys:if", "sys:content-template", "content:data", "content:template"),
											Data = GetBinding(child, "content:data"),
											Template = GetBinding(child, "content:template"),
											DataType = GetBinding(child, "content:datatype"),
											ContentTemplate = GetBinding(child, "sys:content-template")
										};
										break;

									// Toggle
									case "toggle":
										control = new Toggle() 
										{
											Attributes = GetAttributes(child, "sys:attach", "sys:if", "sys:content-template", "toggle:on", "toggle:action", "toggle:class", "toggle:groupname", "toggle:strictmode", "toggle:when"),
											On = GetBinding(child, "toggle:on"),
											Class = GetBinding(child, "toggle:class"),
											ClassName = GetBinding(child, "toggle:classname"),
											Action = GetBinding(child, "toggle:action"),
											GroupName = GetBinding(child, "toggle:groupname"),
											StrictMode = GetBinding(child, "toggle:strictmode"),
											When = GetBinding(child, "toggle:when"),
											ContentTemplate = GetBinding(child, "sys:content-template")
										};
										break;

									// ToggleGroup
									case "togglegroup":
										control = new ToggleGroup()
										{
											Attributes = GetAttributes(child, "sys:attach", "sys:if", "sys:content-template"),
											ContentTemplate = GetBinding(child, "sys:content-template")
										};
										break;

									// Behavior
									case "behavior":
										control = new Behavior()
										{
											Attributes = GetAttributes(child, "sys:attach", "sys:if", "sys:content-template"),
											ContentTemplate = GetBinding(child, "sys:content-template")
										};
										break;

									// Html
									case "html":
										control = new Html()
										{
											Attributes = GetAttributes(child, "sys:attach", "sys:if", "sys:content-template"),
											ContentTemplate = GetBinding(child, "sys:content-template")
										};
										break;

									default:
										throw new ArgumentException("Controls of type '" + child.GetAttribute("sys:attach") + "' are not supported for server rendering.");
								}

								// Add data-sys-attach to indicate the control type when performing linking on the client
								control.Attributes.Add(new Attribute() { Name = "data-sys-attach", Value = child.GetAttribute("sys:attach") });
							}
							else
							{
								control = new Control()
								{
									Attributes = GetAttributes(child, "sys:if", "sys:content-template", "sys:innerhtml", "sys:innertext"),
									ContentTemplate = GetBinding(child, "sys:content-template"),
									IsEmpty = child.ChildNodes.Count == 0
								};
								if (child.InnerXml.Trim().StartsWith("{") && child.InnerXml.Trim().EndsWith("}"))
								{
									parseChildren = false;
									control.Attributes.Add(new Attribute() { Name = "innerhtml", Binding = Binding.Parse(GetDefaultProperty(child), child.InnerXml.Trim()), Value = child.InnerXml.Trim() });
									control.IsEmpty = true;
								}
							}

							var isTemplate = IsTemplate(control);

							// If the sys:content-template attribute is found, then ensure it is within or on a templated control
							if (child.HasAttribute("sys:content-template") && !withinTemplate && !isTemplate)
								throw new ApplicationException("The sys:content-template attribute must be used on or within an control that implements Sys.UI.IContentTemplateConsumer.");

							// Process the controls child blocks
							if (parseChildren)
							{
								// Determine the number of top-level templates represented by this node
								int numTopLevelTemplates;

								if (isTemplate)
								{
									// A templated control represents only 1 top-level nested template
									numTopLevelTemplates = 1;

									// Set nested template index
									control.NestedTemplateIndex = lastNestedTemplateIndex + 1;

									// Parse child blocks as a new template region.  This means that lastNestedTemplateIndex
									// starts fresh (-1) and the number of child templates are not relevant here.
									control.Blocks = ParseChildren(source, child, true);
								}
								else
									// Parse children and capture the number of top-level templates contained within
									control.Blocks = ParseChildren(source, child, withinTemplate, lastNestedTemplateIndex, out numTopLevelTemplates);

								// Increment the number of nested templates and last index by
								// the number of top-level templates that this node represents
								nestedTemplates += numTopLevelTemplates;
								lastNestedTemplateIndex += numTopLevelTemplates;
							}
							else
								// A non-control with a binding expression as its inner-html contains no blocks
								control.Blocks = new List<Block>();

							control.Tag = child.Name;
							control.Markup = GetMarkup(child);
							control.If = GetBinding(child, "sys:if");

							// Add the control
							blocks.Add(control);
						}

						// Element
						else if (child.Attributes.Cast<XmlAttribute>().Any(a => a.Value.StartsWith("{") && a.Value.EndsWith("}")) ||
								 (child.ChildNodes.Cast<XmlNode>().All(n => n.NodeType != XmlNodeType.Element) && child.InnerXml.Trim().StartsWith("{") && child.InnerXml.Trim().EndsWith("}")))
						{
							var isBinding = child.InnerXml.Trim().StartsWith("{") && child.InnerXml.Trim().EndsWith("}");

							// Add the bound element
							var e = new Element()
							{
								Markup = isBinding || child.ChildNodes.Count == 0 ? GetMarkup(child) : GetElementMarkup(child),
								Attributes = GetAttributes(child),
								Tag = child.Name,
								IsEmpty = isBinding || child.ChildNodes.Count == 0
							};

							if (isBinding)
								e.Attributes.Add(new Attribute() { Name = "innerhtml", Binding = Binding.Parse(GetDefaultProperty(child), child.InnerXml.Trim()) });

							blocks.Add(e);

							// Process child nodes, if the element content is not bound
							if (!e.IsEmpty)
							{
								int numTopLevelTemplates;
								var children = ParseChildren(source, child, withinTemplate, lastNestedTemplateIndex, out numTopLevelTemplates);
								lastNestedTemplateIndex += numTopLevelTemplates;
								nestedTemplates += numTopLevelTemplates;

								blocks.AddRange(children);
								blocks.Add(new Block() { Markup = "</" + child.Name + ">" });
							}
						}

						// Literal
						else
						{
							// Get the blocks contained by the literal element
							int numTopLevelTemplates;
							var children = ParseChildren(source, child, withinTemplate, lastNestedTemplateIndex, out numTopLevelTemplates);
							lastNestedTemplateIndex += numTopLevelTemplates;
							nestedTemplates += numTopLevelTemplates;

							// Add the entire element as a block if it only contains literal content
							if (children.Count == 0 || (children.Count == 1 && children.First().GetType() == typeof(Block)))
								blocks.Add(new Block() { Markup = GetMarkup(child) });

							// Otherwise, process the child blocks
							else
							{
								blocks.Add(new Block() { Markup = GetElementMarkup(child) });
								blocks.AddRange(children);
								blocks.Add(new Block() { Markup = "</" + child.Name + ">" });
							}
						}
						break;

					// Literal content
					case XmlNodeType.Text:
						blocks.Add(new Block() { Markup = GetMarkup(node) });
						break;
				}
			}

			// Condense adjacent literal blocks
			Block literal = null;
			for (int i = blocks.Count - 1; i >= 0; i--)
			{
				if (blocks[i].GetType() == typeof(Block))
				{
					if (literal == null)
						literal = blocks[i];
					else
					{
						literal.Markup = blocks[i].Markup + literal.Markup;
						blocks.RemoveAt(i);
					}
				}
				else
					literal = null;
			}

			return blocks;
		}