Ext.data.NodeInterface

Alternate names

Ext.data.Node

Hierarchy

Ext.Base
Ext.data.NodeInterface

Requires

Files

This class is meant to be used as a set of methods that are applied to the prototype of a Record to decorate it with a Node API. This means that models used in conjunction with a tree will have all of the tree related methods available on the model. In general this class will not be used directly by the developer. This class also creates extra fields on the model if they do not exist, to help maintain the tree state and UI. These fields are:

  • parentId
  • index
  • depth
  • expanded
  • expandable
  • checked
  • leaf
  • cls
  • iconCls
  • root
  • isLast
  • isFirst
  • allowDrop
  • allowDrag
  • loaded
  • loading
  • href
  • hrefTarget
  • qtip
  • qtitle

Properties

Defined By

Instance properties

Ext.data.NodeInterface
view source
: Object
An array of this nodes children. ...

An array of this nodes children. Array will be empty if this node has no children.

Ext.data.NodeInterface
view source
: Object
A reference to this node's first child node. ...

A reference to this node's first child node. null if this node has no children.

Ext.data.NodeInterface
view source
: Object
A reference to this node's last child node. ...

A reference to this node's last child node. null if this node has no children.

Ext.data.NodeInterface
view source
: Object
A reference to this node's next sibling node. ...

A reference to this node's next sibling node. null if this node does not have a next sibling.

Ext.data.NodeInterface
view source
: Object
A reference to this node's parent node. ...

A reference to this node's parent node. null if this node is the root node.

Ext.data.NodeInterface
view source
: Object
A reference to this node's previous sibling node. ...

A reference to this node's previous sibling node. null if this node does not have a previous sibling.

Get the reference to the current class from which this object was instantiated. ...

Get the reference to the current class from which this object was instantiated. Unlike statics, this.self is scope-dependent and it's meant to be used for dynamic inheritance. See statics for a detailed comparison

Ext.define('My.Cat', {
    statics: {
        speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
    },

    constructor: function() {
        alert(this.self.speciesName); // dependent on 'this'
    },

    clone: function() {
        return new this.self();
    }
});


Ext.define('My.SnowLeopard', {
    extend: 'My.Cat',
    statics: {
        speciesName: 'Snow Leopard'         // My.SnowLeopard.speciesName = 'Snow Leopard'
    }
});

var cat = new My.Cat();                     // alerts 'Cat'
var snowLeopard = new My.SnowLeopard();     // alerts 'Snow Leopard'

var clone = snowLeopard.clone();
alert(Ext.getClassName(clone));             // alerts 'My.SnowLeopard'
Defined By

Static properties

...

Defaults to: []

Methods

Defined By

Instance methods

Ext.data.NodeInterface
view source
( node ) : Ext.data.NodeInterface
Insert node(s) as the last child node of this node. ...

Insert node(s) as the last child node of this node.

If the node was previously a child node of another parent node, it will be removed from that node first.

Parameters

Returns

Fires

Ext.data.NodeInterface
view source
( fn, [scope], [args] )
Bubbles up the tree from this node, calling the specified function with each node. ...

Bubbles up the tree from this node, calling the specified function with each node. The arguments to the function will be the args provided or the current node. If the function returns false at any point, the bubble is stopped.

Parameters

  • fn : Function

    The function to call.

  • scope : Object (optional)

    The scope (this reference) in which the function is executed. Defaults to the current Node.

  • args : Array (optional)

    The args to call the function with (default to passing the current Node).

Call the original method that was previously overridden with override, This method is deprecated as callParent does ...

Call the original method that was previously overridden with override,

This method is deprecated as callParent does the same thing.

Ext.define('My.Cat', {
    constructor: function() {
        alert("I'm a cat!");
    }
});

My.Cat.override({
    constructor: function() {
        alert("I'm going to be a cat!");

        var instance = this.callOverridden();

        alert("Meeeeoooowwww");

        return instance;
    }
});

var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
                          // alerts "I'm a cat!"
                          // alerts "Meeeeoooowwww"

Parameters

  • args : Array/Arguments

    The arguments, either an array or the arguments object from the current method, for example: this.callOverridden(arguments)

Returns

  • Object

    Returns the result of calling the overridden method

Call the "parent" method of the current method. ...

