ITemplate Interface

public interface ITemplate

public interface ITemplate

public interface ITemplate

using System;
using System.Web;
using System.Web.UI;

namespace TemplateControlSamples {

    public class TemplateItem : Control, INamingContainer {
        private String     _message         = null;

        public TemplateItem(String message) {
            _message = message;
        }

        public String Message {

           get {
              return _message;
           }
           set {
              _message = value;
           }
        }
    }

    [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name="FullTrust")]
    [ParseChildren(true)]
    public class Template1 : Control, INamingContainer {

        private ITemplate  _messageTemplate = null;
        private String     _message         = null;

        public String Message {

           get {
              return _message;
           }
           set {
              _message = value;
           }
        }

        [
            PersistenceMode(PersistenceMode.InnerProperty),
            TemplateContainer(typeof(TemplateItem))
        ]
        public ITemplate MessageTemplate {
           get {
              return _messageTemplate;
           }
           set {
              _messageTemplate = value;
           }
        }

        protected override void CreateChildControls() {

           // If a template has been specified, use it to create children.
           // Otherwise, create a single LiteralControl with the message value.

           if (MessageTemplate != null) {
              Controls.Clear();
              TemplateItem i = new TemplateItem(this.Message);
              MessageTemplate.InstantiateIn(i);
              Controls.Add(i);
           }
           else {
              this.Controls.Add(new LiteralControl(this.Message));
           }
        }
    }
}
   

package TemplateControlSamples;

import System.*;
import System.Web.*;
import System.Web.UI.*;   
   
public class TemplateItem extends Control implements INamingContainer
{
    private String _message = null;

    public TemplateItem(String message)
    {
        _message = message;
    } //TemplateItem
      
    /** @property 
     */
    public String get_Message()
    {
        return _message ;
    } //get_Message
    
    /** @property 
     */
    public void set_Message ( String value )
    {
        _message = value;
    } //set_Message
} //TemplateItem   
   
/** @attribute ParseChildren(true)
 */
public class Template1 extends Control implements INamingContainer
{
    private ITemplate _messageTemplate = null;
    private String _message = null;
      
    /** @property 
     */
    public String get_Message()
    {
        return _message ;
    } //get_Message

    /** @property 
     */
    public void set_Message ( String value )
    {
        _message = value;
    } //set_Message
      
    /** @attribute PersistenceMode(PersistenceMode.InnerProperty)
        @attribute TemplateContainer(TemplateItem.class)
     */      
      
    /** @property 
     */
    public ITemplate get_MessageTemplate()
    {
        return _messageTemplate ;
    }

    /** @property 
     */
    public void set_MessageTemplate ( ITemplate value )
    {
        _messageTemplate = value;
    }
      
    protected void CreateChildControls()
    {
        // If a template has been specified, use it to create children.
        // Otherwise, create a single LiteralControl with the message value.
        if ( get_MessageTemplate() != null  ) {
            get_Controls().Clear();
            TemplateItem i = new TemplateItem(this.get_Message());
            get_MessageTemplate().InstantiateIn(i);
            get_Controls().Add(i);
        }
        else {
            this.get_Controls().Add(new LiteralControl(this.get_Message()));
        }
    } //CreateChildControls
} //Template1

import System
import System.Web
import System.Web.UI

package TemplateControlSamplesJS{

    class TemplateItem extends Control implements INamingContainer{

        private var message : String = null

        function TemplateItem(message : String){
            this.message = message
        }

        function get Message() : String{
           return message
        }
        
        function set Message(value : String){
           message = value
        }
    }

    public ParseChildren(true)
    class Template1JS extends Control implements INamingContainer{

        private var messageTemplate : ITemplate = null
        private var message : String = null

        function get Message(): String{
           return message
        }
        
        function set Message(value : String){
           message = value
        }

        public TemplateContainer(TemplateItem)
        function get MessageTemplate() : ITemplate{
           return messageTemplate
        }
        
        function set MessageTemplate(value : ITemplate){
           messageTemplate = value
        }

        protected function CreateChildControls(){

           // if(a template has been specified, use it to create children.
           // Otherwise, create a single literalcontrol with message value

           if(MessageTemplate != null){
              Controls.Clear()
              var I : TemplateItem = new TemplateItem(this.Message)
              MessageTemplate.InstantiateIn(I)
              Controls.Add(I)
           }else
              this.Controls.Add(new LiteralControl(this.Message))
        }

    }

}