LiteralControl.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / fx / src / xsp / System / Web / UI / LiteralControl.cs / 1 / LiteralControl.cs
                        

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

/* 
 * Control that holds a literal string 
 *
 * Copyright (c) 1999 Microsoft Corporation 
 */

namespace System.Web.UI {
 
    using System;
    using System.ComponentModel; 
    using System.ComponentModel.Design; 
    using System.IO;
    using System.Security.Permissions; 


    /// 
    /// Defines the properties and methods of the LiteralControl class. A 
    ///    literal control is usually rendered as HTML text on a page. 
    ///  
    ///    LiteralControls behave as text holders, i.e., the parent of a LiteralControl may decide 
    ///    to extract its text, and remove the control from its Control collection (typically for
    ///    performance reasons). 
    ///    Therefore a control derived from LiteralControl must do any preprocessing of its Text
    ///    when it hands it out, that it would otherwise have done in its Render implementation.
    /// 
    ///  
    [
    ToolboxItem(false) 
    ] 
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)] 
    public class LiteralControl : Control, ITextControl
#if ORCAS
        , IPaginationInfo
#endif 
    {
        internal string _text; 
 

        ///  
        ///    Creates a control that holds a literal string.
        /// 
        public LiteralControl() {
            PreventAutoID(); 
            SetEnableViewStateInternal(false);
        } 
 

        ///  
        /// Initializes a new instance of the LiteralControl class with
        ///    the specified text.
        /// 
        public LiteralControl(string text) : this() { 
            _text = (text != null) ? text : String.Empty;
        } 
 

        ///  
        ///    Gets or sets the text content of the literal control.
        /// 
        public virtual string Text {
            get { 
                return _text;
            } 
            set { 
                _text = (value != null) ? value : String.Empty;
            } 
        }


        protected override ControlCollection CreateControlCollection() { 
            return new EmptyControlCollection(this);
        } 
#if ORCAS 

        ///  
        bool IPaginationInfo.PaginateChildren {
            get {
                return PaginateChildren;
            } 
        }
 
 
        /// 
        protected virtual bool PaginateChildren { 
            get {
                return false;
            }
        } 

 
        ///  
        int IPaginationInfo.Weight {
            get { 
                return Weight;
            }
        }
 

        ///  
        protected virtual int Weight { 
            get {
                int length = _text.Length; 
                if (length >= 50) {
                    return 100;
                }
                for (int i = 0; i < length; i++) { 
                    if (i==50 || !Char.IsWhiteSpace(_text, i)) {
                        return 100; 
                    } 
                }
                return 0; 
            }
        }
#endif
 

        ///  
        ///    Saves any state that was modified after mark. 
        /// 
        protected internal override void Render(HtmlTextWriter output) { 
            output.Write(_text);
        }

        internal override void InitRecursive(Control namingContainer) { 
            ResolveAdapter();
            if (_adapter != null) { 
                _adapter.OnInit(EventArgs.Empty); 
            }
            else { 
                OnInit(EventArgs.Empty);
            }

        } 

        internal override void LoadRecursive() { 
            if(_adapter != null) { 
                _adapter.OnLoad(EventArgs.Empty);
            } 
            else {
                OnLoad(EventArgs.Empty);
            }
        } 

        internal override void PreRenderRecursiveInternal() { 
            if(_adapter != null) { 
                _adapter.OnPreRender(EventArgs.Empty);
            } 
            else {
                OnPreRender(EventArgs.Empty);
            }
        } 

        internal override void UnloadRecursive(bool dispose) { 
            if(_adapter != null) { 
                _adapter.OnUnload(EventArgs.Empty);
            } 
            else {
                OnUnload(EventArgs.Empty);
            }
 
            //
            if (dispose) 
                Dispose(); 
        }
 

    }

 
    /*
     * Class used to access literal strings stored in a resource (perf optimization). 
     * This class is only public because it needs to be used by the generated classes. 
     * Users should not use directly.
     */ 
    internal sealed class ResourceBasedLiteralControl : LiteralControl {
        private TemplateControl _tplControl;
        private int _offset;    // Offset of the start of this string in the resource
        private int _size;      // Size of this string in bytes 
        private bool _fAsciiOnly;    // Does the string contain only 7-bit ascii characters
 
        internal ResourceBasedLiteralControl(TemplateControl tplControl, int offset, int size, bool fAsciiOnly) { 

            // Make sure we don't access invalid data 
            if (offset < 0 || offset+size > tplControl.MaxResourceOffset)
                throw new ArgumentException();

            _tplControl = tplControl; 
            _offset = offset;
            _size = size; 
            _fAsciiOnly = fAsciiOnly; 

            PreventAutoID(); 
            EnableViewState = false;
        }

        public override string Text { 
            get {
                // If it's just a normal string, call the base 
                if (_size == 0) 
                    return base.Text;
 
                return StringResourceManager.ResourceToString(
                    _tplControl.StringResourcePointer, _offset, _size);
            }
            set { 
                // From now on, this will behave like a normal LiteralControl
                _size = 0; 
                base.Text = value; 
            }
        } 

        protected internal override void Render(HtmlTextWriter output) {

            // If it's just a normal string, call the base 
            if (_size == 0) {
                base.Render(output); 
                return; 
            }
 
            output.WriteUTF8ResourceString(_tplControl.StringResourcePointer, _offset, _size, _fAsciiOnly);
        }
    }
}

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