Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/Compilation/PageThemeCodeDomTreeGenerator.cs

@@ -0,0 +1,342 @@
+//------------------------------------------------------------------------------
+// <copyright file="PageThemeCodeDomTreeGenerator.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+using System.Reflection;
+using System.ComponentModel;
+using System.CodeDom;
+using System.CodeDom.Compiler;
+using System.Globalization;
+using System.IO;
+using System.Web.UI;
+using System.Web.Util;
+using Debug=System.Web.Util.Debug;
+
+namespace System.Web.Compilation {
+
+    internal class PageThemeCodeDomTreeGenerator : BaseTemplateCodeDomTreeGenerator {
+
+        private Hashtable _controlSkinTypeNameCollection = new Hashtable();
+        private ArrayList _controlSkinBuilderEntryList = new ArrayList();
+
+        private int _controlCount = 0;
+        private CodeTypeReference _controlSkinDelegateType = new CodeTypeReference(typeof(ControlSkinDelegate));
+        private CodeTypeReference _controlSkinType = new CodeTypeReference(typeof(ControlSkin));
+
+        private PageThemeParser _themeParser;
+        private const string _controlSkinsVarName = "__controlSkins";
+        private const string _controlSkinsPropertyName = "ControlSkins";
+        private const string _linkedStyleSheetsVarName = "__linkedStyleSheets";
+        private const string _linkedStyleSheetsPropertyName = "LinkedStyleSheets";
+
+        internal PageThemeCodeDomTreeGenerator(PageThemeParser parser) : base(parser) {
+            _themeParser = parser;
+        }
+
+        private void AddMemberOverride(string name, Type type, CodeExpression expr) {
+            CodeMemberProperty member = new CodeMemberProperty();
+            member.Name = name;
+            member.Attributes = MemberAttributes.Override | MemberAttributes.Family;
+            member.Type = new CodeTypeReference(type.FullName);
+            CodeMethodReturnStatement returnStmt = new CodeMethodReturnStatement(expr);
+            member.GetStatements.Add(returnStmt);
+            _sourceDataClass.Members.Add(member);
+        }
+
+        private void BuildControlSkins(CodeStatementCollection statements) {
+            foreach (ControlSkinBuilderEntry entry in _controlSkinBuilderEntryList) {
+                string skinID = entry.SkinID;
+                ControlBuilder builder = entry.Builder;
+                statements.Add(BuildControlSkinAssignmentStatement(builder, skinID));
+            }
+        }
+
+        private CodeStatement BuildControlSkinAssignmentStatement(
+            ControlBuilder builder, string skinID) {
+
+            Type controlType = builder.ControlType;
+
+            string keyVarName = GetMethodNameForBuilder(buildMethodPrefix, builder) + "_skinKey";
+
+            // e.g.
+            // private static object __BuildControl__control3_skinKey = PageTheme.CreateSkinKey(typeof({controlType}), {skinID});
+            CodeMemberField field = new CodeMemberField(typeof(object), keyVarName);
+            field.Attributes = MemberAttributes.Static | MemberAttributes.Private;
+            CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression();
+            cmie.Method = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(PageTheme)), "CreateSkinKey");
+            cmie.Parameters.Add(new CodeTypeOfExpression(controlType));
+            cmie.Parameters.Add(new CodePrimitiveExpression(skinID));
+            field.InitExpression = cmie;
+            _sourceDataClass.Members.Add(field);
+
+            // e.g. this.__namedControlSkins[keyVarName] =
+            //          new System.Web.UI.ControlSkin(typeof(System.Web.UI.WebControls.Label),
+            //          new System.Web.UI.ControlSkinDelegate(this.__BuildControl__control3));
+            CodeFieldReferenceExpression varExpr = new CodeFieldReferenceExpression(
+                new CodeThisReferenceExpression(),
+                _controlSkinsVarName);
+
+            CodeIndexerExpression indexerExpr = new CodeIndexerExpression(
+                varExpr,
+                new CodeExpression[] {
+                    new CodeVariableReferenceExpression(keyVarName)
+                }
+            );
+
+            CodeDelegateCreateExpression del = new CodeDelegateCreateExpression(
+                                                            _controlSkinDelegateType,
+                                                            new CodeThisReferenceExpression(),
+                                                            GetMethodNameForBuilder(buildMethodPrefix, builder));
+            CodeObjectCreateExpression valueExpr = new CodeObjectCreateExpression(_controlSkinType);
+            valueExpr.Parameters.Add(new CodeTypeOfExpression(controlType));
+            valueExpr.Parameters.Add(del);
+
+            return new CodeAssignStatement(indexerExpr, valueExpr);
+        }
+
+        private void BuildControlSkinMember() {
+            // e.g.
+            // private System.Collections.Specialized.HybridDictionary __cssFileList =
+            //     new System.Collections.Specialized.HybridDictionary(2);
+            int initialSize = _controlSkinBuilderEntryList.Count;
+            CodeMemberField field = new CodeMemberField(typeof(HybridDictionary).FullName, _controlSkinsVarName);
+            CodeObjectCreateExpression expr = new CodeObjectCreateExpression(typeof(HybridDictionary));
+            expr.Parameters.Add(new CodePrimitiveExpression(initialSize));
+            field.InitExpression = expr;
+            _sourceDataClass.Members.Add(field);
+        }
+
+        private void BuildControlSkinProperty() {
+            // e.g.
+            //  protected override System.Collections.IDictionary ControlSkins {
+            //       get { return this.__controlSkins; }
+            //  }
+            CodeFieldReferenceExpression accessExpr = new CodeFieldReferenceExpression(
+                                                            new CodeThisReferenceExpression(),
+                                                            _controlSkinsVarName);
+
+            AddMemberOverride(_controlSkinsPropertyName, typeof(IDictionary), accessExpr);
+        }
+
+        private void BuildLinkedStyleSheetMember() {
+
+            // e.g.
+            // private System.String[] __linkedStyleSheets = new String[] {
+            //     "linkedStyleSheet1 vdirs",
+            //     "linkedStyleSheet2 vdirs",
+            // }
+            CodeMemberField field = new CodeMemberField(typeof(String[]), _linkedStyleSheetsVarName);
+
+            if (_themeParser.CssFileList != null && _themeParser.CssFileList.Count > 0) {
+                CodeExpression[] cssFiles = new CodeExpression[_themeParser.CssFileList.Count];
+                int i = 0;
+                foreach(String cssFile in _themeParser.CssFileList) {
+                    cssFiles[i++] = new CodePrimitiveExpression(cssFile);
+                }
+                
+                CodeArrayCreateExpression initExpr = new CodeArrayCreateExpression(typeof(String), cssFiles);
+                field.InitExpression = initExpr;
+            }
+            else {
+                field.InitExpression = new CodePrimitiveExpression(null);
+            }
+            _sourceDataClass.Members.Add(field);
+        }
+
+        private void BuildLinkedStyleSheetProperty() {
+            // e.g.
+            //  protected override String[] LinkedStyleSheets {
+            //       get { return this.__linkedStyleSheets; }
+            //  }
+            CodeFieldReferenceExpression accessExpr = new CodeFieldReferenceExpression(
+                                                            new CodeThisReferenceExpression(),
+                                                            _linkedStyleSheetsVarName);
+
+            AddMemberOverride(_linkedStyleSheetsPropertyName, typeof(String[]), accessExpr);
+        }
+
+        protected override void BuildInitStatements(CodeStatementCollection trueStatements, CodeStatementCollection topLevelStatements) {
+            base.BuildInitStatements(trueStatements, topLevelStatements);
+            BuildControlSkins(topLevelStatements);
+        }
+
+        protected override void BuildMiscClassMembers() {
+            base.BuildMiscClassMembers();
+
+            AddMemberOverride(templateSourceDirectoryName, typeof(String),
+                new CodePrimitiveExpression(_themeParser.VirtualDirPath.VirtualPathString));
+
+            BuildSourceDataTreeFromBuilder(_themeParser.RootBuilder,
+                false /*fInTemplate*/, false /*topLevelControlInTemplate*/, null /*pse*/);
+
+            BuildControlSkinMember();
+            BuildControlSkinProperty();
+            BuildLinkedStyleSheetMember();
+            BuildLinkedStyleSheetProperty();
+        }
+
+        protected override void BuildSourceDataTreeFromBuilder(ControlBuilder builder,
+                                                bool fInTemplate, bool topLevelControlInTemplate,
+                                                PropertyEntry pse) {
+
+            // Don't do anything for code blocks
+            if (builder is CodeBlockBuilder)
+                return;
+
+            // Is the current builder for a template?
+            bool fTemplate = (builder is TemplateBuilder);
+
+            // Is the current builder the root builder?
+            bool fRootBuilder = (builder == _themeParser.RootBuilder);
+
+            // Is this a control theme?
+            bool fControlSkin = !fInTemplate && !fTemplate && topLevelControlInTemplate;
+
+            // Ignore the ID attribute, always auto generate ID.
+            _controlCount++;
+            builder.ID = "__control" + _controlCount.ToString(NumberFormatInfo.InvariantInfo);
+            builder.IsGeneratedID = true;
+
+            // Check for the SkinID property.
+            if (fControlSkin && !(builder is DataBoundLiteralControlBuilder)) {
+
+                Type ctrlType = builder.ControlType;
+                Debug.Assert(typeof(Control).IsAssignableFrom(ctrlType));
+                Debug.Assert(ThemeableAttribute.IsTypeThemeable(ctrlType));
+
+                string skinID = builder.SkinID;
+                object skinKey = PageTheme.CreateSkinKey(builder.ControlType, skinID);
+
+                if (_controlSkinTypeNameCollection.Contains(skinKey)) {
+                    if (String.IsNullOrEmpty(skinID)) {
+                        throw new HttpParseException(SR.GetString(SR.Page_theme_default_theme_already_defined,
+                            builder.ControlType.FullName), null, builder.VirtualPath, null, builder.Line);
+                    }
+                    else {
+                        throw new HttpParseException(SR.GetString(SR.Page_theme_skinID_already_defined, skinID),
+                            null, builder.VirtualPath, null, builder.Line);
+                    }
+                }
+
+                _controlSkinTypeNameCollection.Add(skinKey, true);
+                _controlSkinBuilderEntryList.Add(new ControlSkinBuilderEntry(builder, skinID));
+            }
+
+            // Process the children
+            // only root builders and template builders are processed.
+            if (builder.SubBuilders != null) {
+                foreach (object child in builder.SubBuilders) {
+                    if (child is ControlBuilder) {
+                        bool isTopLevelCtrlInTemplate = fTemplate && typeof(Control).IsAssignableFrom(((ControlBuilder)child).ControlType);
+                        BuildSourceDataTreeFromBuilder((ControlBuilder)child, fInTemplate, isTopLevelCtrlInTemplate, null);
+                    }
+                }
+            }
+
+            foreach (TemplatePropertyEntry entry in builder.TemplatePropertyEntries) {
+                BuildSourceDataTreeFromBuilder(((TemplatePropertyEntry)entry).Builder, true, false /*topLevelControlInTemplate*/, entry);
+            }
+
+            foreach (ComplexPropertyEntry entry in builder.ComplexPropertyEntries) {
+                if (!(entry.Builder is StringPropertyBuilder)) {
+                    BuildSourceDataTreeFromBuilder(((ComplexPropertyEntry)entry).Builder, fInTemplate, false /*topLevelControlInTemplate*/, entry);
+                }
+            }
+
+            // Build a Build method for the control
+            // fControlSkin indicates whether the method is a theme build method.
+            if (!fRootBuilder) {
+                BuildBuildMethod(builder, fTemplate, fInTemplate, topLevelControlInTemplate, pse,
+                    fControlSkin);
+            }
+
+            // Build a Render method for the control, unless it has no code
+            if (!fControlSkin && builder.HasAspCode) {
+                BuildRenderMethod(builder, fTemplate);
+            }
+
+            // Build a method to extract values from the template
+            BuildExtractMethod(builder);
+
+            // Build a property binding method for the control
+            BuildPropertyBindingMethod(builder, fControlSkin);
+        }
+
+        internal override CodeExpression BuildStringPropertyExpression(PropertyEntry pse) {
+            // Make the UrlProperty based on virtualDirPath for control themes.
+            if (pse.PropertyInfo != null) {
+                UrlPropertyAttribute urlAttrib = Attribute.GetCustomAttribute(pse.PropertyInfo, typeof(UrlPropertyAttribute)) as UrlPropertyAttribute;
+
+                if (urlAttrib != null) {
+                    if (pse is SimplePropertyEntry) {
+                        SimplePropertyEntry spse = (SimplePropertyEntry)pse;
+
+                        string strValue = (string)spse.Value;
+                        if (UrlPath.IsRelativeUrl(strValue) && !UrlPath.IsAppRelativePath(strValue)) {
+                            spse.Value = UrlPath.MakeVirtualPathAppRelative(UrlPath.Combine(_themeParser.VirtualDirPath.VirtualPathString, strValue));
+                        }
+                    }
+                    else {
+                        Debug.Assert(pse is ComplexPropertyEntry);
+                        ComplexPropertyEntry cpe = (ComplexPropertyEntry)pse;
+                        StringPropertyBuilder builder = (StringPropertyBuilder)cpe.Builder;
+
+                        string strValue = (string)builder.BuildObject();
+                        if (UrlPath.IsRelativeUrl(strValue) && !UrlPath.IsAppRelativePath(strValue)) {
+                            cpe.Builder = new StringPropertyBuilder(UrlPath.MakeVirtualPathAppRelative(UrlPath.Combine(_themeParser.VirtualDirPath.VirtualPathString, strValue)));
+                        }
+                    }
+                }
+            }
+
+            return base.BuildStringPropertyExpression(pse);
+        }
+
+        protected override CodeAssignStatement BuildTemplatePropertyStatement(CodeExpression ctrlRefExpr) {
+
+            // e.g. __ctrl.AppRelativeTemplateSourceDirectory = this.AppRelativeTemplateSourceDirectory;
+            CodeAssignStatement assign = new CodeAssignStatement();
+            assign.Left = new CodePropertyReferenceExpression(ctrlRefExpr, templateSourceDirectoryName);
+            assign.Right = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), templateSourceDirectoryName);
+            return assign;
+        }
+
+        protected override string GetGeneratedClassName() {
+            string className = _themeParser.VirtualDirPath.FileName;
+            className = System.Web.UI.Util.MakeValidTypeNameFromString(className);
+
+            return className;
+        }
+
+        protected override bool UseResourceLiteralString(string s) {
+            // never use resource literal string, page theme does not support the required methods.
+            return false;
+        }
+
+        // Don't build the Profile property in Theme classes
+        protected override bool NeedProfileProperty { get { return false; } }
+
+        private class ControlSkinBuilderEntry {
+            private ControlBuilder _builder;
+            private string _id;
+
+            public ControlSkinBuilderEntry (ControlBuilder builder, string skinID) {
+                _builder = builder;
+                _id = skinID;
+            }
+
+            public ControlBuilder Builder {
+                get { return _builder; }
+            }
+
+            public String SkinID {
+                get { return _id == null? String.Empty : _id; }
+            }
+        }
+    }
+}