Call the "parent" method of the current method. That is the method previously overridden by derivation or by an override (see Ext.define).

 Ext.define('My.Base', {
     constructor: function (x) {
         this.x = x;
     },

     statics: {
         method: function (x) {
             return x;
         }
     }
 });

 Ext.define('My.Derived', {
     extend: 'My.Base',

     constructor: function () {
         this.callParent([21]);
     }
 });

 var obj = new My.Derived();

 alert(obj.x);  // alerts 21

This can be used with an override as follows:

 Ext.define('My.DerivedOverride', {
     override: 'My.Derived',

     constructor: function (x) {
         this.callParent([x*2]); // calls original My.Derived constructor
     }
 });

 var obj = new My.Derived();

 alert(obj.x);  // now alerts 42

This also works with static methods.

 Ext.define('My.Derived2', {
     extend: 'My.Base',

     statics: {
         method: function (x) {
             return this.callParent([x*2]); // calls My.Base.method
         }
     }
 });

 alert(My.Base.method(10));     // alerts 10
 alert(My.Derived2.method(10)); // alerts 20

Lastly, it also works with overridden static methods.

 Ext.define('My.Derived2Override', {
     override: 'My.Derived2',

     statics: {
         method: function (x) {
             return this.callParent([x*2]); // calls My.Derived2.method
         }
     }
 });

 alert(My.Derived2.method(10)); // now alerts 40

To override a method and replace it and also call the superclass method, use callSuper. This is often done to patch a method to fix a bug.

Parameters

  • args : Array/Arguments

    The arguments, either an array or the arguments object from the current method, for example: this.callParent(arguments)

Returns

  • Object

    Returns the result of calling the parent method

This method is used by an override to call the superclass method but bypass any overridden method. ...

This method is used by an override to call the superclass method but bypass any overridden method. This is often done to "patch" a method that contains a bug but for whatever reason cannot be fixed directly.

Consider:

 Ext.define('Ext.some.Class', {
     method: function () {
         console.log('Good');
     }
 });

 Ext.define('Ext.some.DerivedClass', {
     method: function () {
         console.log('Bad');

         // ... logic but with a bug ...

         this.callParent();
     }
 });

To patch the bug in DerivedClass.method, the typical solution is to create an override:

 Ext.define('App.paches.DerivedClass', {
     override: 'Ext.some.DerivedClass',

     method: function () {
         console.log('Fixed');

         // ... logic but with bug fixed ...

         this.callSuper();
     }
 });

The patch method cannot use callParent to call the superclass method since that would call the overridden method containing the bug. In other words, the above patch would only produce "Fixed" then "Good" in the console log, whereas, using callParent would produce "Fixed" then "Bad" then "Good".

Parameters

  • args : Array/Arguments

    The arguments, either an array or the arguments object from the current method, for example: this.callSuper(arguments)

Returns

  • Object

    Returns the result of calling the superclass method

Ext.data.NodeInterface
view source
( fn, [scope], [args] )
Cascades down the tree from this node, calling the specified function with each node. ...

Cascades down the tree from this node, calling the specified function with each node. The arguments to the function will be the args provided or the current node. If the function returns false at any point, the cascade is stopped on that branch.

Parameters

  • fn : Function

    The function to call

  • scope : Object (optional)

    The scope (this reference) in which the function is executed. Defaults to the current Node.

  • args : Array (optional)

    The args to call the function with (default to passing the current Node).

Ext.data.NodeInterface
view source
( destroy )private
Clear the node. ...

Clear the node.

Parameters

  • destroy : Boolean

    true to destroy the node.

Ext.data.NodeInterface
view source
( [recursive], [callback], [scope] )
Collapse this node. ...

Collapse this node.

Parameters

  • recursive : Function (optional)

    true to recursively collapse all the children.

  • callback : Function (optional)

    The function to execute once the collapse completes.

  • scope : Object (optional)

    The scope to run the callback in.

