CompileLiteralTextParser.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / MIT / System / Web / UI / MobileControls / CompileLiteralTextParser.cs / 1305376 / CompileLiteralTextParser.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

using System; 
using System.Collections; 
using System.Collections.Specialized;
using System.Diagnostics; 
using System.Web.UI;

namespace System.Web.UI.MobileControls
{ 
    /*
     * CompileLiteralTextParser class. 
     * 
     * This is a specialized version of the LiteralTextParser class.
     * It creates a set of control builders from the parsed literal text. 
     *
     * Copyright (c) 2000 Microsoft Corporation
     */
 
    [Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
    internal class CompileLiteralTextParser : LiteralTextParser 
    { 
        TemplateParser _parser;
        ControlBuilder _parentBuilder; 
        String _fileName;
        int _lineNumber;
        IList _tagInnerTextElements = null;
 
        internal CompileLiteralTextParser(TemplateParser parser,
                                        ControlBuilder parentBuilder, 
                                        String fileName, 
                                        int lineNumber)
        { 
            _parser = parser;
            _parentBuilder = parentBuilder;
            _fileName = fileName;
            _lineNumber = lineNumber; 
        }
 
        protected override void ProcessElement(LiteralElement element) 
        {
            ControlBuilder subBuilder; 

            switch (element.Type)
            {
                case LiteralElementType.Text: 
                    Debug.Assert(_tagInnerTextElements == null);
                    subBuilder = ControlBuilder.CreateBuilderFromType( 
                                        _parser, _parentBuilder, 
                                        typeof(LiteralText), typeof(LiteralText).Name,
                                        null, 
                                        GetPropertyDictionary(element.Format, element.BreakAfter, null),
                                        _lineNumber, _fileName);
                    break;
 
                case LiteralElementType.Anchor:
                { 
                    String linkUrl = (String)element.GetAttribute("href"); 
                    subBuilder = ControlBuilder.CreateBuilderFromType(
                                        _parser, _parentBuilder, 
                                        typeof(LiteralLink), typeof(LiteralLink).Name,
                                        null,
                                        GetPropertyDictionary(element.Format, element.BreakAfter, linkUrl),
                                        _lineNumber, _fileName); 
                    AddTagInnerTextElements(subBuilder);
                    break; 
                } 

                default: 
                    return;
            }

            _parentBuilder.AppendSubBuilder(subBuilder); 

            if (element.Text == null || element.Text.Length != 0) 
            { 
                subBuilder.AppendLiteralString(element.Text);
            } 
        }

        private IList TagInnerTextElements
        { 
            get
            { 
                if (_tagInnerTextElements == null) 
                {
                    _tagInnerTextElements = new ArrayList(); 
                }
                return _tagInnerTextElements;
            }
        } 

        private void AddTagInnerTextElements(ControlBuilder builder) 
        { 
            if (_tagInnerTextElements != null)
            { 
                foreach(Object o in _tagInnerTextElements)
                {
                    if (o is String)
                    { 
                        builder.AppendLiteralString((String)o);
                    } 
                    else 
                    {
                        builder.AppendSubBuilder((ControlBuilder)o); 
                    }
                }
                _tagInnerTextElements = null;
            } 
        }
 
        protected override void ProcessTagInnerText(String text) 
        {
            // Called to add an inner text segment of a multi-segment tag, e.g. 
            //      some text <%# a databinding %> some more text

            TagInnerTextElements.Add(text);
        } 

        internal /*public*/ void AddDataBinding(ControlBuilder builder) 
        { 
            if (IsInTag)
            { 
                TagInnerTextElements.Add(builder);
            }
            else
            { 
                ControlBuilder newBuilder = ControlBuilder.CreateBuilderFromType(
                                              _parser, _parentBuilder, 
                                              typeof(LiteralText), typeof(LiteralText).Name, 
                                            null,
                                            GetPropertyDictionary(CurrentFormat, false, null), 
                                            _lineNumber, _fileName);
                _parentBuilder.AppendSubBuilder(newBuilder);
                newBuilder.AppendSubBuilder(builder);
                OnAfterDataBoundLiteral(); 
            }
        } 
 
        // Convert formatting and other options into a set of properties, just as if they had been
        // specified in persistence format. 

        private ListDictionary GetPropertyDictionary(LiteralFormat format, bool breakAfter, String linkUrl)
        {
            ListDictionary dictionary = null; 
            if (format != LiteralFormat.None || !breakAfter || linkUrl != null)
            { 
                dictionary = new ListDictionary(); 
                if ((format & LiteralFormat.Bold) == LiteralFormat.Bold)
                { 
                    dictionary.Add("Font-Bold", "True");
                }
                if ((format & LiteralFormat.Italic) == LiteralFormat.Italic)
                { 
                    dictionary.Add("Font-Italic", "True");
                } 
                if(!breakAfter) 
                {
                    dictionary.Add("BreakAfter", "False"); 
                }
                if (linkUrl != null)
                {
                    dictionary.Add("NavigateUrl", linkUrl); 
                }
            } 
 
            return dictionary;
        } 
    }

}
 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK