context: /********
   * This file is part of Ext.NET.
   *     
   * Ext.NET is free software: you can redistribute it and/or modify
   * it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE as 
   * published by the Free Software Foundation, either version 3 of the 
   * License, or (at your option) any later version.
   * 
   * Ext.NET is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU AFFERO GENERAL PUBLIC LICENSE for more details.
   * 
   * You should have received a copy of the GNU AFFERO GENERAL PUBLIC LICENSE
   * along with Ext.NET.  If not, see <http://www.gnu.org/licenses/>.
   *
   *
   * @version   : 2.0.0.beta - Community Edition (AGPLv3 License)
   * @author    : Ext.NET, Inc. http://www.ext.net/
   * @date      : 2012-03-07
   * @copyright : Copyright (c) 2007-2012, Ext.NET, Inc. (http://www.ext.net/). All rights reserved.
   * @license   : GNU AFFERO GENERAL PUBLIC LICENSE (AGPL) 3.0. 
   *              See license.txt and http://www.ext.net/license/.
   *              See AGPL License at http://www.gnu.org/licenses/agpl-3.0.txt
   ********/
  
  using System.ComponentModel;
  using System.Web.UI;
  
  namespace Ext.Net
  {
  	/// <summary>
  	/// 
  	/// </summary>
  	[Description("")]
      public partial class TreePanelDirectEvents : TablePanelDirectEvents
      {
          public TreePanelDirectEvents() { }
  
          public TreePanelDirectEvents(Observable parent) { this.Parent = parent; }
  
          private ComponentDirectEvent beforeItemAppend;
  
          /// <summary>
          /// Fires before a new child is appended, return false to cancel the append.
          /// 
          /// Parameters
          /// item : Node
          ///     This node
          /// node : Node
          ///     The child node to be appended
          /// options : Object
          ///     The options object passed to Ext.util.Observable.addListener.
          /// </summary>
          [ListenerArgument(0, "item")]
          [ListenerArgument(1, "node")]
          [ListenerArgument(2, "options")]
          [TypeConverter(typeof(ExpandableObjectConverter))]
          [ConfigOption("beforeitemappend", typeof(DirectEventJsonConverter))]
          [PersistenceMode(PersistenceMode.InnerProperty)]
          [NotifyParentProperty(true)]
          [Description("Fires before a new child is appended, return false to cancel the append.")]
          public virtual ComponentDirectEvent BeforeItemAppend
          {
              get
              {
                  if (this.beforeItemAppend == null)
                  {
                      this.beforeItemAppend = new ComponentDirectEvent(this);
                  }
  
                  return this.beforeItemAppend;
              }
          }
  
          private ComponentDirectEvent beforeItemCollapse;
  
          /// <summary>
          /// Fires before this node is collapsed.
          /// 
          /// Parameters
          /// item : Node
          ///     The collapsing node        
          /// options : Object
          ///     The options object passed to Ext.util.Observable.addListener.
          /// </summary>
          [ListenerArgument(0, "item")]
          [ListenerArgument(1, "options")]
          [TypeConverter(typeof(ExpandableObjectConverter))]
          [ConfigOption("beforeitemcollapse", typeof(DirectEventJsonConverter))]
          [PersistenceMode(PersistenceMode.InnerProperty)]
          [NotifyParentProperty(true)]
          [Description("Fires before this node is collapsed.")]
          public virtual ComponentDirectEvent BeforeItemCollapse
          {
              get
              {
                  if (this.beforeItemCollapse == null)
                  {
                      this.beforeItemCollapse = new ComponentDirectEvent(this);
                  }
  
                  return this.beforeItemCollapse;
              }
          }
  
          private ComponentDirectEvent beforeItemExpand;
  
          /// <summary>
          /// Fires before this node is collapsed.
          /// 
          /// Parameters
          /// item : Node
          ///     The collapsing node        
          /// options : Object
          ///     The options object passed to Ext.util.Observable.addListener.
          /// </summary>
          [ListenerArgument(0, "item")]
          [ListenerArgument(1, "options")]
          [TypeConverter(typeof(ExpandableObjectConverter))]
          [ConfigOption("beforeitemexpand", typeof(DirectEventJsonConverter))]
          [PersistenceMode(PersistenceMode.InnerProperty)]
          [NotifyParentProperty(true)]
          [Description("Fires before this node is collapsed.")]
          public virtual ComponentDirectEvent BeforeItemExpand
          {
              get
              {
                  if (this.beforeItemExpand == null)
                  {
                      this.beforeItemExpand = new ComponentDirectEvent(this);
                  }
  
                  return this.beforeItemExpand;
              }
          }
  
          private ComponentDirectEvent beforeItemInsert;
  
          /// <summary>
          /// Fires before a new child is inserted, return false to cancel the insert.
          /// 
          /// Parameters
          /// item : Node
          ///     This node
          /// node : Node
          ///     The child node to be inserted
          /// refNode : Node
          ///     The child node the node is being inserted before
          /// options : Object
          ///     The options object passed to Ext.util.Observable.addListener.
          /// </summary>
          [ListenerArgument(0, "item")]
          [ListenerArgument(1, "node")]
          [ListenerArgument(2, "refNode")]
          [ListenerArgument(3, "options")]
          [TypeConverter(typeof(ExpandableObjectConverter))]
          [ConfigOption("beforeiteminsert", typeof(DirectEventJsonConverter))]
          [PersistenceMode(PersistenceMode.InnerProperty)]
          [NotifyParentProperty(true)]
          [Description("Fires before a new child is inserted, return false to cancel the insert.")]
          public virtual ComponentDirectEvent BeforeItemInsert
          {
              get
              {
                  if (this.beforeItemInsert == null)
                  {
                      this.beforeItemInsert = new ComponentDirectEvent(this);
                  }
  
                  return this.beforeItemInsert;
              }
          }
  
          private ComponentDirectEvent beforeItemMove;
  
          /// <summary>
          /// Fires before this node is moved to a new location in the tree. Return false to cancel the move.
          /// 
          /// Parameters
          /// item : Node
          ///     The collapsing node  
          /// oldParent : Node
          ///     The parent of this node
          /// newParent : Node
          ///     The new parent this node is moving to
          /// index : Number
          ///     The index it is being moved to
          /// options : Object
          ///     The options object passed to Ext.util.Observable.addListener.
          /// </summary>
          [ListenerArgument(0, "item")]
          [ListenerArgument(1, "oldParent")]
          [ListenerArgument(2, "newParent")]
          [ListenerArgument(3, "index")]
          [ListenerArgument(4, "options")]
          [TypeConverter(typeof(ExpandableObjectConverter))]
          [ConfigOption("beforeitemmove", typeof(DirectEventJsonConverter))]
          [PersistenceMode(PersistenceMode.InnerProperty)]
          [NotifyParentProperty(true)]
          [Description("Fires before this node is moved to a new location in the tree. Return false to cancel the move.")]
          public virtual ComponentDirectEvent BeforeItemMove
          {
              get
              {
                  if (this.beforeItemMove == null)
                  {
                      this.beforeItemMove = new ComponentDirectEvent(this);
                  }
  
                  return this.beforeItemMove;
              }
          }
  
          private ComponentDirectEvent beforeItemRemove;
  
          /// <summary>
          /// Fires before a child is removed, return false to cancel the remove.
          /// 
          /// Parameters
          /// item : Node
          ///     The collapsing node  
          /// node : Node
          ///     The child node to be removed
          /// options : Object
          ///     The options object passed to Ext.util.Observable.addListener.
          /// </summary>
          [ListenerArgument(0, "item")]
          [ListenerArgument(1, "node")]
          [ListenerArgument(2, "options")]
          [TypeConverter(typeof(ExpandableObjectConverter))]
          [ConfigOption("beforeitemremove", typeof(DirectEventJsonConverter))]
          [PersistenceMode(PersistenceMode.InnerProperty)]
          [NotifyParentProperty(true)]
          [Description("Fires before a child is removed, return false to cancel the remove.")]
          public virtual ComponentDirectEvent BeforeItemRemove
          {
              get
              {
                  if (this.beforeItemRemove == null)
                  {
                      this.beforeItemRemove = new ComponentDirectEvent(this);
                  }
  
                  return this.beforeItemRemove;
              }
          }
  
          private ComponentDirectEvent beforeLoad;
  
          /// <summary>
          /// Fires before a request is made for a new data object. If the beforeload handler returns false the load action will be canceled.
          /// 
          /// Parameters
          /// item : Ext.data.Store
          ///     This Store
          /// operation : Ext.data.Operation
          ///     The Ext.data.Operation object that will be passed to the Proxy to load the Store
          /// options : Object
          ///     The options object passed to Ext.util.Observable.addListener.
          /// </summary>
          [ListenerArgument(0, "item")]
          [ListenerArgument(1, "operation")]
          [ListenerArgument(2, "options")]
          [TypeConverter(typeof(ExpandableObjectConverter))]
          [ConfigOption("beforeload", typeof(DirectEventJsonConverter))]
          [PersistenceMode(PersistenceMode.InnerProperty)]
          [NotifyParentProperty(true)]
          [Description("Fires before a request is made for a new data object. If the beforeload handler returns false the load action will be canceled.")]
          public virtual ComponentDirectEvent BeforeLoad
          {
              get
              {
                  if (this.beforeLoad == null)
                  {
                      this.beforeLoad = new ComponentDirectEvent(this);
                  }
  
                  return this.beforeLoad;
              }
          }
  
          private ComponentDirectEvent checkChange;
  
          /// <summary>
          /// Fires when a node with a checkbox's checked property changes
          /// 
          /// Parameters
          /// item : Ext.data.Model
          ///     The node who's checked property was changed
          /// checked : Boolean
          ///     The node's new checked state
          /// options : Object
          ///     The options object passed to Ext.util.Observable.addListener.
          /// </summary>
          [ListenerArgument(0, "item")]
          [ListenerArgument(1, "checked")]
          [ListenerArgument(2, "options")]
          [TypeConverter(typeof(ExpandableObjectConverter))]
          [ConfigOption("checkchange", typeof(DirectEventJsonConverter))]
          [PersistenceMode(PersistenceMode.InnerProperty)]
          [NotifyParentProperty(true)]
          [Description("Fires when a node with a checkbox's checked property changes")]
          public virtual ComponentDirectEvent CheckChange
          {
              get
              {
                  if (this.checkChange == null)
                  {
                      this.checkChange = new ComponentDirectEvent(this);
                  }
  
                  return this.checkChange;
              }
          }
  
          private ComponentDirectEvent itemAppend;
  
          /// <summary>
          /// Fires when a new child node is appended
          /// 
          /// Parameters
          /// item : Node
          ///     This node
          /// node : Node
          ///     The newly appended node
          /// index : Number
          ///     The index of the newly appended node
          /// options : Object
          ///     The options object passed to Ext.util.Observable.addListener.
          /// </summary>
          [ListenerArgument(0, "item")]
          [ListenerArgument(1, "node")]
          [ListenerArgument(2, "index")]
          [ListenerArgument(3, "options")]
          [TypeConverter(typeof(ExpandableObjectConverter))]
          [ConfigOption("itemappend", typeof(DirectEventJsonConverter))]
          [PersistenceMode(PersistenceMode.InnerProperty)]
          [NotifyParentProperty(true)]
          [Description("Fires when a new child node is appended")]
          public virtual ComponentDirectEvent ItemAppend
          {
              get
              {
                  if (this.itemAppend == null)
                  {
  
gt:                     this.itemAppend = new ComponentDirectEvent(this);