Fires

    Ext.data.NodeInterface
    view source
    ( node ) : Boolean
    Returns true if this node is an ancestor (at any point) of the passed node. ...

    Returns true if this node is an ancestor (at any point) of the passed node.

    Parameters

    Returns

    Ext.data.NodeInterface
    view source
    ( [newId], [deep] ) : Ext.data.NodeInterface
    Creates a copy (clone) of this Node. ...

    Creates a copy (clone) of this Node.

    Parameters

    • newId : String (optional)

      A new id, defaults to this Node's id.

    • deep : Boolean (optional)

      If passed as true, all child Nodes are recursively copied into the new Node. If omitted or false, the copy will have no child Nodes.

    Returns

    Fires

      Ext.data.NodeInterface
      view source
      ( node ) : Booleanprivate
      Ensures that the passed object is an instance of a Record with the NodeInterface applied ...

      Ensures that the passed object is an instance of a Record with the NodeInterface applied

      Parameters

      Returns

      Ext.data.NodeInterface
      view source
      ( silent )
      Destroys the node. ...

      Destroys the node.

      Parameters

      Fires

        Overrides: Ext.Base.destroy

        Ext.data.NodeInterface
        view source
        ( fn, [scope], [args] )
        Iterates the child nodes of this node, calling the specified function with each node. ...

        Iterates the child nodes of this node, calling the specified function with each node. The arguments to the function will be the args provided or the current node. If the function returns false at any point, the iteration stops.

        Parameters

        • fn : Function

          The function to call.

        • scope : Object (optional)

          The scope (this reference) in which the function is executed. Defaults to the current Node in the iteration.

        • args : Array (optional)

          The args to call the function with (default to passing the current Node).

        Ext.data.NodeInterface
        view source
        ( [recursive], [callback], [scope] )
        Expand this node. ...

        Expand this node.

        Parameters

        • recursive : Function (optional)

          true to recursively expand all the children.

        • callback : Function (optional)

          The function to execute once the expand completes.

        • scope : Object (optional)

          The scope to run the callback in.

        Fires

          Ext.data.NodeInterface
          view source
          ( attribute, value, [deep] ) : Ext.data.NodeInterface
          Finds the first child that has the attribute with the specified value. ...

          Finds the first child that has the attribute with the specified value.

          Parameters

          • attribute : String

            The attribute name.

          • value : Object

            The value to search for.

          • deep : Boolean (optional)

            true to search through nodes deeper than the immediate children.

          Returns

          Fires

            Ext.data.NodeInterface
            view source
            ( fn, [scope], [deep] ) : Ext.data.NodeInterface
            Finds the first child by a custom function. ...

            Finds the first child by a custom function. The child matches if the function passed returns true.

            Parameters

            • fn : Function

              A function which must return true if the passed Node is the required Node.

            • scope : Object (optional)

              The scope (this reference) in which the function is executed. Defaults to the Node being tested.

            • deep : Boolean (optional)

              True to search through nodes deeper than the immediate children.

            Returns

            Ext.data.NodeInterface
            view source
            ( ) : Objectprivate
            Returns the bubble target for this node. ...

            Returns the bubble target for this node.

            Returns

            Ext.data.NodeInterface
            view source
            ( index ) : Ext.data.NodeInterface
            Returns the child node at the specified index. ...

            Returns the child node at the specified index.

            Parameters

            Returns

            ...

            Parameters

            Ext.data.NodeInterface
            view source
            ( ) : Number
            Returns depth of this node (the root node has a depth of 0). ...

            Returns depth of this node (the root node has a depth of 0).

            Returns

            Fires

              Returns the initial configuration passed to constructor. ...

              Returns the initial configuration passed to constructor.

              Parameters

              • name : String (optional)

                When supplied, value for particular configuration option is returned, otherwise the full config object is returned.

              Returns

              Ext.data.NodeInterface
              view source
              ( [field], [separator] ) : String
              Gets the hierarchical path from the root of the current node. ...

              Gets the hierarchical path from the root of the current node.

              Parameters

              • field : String (optional)

                The field to construct the path from. Defaults to the model idProperty.

              • separator : String (optional)

                A separator to use.

                Defaults to: /

              Returns

              Fires

                Ext.data.NodeInterface
                view source
                ( ) : Boolean
                Returns true if this node has one or more child nodes, else false. ...

                Returns true if this node has one or more child nodes, else false.

                Returns

                Fires

                  ...

                  Parameters

                  Ext.data.NodeInterface
                  view source
                  ( child ) : Number
                  Returns the index of a child node. ...

                  Returns the index of a child node.

                  Parameters

                  Returns

                  • Number

                    The index of the node or -1 if it was not found.

                  ( instanceConfig ) : Objectchainableprotected
                  Initialize configuration for this class. ...

                  Initialize configuration for this class. a typical example:

                  Ext.define('My.awesome.Class', {
                      // The default config
                      config: {
                          name: 'Awesome',
                          isAwesome: true
                      },
                  
                      constructor: function(config) {
                          this.initConfig(config);
                      }
                  });
                  
                  var awesome = new My.awesome.Class({
                      name: 'Super Awesome'
                  });
                  
                  alert(awesome.getName()); // 'Super Awesome'
                  

                  Parameters

                  Returns

                  • Object

                    mixins The mixin prototypes as key - value pairs

                  Fires

                    Ext.data.NodeInterface
                    view source
                    ( node, refNode ) : Ext.data.NodeInterface
                    Inserts the first node before the second node in this nodes childNodes collection. ...

                    Inserts the first node before the second node in this nodes childNodes collection.

                    Parameters

                    Returns

                    Fires

                    Ext.data.NodeInterface
                    view source
                    ( index, node ) : Ext.data.Model
                    Insert a node into this node. ...

                    Insert a node into this node.

                    Parameters

                    Returns

                    Fires

                    Ext.data.NodeInterface
                    view source
                    ( node ) : Boolean
                    Returns true if the passed node is an ancestor (at any point) of this node. ...

                    Returns true if the passed node is an ancestor (at any point) of this node.

                    Parameters

                    Returns

                    Ext.data.NodeInterface
                    view source
                    ( ) : Boolean
                    Returns true if this node has one or more child nodes, or if the expandable node attribute is explicitly specified as...

                    Returns true if this node has one or more child nodes, or if the expandable node attribute is explicitly specified as true, otherwise returns false.

                    Returns

                    Fires

                      Ext.data.NodeInterface
                      view source
                      ( ) : Boolean
                      Returns true if this node is expanded. ...

                      Returns true if this node is expanded.

                      Returns

                      Fires

                        Ext.data.NodeInterface
                        view source
                        ( ) : Boolean
                        Returns true if this node is the first child of its parent. ...

                        Returns true if this node is the first child of its parent.

                        Returns

                        Fires

                          Ext.data.NodeInterface
                          view source
                          ( ) : Boolean
                          Returns true if this node is the last child of its parent. ...

                          Returns true if this node is the last child of its parent.

                          Returns

                          Fires

                            Ext.data.NodeInterface
                            view source
                            ( ) : Boolean
                            Returns true if this node is a leaf ...

                            Returns true if this node is a leaf

                            Returns

                            Fires

                              Ext.data.NodeInterface
                              view source
                              ( ) : Boolean
                              Returns true if this node is loaded. ...

                              Returns true if this node is loaded.

                              Returns

                              Fires

                                Ext.data.NodeInterface
                                view source
                                ( ) : Boolean
                                Returns true if this node is loading. ...

                                Returns true if this node is loading.

                                Returns

                                Fires

                                  Ext.data.NodeInterface
                                  view source
                                  ( ) : Boolean
                                  Returns true if this node is the root node. ...

                                  Returns true if this node is the root node.

                                  Returns

                                  Ext.data.NodeInterface
                                  view source
                                  ( ) : Boolean
                                  Returns true if this node is visible. ...

                                  Returns true if this node is visible.

                                  Returns

                                  ( names, callback, scope )private
                                  ...

                                  Parameters

                                  Ext.data.NodeInterface
                                  view source
                                  ( [destroy] ) : Ext.data.NodeInterfacechainable
                                  Removes this node from its parent. ...

                                  Removes this node from its parent.

                                  Parameters

                                  • destroy : Boolean (optional)

                                    true to destroy the node upon removal.

                                    Defaults to: false

                                  Returns

                                  Ext.data.NodeInterface
                                  view source
                                  ( [destroy] ) : Ext.data.NodeInterfacechainable
                                  Removes all child nodes from this node. ...

                                  Removes all child nodes from this node.

                                  Parameters

                                  • destroy : Boolean (optional)

                                    true to destroy the node upon removal.

                                    Defaults to: false

                                  Returns

                                  Fires

                                  Ext.data.NodeInterface
                                  view source
                                  ( node, [destroy] ) : Ext.data.NodeInterface
                                  Removes a child node from this node. ...

                                  Removes a child node from this node.

                                  Parameters

                                  Returns

                                  Fires

                                  Ext.data.NodeInterface
                                  view source
                                  ( newChild, oldChild ) : Ext.data.NodeInterface
                                  Replaces one child node in this node with another. ...

                                  Replaces one child node in this node with another.

                                  Parameters

                                  Returns

                                  Fires

                                  ( config, applyIfNotSet ) : Ext.Basechainableprivate
                                  ...

                                  Parameters

                                  Returns

                                  Ext.data.NodeInterface
                                  view source
                                  ( node )private
                                  Sets the first child of this node ...

                                  Sets the first child of this node

                                  Parameters

                                  Ext.data.NodeInterface
                                  view source
                                  ( node )private
                                  Sets the last child of this node ...

                                  Sets the last child of this node

                                  Parameters

                                  Ext.data.NodeInterface
                                  view source
                                  ( sortFn, recursive, suppressEvent )
                                  Sorts this nodes children using the supplied sort function. ...

                                  Sorts this nodes children using the supplied sort function.

                                  Parameters

                                  • sortFn : Function

                                    A function which, when passed two Nodes, returns -1, 0 or 1 depending upon required sort order.

                                  • recursive : Boolean

                                    Whether or not to apply this sort recursively.

                                  • suppressEvent : Boolean

                                    Set to true to not fire a sort event.

                                  Fires

                                  Get the reference to the class from which this object was instantiated. ...

                                  Get the reference to the class from which this object was instantiated. Note that unlike self, this.statics() is scope-independent and it always returns the class from which it was called, regardless of what this points to during run-time

                                  Ext.define('My.Cat', {
                                      statics: {
                                          totalCreated: 0,
                                          speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
                                      },
                                  
                                      constructor: function() {
                                          var statics = this.statics();
                                  
                                          alert(statics.speciesName);     // always equals to 'Cat' no matter what 'this' refers to
                                                                          // equivalent to: My.Cat.speciesName
                                  
                                          alert(this.self.speciesName);   // dependent on 'this'
                                  
                                          statics.totalCreated++;
                                      },
                                  
                                      clone: function() {
                                          var cloned = new this.self();                    // dependent on 'this'
                                  
                                          cloned.groupName = this.statics().speciesName;   // equivalent to: My.Cat.speciesName
                                  
                                          return cloned;
                                      }
                                  });
                                  
                                  
                                  Ext.define('My.SnowLeopard', {
                                      extend: 'My.Cat',
                                  
                                      statics: {
                                          speciesName: 'Snow Leopard'     // My.SnowLeopard.speciesName = 'Snow Leopard'
                                      },
                                  
                                      constructor: function() {
                                          this.callParent();
                                      }
                                  });
                                  
                                  var cat = new My.Cat();                 // alerts 'Cat', then alerts 'Cat'
                                  
                                  var snowLeopard = new My.SnowLeopard(); // alerts 'Cat', then alerts 'Snow Leopard'
                                  
                                  var clone = snowLeopard.clone();
                                  alert(Ext.getClassName(clone));         // alerts 'My.SnowLeopard'
                                  alert(clone.groupName);                 // alerts 'Cat'
                                  
                                  alert(My.Cat.totalCreated);             // alerts 3
                                  

                                  Returns

                                  Ext.data.NodeInterface
                                  view source
                                  ( silent ) : Boolean
                                  Updates general data of this node like isFirst, isLast, depth. ...

                                  Updates general data of this node like isFirst, isLast, depth. This method is internally called after a node is moved. This shouldn't have to be called by the developer unless they are creating custom Tree plugins.

                                  Parameters

                                  Returns

                                  Fires

                                    Defined By

                                    Static methods

                                    ( config, fullMerge )privatestatic
                                    ...

                                    Parameters

                                    ( members )chainableprivatestatic
                                    ...

                                    Parameters

                                    ( name, member )chainableprivatestatic
                                    ...

                                    Parameters

                                    ( members )chainablestatic
                                    Add methods / properties to the prototype of this class. ...

                                    Add methods / properties to the prototype of this class.

                                    Ext.define('My.awesome.Cat', {
                                        constructor: function() {
                                            // ...
                                        }
                                    });
                                    
                                     My.awesome.Cat.addMembers({
                                         meow: function() {
                                            alert('Meowww...');
                                         }
                                     });
                                    
                                     var kitty = new My.awesome.Cat();
                                     kitty.meow();
                                    

                                    Parameters

                                    ( members ) : Ext.Basechainablestatic
                                    Add / override static properties of this class. ...

                                    Add / override static properties of this class.

                                    Ext.define('My.cool.Class', {
                                        // this.se
                                    });
                                    
                                    My.cool.Class.addStatics({
                                        someProperty: 'someValue',      // My.cool.Class.someProperty = 'someValue'
                                        method1: function() {  },    // My.cool.Class.method1 = function() { ... };
                                        method2: function() {  }     // My.cool.Class.method2 = function() { ... };
                                    });
                                    

                                    Parameters

                                    Returns

                                    ( xtype )chainableprivatestatic
                                    ...

                                    Parameters

                                    Ext.data.NodeInterface
                                    view source
                                    ( modelClass, addFields )privatestatic
                                    ...

                                    Parameters

                                    ( fromClass, members ) : Ext.Basechainableprivatestatic
                                    Borrow another class' members to the prototype of this class. ...

                                    Borrow another class' members to the prototype of this class.

                                    Ext.define('Bank', {
                                        money: '$$$',
                                        printMoney: function() {
                                            alert('$$$$$$$');
                                        }
                                    });
                                    
                                    Ext.define('Thief', {
                                        // ...
                                    });
                                    
                                    Thief.borrow(Bank, ['money', 'printMoney']);
                                    
                                    var steve = new Thief();
                                    
                                    alert(steve.money); // alerts '$$$'
                                    steve.printMoney(); // alerts '$$$$$$$'
                                    

                                    Parameters

                                    • fromClass : Ext.Base

                                      The class to borrow members from

                                    • members : Array/String

                                      The names of the members to borrow

                                    Returns

                                    ( args )protectedstatic
                                    ...

                                    Parameters

                                    Create a new instance of this Class. ...

                                    Create a new instance of this Class.

                                    Ext.define('My.cool.Class', {
                                        // ...
                                    });
                                    
                                    My.cool.Class.create({
                                        someConfig: true
                                    });
                                    

                                    All parameters are passed to the constructor of the class.

                                    Returns

                                    ( alias, origin )static
                                    Create aliases for existing prototype methods. ...

                                    Create aliases for existing prototype methods. Example:

                                    Ext.define('My.cool.Class', {
                                        method1: function() {  },
                                        method2: function() {  }
                                    });
                                    
                                    var test = new My.cool.Class();
                                    
                                    My.cool.Class.createAlias({
                                        method3: 'method1',
                                        method4: 'method2'
                                    });
                                    
                                    test.method3(); // test.method1()
                                    
                                    My.cool.Class.createAlias('method5', 'method3');
                                    
                                    test.method5(); // test.method3() -> test.method1()
                                    

                                    Parameters

                                    Ext.data.NodeInterface
                                    view source
                                    ( record )static
                                    This method allows you to decorate a Record's prototype to implement the NodeInterface. ...

                                    This method allows you to decorate a Record's prototype to implement the NodeInterface. This adds a set of methods, new events, new properties and new fields on every Record with the same Model as the passed Record.

                                    Parameters

                                    • record : Ext.data.Model

                                      The Record you want to decorate the prototype of.

                                    ( parent )privatestatic
                                    ...

                                    Parameters

                                    Get the current class' name in string format. ...

                                    Get the current class' name in string format.

                                    Ext.define('My.cool.Class', {
                                        constructor: function() {
                                            alert(this.self.getName()); // alerts 'My.cool.Class'
                                        }
                                    });
                                    
                                    My.cool.Class.getName(); // 'My.cool.Class'
                                    

                                    Returns

                                    ...
                                    ( name, mixinClass )privatestatic
                                    Used internally by the mixins pre-processor ...

                                    Used internally by the mixins pre-processor

                                    Parameters

                                    ( fn, scope )chainableprivatestatic
                                    ...

                                    Parameters

                                    ( members ) : Ext.Basechainabledeprecatedstatic
                                    Override members of this class. ...

                                    Override members of this class. Overridden methods can be invoked via callParent.

                                    Ext.define('My.Cat', {
                                        constructor: function() {
                                            alert("I'm a cat!");
                                        }
                                    });
                                    
                                    My.Cat.override({
                                        constructor: function() {
                                            alert("I'm going to be a cat!");
                                    
                                            var instance = this.callParent(arguments);
                                    
                                            alert("Meeeeoooowwww");
                                    
                                            return instance;
                                        }
                                    });
                                    
                                    var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
                                                              // alerts "I'm a cat!"
                                                              // alerts "Meeeeoooowwww"
                                    

                                    As of 2.1, direct use of this method is deprecated. Use Ext.define instead:

                                    Ext.define('My.CatOverride', {
                                        override: 'My.Cat',
                                    
                                        constructor: function() {
                                            alert("I'm going to be a cat!");
                                    
                                            var instance = this.callParent(arguments);
                                    
                                            alert("Meeeeoooowwww");
                                    
                                            return instance;
                                        }
                                    });
                                    

                                    The above accomplishes the same result but can be managed by the Ext.Loader which can properly order the override and its target class and the build process can determine whether the override is needed based on the required state of the target class (My.Cat).

                                    This method has been deprecated since 2.1.0

                                    Please use Ext.define instead

                                    Parameters

                                    • members : Object

                                      The properties to add to this class. This should be specified as an object literal containing one or more properties.

                                    Returns

                                    Defined By

                                    Events

                                    Ext.data.NodeInterface
                                    view source
                                    ( this, node, index, eOpts )
                                    Fires when a new child node is appended. ...

                                    Fires when a new child node is appended.

                                    Parameters

                                    Ext.data.NodeInterface
                                    view source
                                    ( this, node, eOpts )
                                    Fires before a new child is appended, return false to cancel the append. ...

                                    Fires before a new child is appended, return false to cancel the append.

                                    Parameters

                                    Ext.data.NodeInterface
                                    view source
                                    ( this, eOpts )
                                    Fires before this node is collapsed. ...

                                    Fires before this node is collapsed.

                                    Parameters

                                    Ext.data.NodeInterface
                                    view source
                                    ( this, eOpts )
                                    Fires before this node is expanded. ...

                                    Fires before this node is expanded.

                                    Parameters

                                    Ext.data.NodeInterface
                                    view source
                                    ( this, node, refNode, eOpts )
                                    Fires before a new child is inserted, return false to cancel the insert. ...

                                    Fires before a new child is inserted, return false to cancel the insert.

                                    Parameters

                                    Ext.data.NodeInterface
                                    view source
                                    ( this, oldParent, newParent, index, eOpts )
                                    Fires before this node is moved to a new location in the tree. ...

                                    Fires before this node is moved to a new location in the tree. Return false to cancel the move.

                                    Parameters

                                    Ext.data.NodeInterface
                                    view source
                                    ( this, node, eOpts )
                                    Fires before a child is removed, return false to cancel the remove. ...

                                    Fires before a child is removed, return false to cancel the remove.

                                    Parameters

                                    Ext.data.NodeInterface
                                    view source
                                    ( this, eOpts )
                                    Fires when this node is collapsed. ...

                                    Fires when this node is collapsed.

                                    Parameters

                                    Ext.data.NodeInterface
                                    view source
                                    ( this, eOpts )
                                    Fires when this node is expanded. ...

                                    Fires when this node is expanded.

                                    Parameters

                                    Ext.data.NodeInterface
                                    view source
                                    ( this, node, refNode, eOpts )
                                    Fires when a new child node is inserted. ...

                                    Fires when a new child node is inserted.

                                    Parameters

                                    Ext.data.NodeInterface
                                    view source
                                    ( this, oldParent, newParent, index, eOpts )
                                    Fires when this node is moved to a new location in the tree. ...

                                    Fires when this node is moved to a new location in the tree.

                                    Parameters

                                    Ext.data.NodeInterface
                                    view source
                                    ( this, node, eOpts )
                                    Fires when a child node is removed. ...

                                    Fires when a child node is removed.

                                    Parameters

                                    Ext.data.NodeInterface
                                    view source
                                    ( this, childNodes, eOpts )
                                    Fires when this node's childNodes are sorted. ...

                                    Fires when this node's childNodes are sorted.

                                    Parameters