netzke-core 0.12.3 → 1.0.0.0.pre

data/javascripts/base.js

@@ -1,58 +1,78 @@
 /**
-This file gets loaded along with the rest of Ext library at the initial load. It is common for both Ext JS and Touch; Ext JS-specific stuff is in ext.js.
-
-At this time the following constants have been set by Rails:
-
-  Netzke.RelativeUrlRoot - set to ActionController::Base.config.relative_url_root
-  Netzke.RelativeExtUrl - URL to ext files
-  Netzke.ControllerUrl - NetzkeController URL
-*/
-
-// Initial stuff
-Netzke.classNamespace = 'Netzke.classes'; // TODO: pass from Ruby
-Ext.ns('Ext.netzke'); // namespace for extensions that depend on Ext
-Ext.ns('Netzke.page'); // namespace for all component instances on the page
-Ext.ns(Netzke.classNamespace); // namespace for all component classes
-Ext.ns('Netzke.classes.Core'); // namespace for Core mixins
-
-Netzke.deprecationWarning = function(msg){
-  if (typeof console == 'undefined') {
-    // no console defined
-  } else {
-    console.info("Netzke: " + msg);
-  }
-};
+ * Client-side code for [Netzke::Base](http://www.rubydoc.info/github/netzke/netzke-core/Netzke/Base)
+ * @class Netzke.Base
+ */
+Ext.define("Netzke.Base", {
+  extend: 'Ext.Mixin',
 
-Netzke.warning = Netzke.deprecationWarning;
+  mixinConfig: {
+    before: {
+      constructor: 'netzkeBeforeConstructor',
+      initComponent: 'netzkeBeforeInitComponent'
+    },
 
-Netzke.exception = function(msg) {
-  throw("Netzke: " + msg);
-};
+    after: {
+      constructor: 'netzkeAfterConstructor',
+      initComponent: 'netzkeAfterInitComponent'
+    }
+  },
 
-// Used in testing
-if( Netzke.nLoadingFixRequests == undefined ){
-  Netzke.nLoadingFixRequests=0;
-  Ext.Ajax.on('beforerequest',    function(conn,opt) { Netzke.nLoadingFixRequests+=1; });
-  Ext.Ajax.on('requestcomplete',  function(conn,opt) { Netzke.nLoadingFixRequests-=1; });
-  Ext.Ajax.on('requestexception', function(conn,opt) { Netzke.nLoadingFixRequests-=1; });
-  Netzke.ajaxIsLoading = function() { return Netzke.nLoadingFixRequests > 0; };
-}
+  /**
+   * This is `true` for all Netzke components.
+   * @property isNetzke
+   * @type boolean
+   */
+  isNetzke: true,
 
-// Used in testing, too
-Netzke.runningRequests = 0;
-Netzke.isLoading=function () {
-  return Netzke.runningRequests != 0;
-}
+  /**
+   * Override this property globally if you to use a custom notifier class.
+   * @property netzkeNotifier
+   * @type Netzke.Notifier
+   */
+  netzkeNotifier: Ext.create('Netzke.Notifier'),
 
-// xtypes of cached Netzke classes
-Netzke.cache = [];
+  /**
+   * Called before constructor. Implements all kinds of Netzke component initializations. Override as needed.
+   * @method netzkeBeforeConstructor
+   * @param config {Object} Passed configuration
+   */
+  netzkeBeforeConstructor: function(config){
+    this.server = {}; // namespace for endpoint functions
+    this.netzkeComponents = config.netzkeComponents;
+    this.passedConfig = config;
+    this.netzkeProcessEndpoints(config);
+    this.netzkeProcessPlugins(config);
+    this.netzkeNormalizeActions(config);
+    this.netzkeNormalizeConfig(config);
+    this.serverConfig = config.clientConfig || {};
+  },
 
-Ext.define("Netzke.classes.Core.Mixin", {
-  isNetzke: true, // to distinguish Netzke components from regular Ext components
+  /**
+   * Called after constructor. Override as needed.
+   * @method netzkeAfterConstructor
+   * @param config {Object} Passed configuration
+   */
+  netzkeAfterConstructor: function(config){
+  },
 
   /**
-  * Evaluates CSS
-  * @private
+   * Called before `initComponent`. Override as needed.
+   * @method netzkeBeforeInitComponent
+   */
+  netzkeBeforeInitComponent: function(){
+  },
+
+  /**
+   * Called after `initComponent`. Override as needed.
+   * @method netzkeAfterInitComponent
+   */
+  netzkeAfterInitComponent: function(){
+  },
+
+  /**
+  * Evaluates CSS passed from the server.
+  * @method netzkeEvalCss
+  * @param code {String} CSS code
   */
   netzkeEvalCss : function(code){
     var head = Ext.fly(document.getElementsByTagName('head')[0]);
@@ -64,42 +84,36 @@ Ext.define("Netzke.classes.Core.Mixin", {
   },
 
   /**
-  * Evaluates JS
-  * @private
+  * Evaluates Javascript passed from the server.
+  * @method netzkeEvalJs
+  * @param code {String} Javascript code
   */
   netzkeEvalJs : function(code){
     eval(code);
   },
 
-  /**
-  * Gets id in the context of provided parent.
-  * For example, the components "properties", being a child of "books" has global id "books__properties", which *is* its component's real id. This methods, with the instance of "books" passed as parameter, returns "properties".
-  * @private
-  */
-  netzkeLocalId : function(parent){
-    return this.id.replace(parent.id + "__", "");
-  },
-
-  /**
-  Executes a bunch of methods. This method is called almost every time a communication to the server takes place.
-  Thus the server side of a component can provide any set of commands to its client side.
-  Args:
-    - instructions: can be
-      1) a hash of instructions, where the key is the method name, and value - the argument that method will be called with (thus, these methods are expected to *only* receive 1 argument). In this case, the methods will be executed in no particular order.
-      2) an array of hashes of instructions. They will be executed in order.
-      Arrays and hashes may be nested at will.
-      If the key in the instructions hash refers to a child Netzke component, netzkeBulkExecute will be called on that component with the value passed as the argument.
+ /**
+  * Executes a bunch of methods. This method is called almost every time a communication to the server takes place.
+  * Thus the server side of a component can provide any set of commands to its client side.
+  *
+  * @method netzkeBulkExecute
+  *
+  * @param {Array|Object} instructions
+  *  1) a hash of instructions, where the key is the method name, and value - the argument that method will be called with (thus, these methods are expected to *only* receive 1 argument). In this case, the methods will be executed in no particular order.
+  *  2) an array of hashes of instructions. They will be executed in order.
+  *  Arrays and hashes may be nested at will.
+  *  If the key in the instructions hash refers to a child Netzke component, netzkeBulkExecute will be called on that component with the value passed as the argument.
 
-  Examples of the arguments:
-      // same as this.feedback("Your order is accepted");
-      {feedback: "You order is accepted"}
+  *  @example
+  *
+  *      // executes as this.feedback("Your order is accepted");
+  *      {feedback: "You order is accepted"}
 
-      // same as: this.setTitle('Suprise!'); this.setDisabled(true);
-      [{setTitle:'Suprise!'}, {setDisabled:true}]
+  *      // executes as: this.setTitle('Suprise!'); this.setDisabled(true);
+  *      [{setTitle:'Suprise!'}, {setDisabled:true}]
 
-      // the same as this.netzkeGetComponent('users').netzkeBulkExecute([{setTitle:'Suprise!'}, {setDisabled:true}]);
-      {users: [{setTitle:'Suprise!'}, {setDisabled:true}] }
-  @private
+  *      // executes as: this.netzkeGetComponent('users').netzkeBulkExecute([{setTitle:'Suprise!'}, {setDisabled:true}]);
+  *      {users: [{setTitle:'Suprise!'}, {setDisabled:true}] }
   */
   netzkeBulkExecute : function(instructions){
     if (Ext.isArray(instructions)) {
@@ -118,7 +132,7 @@ Ext.define("Netzke.classes.Core.Mixin", {
           if (childComponent) {
             childComponent.netzkeBulkExecute(args);
           } else if (Ext.isArray(args)) { // only consider those calls that have arguments wrapped in an array; the only (probably) case when they are not, is with 'success' property set to true in a non-ajax form submit - silently ignore that
-            throw "Netzke: Unknown method or child component '" + instr + "' in component '" + this.id + "'"
+            throw "Netzke: Unknown method or child component '" + instr + "' in component '" + this.path + "'"
           }
         }
       }
@@ -126,6 +140,9 @@ Ext.define("Netzke.classes.Core.Mixin", {
   },
 
   /**
+   * Called by the server side to set the return value of an endpoint call; to be reworked.
+   * @method netzkeSetResult
+   * @param result {Any}
    * @private
    */
   netzkeSetResult: function(result) {
@@ -133,31 +150,37 @@ Ext.define("Netzke.classes.Core.Mixin", {
   },
 
   /**
-  * This method gets called by the server when the component to which an endpoint call was directed to, is not in the session anymore.
+  * Called by the server when the component to which an endpoint call was directed to, is not in the session anymore.
+  * @method netzkeSessionExpired
   * @private
   */
-  netzkeSessionExpired: function() {
+  netzkeOnSessionExpired: function() {
     this.netzkeSessionIsExpired = true;
-    this.onNetzkeSessionExpired();
+    this.netzkeOnSessionExpired();
   },
 
   /**
    * Override this method to handle session expiration. E.g. you may want to inform the user that they will be redirected to the login page.
+   * @method onSessionExpired
    * @private
    */
-  onNetzkeSessionExpired: function() {
-    Netzke.warning("Component not in session. Override `onNetzkeSessionExpired` to handle this.");
+  netzkeOnSessionExpired: function() {
+    Netzke.warning("Component not in session. Override `netzkeOnSessionExpired` to handle this.");
   },
 
   /**
-   * Returns a URL for old-fashion requests (used at multi-part form non-AJAX submissions)
-   * @private
+   * Returns a URL for old-fashion requests (used at multi-part form non-AJAX submissions).
+   * @method netzkeEndpointUrl
+   * @param endpoint {String}
    */
   netzkeEndpointUrl: function(endpoint){
     return Netzke.ControllerUrl + "dispatcher?address=" + this.id + "__" + endpoint;
   },
 
   /**
+   * Processes items.
+   * @method netzkeNormalizeConfigArray
+   * @param items {Array} Items
    * @private
    */
   netzkeNormalizeConfigArray: function(items){
@@ -166,19 +189,9 @@ Ext.define("Netzke.classes.Core.Mixin", {
     Ext.each(items, function(item, i){
       cfg = item;
 
-      // potentially, referencing a component or action with a string
-      if (Ext.isString(item)) {
-        ref = item.camelize(true);
-        if ((this.netzkeComponents || {})[ref]) cfg = {netzkeComponent: ref};
-        else if ((this.actions || {})[ref]) cfg = {netzkeAction: ref};
-      }
-
-      if (cfg.netzkeAction) {
-        // replace with action instance
-        actName = cfg.netzkeAction.camelize(true);
-        if (!this.actions[actName]) throw "Netzke: unknown action " + cfg.netzkeAction;
-        items[i] = this.actions[actName];
-        delete(item);
+      if (cfg.action) {
+        if (!this.actions[cfg.action]) throw "Netzke: unknown action " + cfg.action;
+        items[i] = this.actions[cfg.action];
 
       } else if (cfg.netzkeComponent) {
         // replace with component config
@@ -187,7 +200,6 @@ Ext.define("Netzke.classes.Core.Mixin", {
         if (!cmpCfg) throw "Netzke: unknown component " + cmpName;
         cmpCfg.netzkeParent = this;
         items[i] = Ext.apply(cmpCfg, cfg);
-        delete(item);
 
       } else if (Ext.isString(cfg) && Ext.isFunction(this[cfg.camelize(true)+"Config"])) { // replace with config referred to on the Ruby side as a symbol
         // pre-built config
@@ -202,5 +214,479 @@ Ext.define("Netzke.classes.Core.Mixin", {
         }
       }
     }, this);
+  },
+
+  /**
+   * Runs through initial config options and does the following:
+   *
+   * * detects component placeholders and replaces them with full component config found in `netzkeComponents`
+   * * detects action placeholders and replaces them with instances of Ext actions found in `this.actions`
+   *
+   * @method netzkeNormalizeConfig
+   * @param config {Object}
+   */
+  netzkeNormalizeConfig: function(config) {
+    for (key in config) {
+      if (Ext.isArray(config[key])) this.netzkeNormalizeConfigArray(config[key]);
+    }
+  },
+
+  /**
+  * Dynamically creates methods for endpoints, so that we could later call them like: this.myEndpointMethod()
+  * @method netzkeProcessEndpoints
+  * @param config {Object}
+  */
+  netzkeProcessEndpoints: function(config){
+    var endpoints = config.endpoints || [], that = this;
+
+    Ext.each(endpoints, function(methodName){
+      Netzke.directProvider.addRemotingMethodToComponent(config, methodName);
+
+      // define endpoint function
+      this.server[methodName] = function(){
+        var args = Array.prototype.slice.call(arguments), callback, serverConfigs, scope = that;
+
+        if (Ext.isFunction(args[args.length - 2])) {
+          scope = args.pop();
+          callback = args.pop();
+        }
+
+        if (Ext.isFunction(args[args.length - 1])) {
+          callback = args.pop();
+        }
+
+        var cfgs = that.netzkeBuildParentConfigs();
+        var remotingArgs = {args: args, configs: cfgs};
+
+        // call Direct function
+        that.netzkeGetDirectFunction(methodName).call(scope, remotingArgs, function(response, event) {
+          that.netzkeProcessDirectResponse(response, event, callback, scope);
+        }, that);
+      }
+    }, this);
+  },
+
+  /**
+   * TODO
+   * @method netzkeProcessDirectResponse
+   * @param response {Object}
+   * @param event {Object}
+   * @param callback {Function}
+   * @param scope {Object}
+   */
+  netzkeProcessDirectResponse: function(response, event, callback, scope){
+    var callbackParams,
+        result; // endpoint response
+
+    // no server exception?
+    if (Ext.getClass(event) == Ext.direct.RemotingEvent) {
+
+      // process response and get endpoint return value
+      this.netzkeBulkExecute(response);
+      result = this.latestResult;
+
+      // endpoint returns an error?
+      if (result && result.error) {
+        this.netzkeHandleEndpointError(callback, result);
+      // no error
+      } else {
+        if (callback) callback.apply(scope, [result, true]) != false
+      }
+
+    // got Direct exception?
+    } else {
+      this.netzkeHandleDirectError(callback, event);
+    }
+  },
+
+  /**
+   * TODO
+   * @method netzkeHandleEndpointError
+   */
+  netzkeHandleEndpointError: function(callback, result){
+    var shouldFireGlobalEvent = true;
+
+    if (callback) {
+      shouldFireGlobalEvent = callback.apply(this, [result.error, false]) != false;
+    }
+
+    if (shouldFireGlobalEvent) {
+      Netzke.GlobalEvents.fireEvent('endpointexception', result.error);
+    }
+  },
+
+  /**
+   * TODO
+   * @method netzkeHandleDirectError
+   * @param callback {Function}
+   * @param event {Object}
+   */
+  netzkeHandleDirectError: function(callback, event){
+    var shouldFireGlobalEvent = true;
+
+    callbackParams = event;
+    callbackParams.type = 'DIRECT_EXCEPTION';
+
+    // First invoke the callback, and if that allows, call generic exception handler
+    if (callback) {
+      shouldFireGlobalEvent = callback.apply(this, [callbackParams, false]) != false;
+    }
+    if (shouldFireGlobalEvent) {
+      Netzke.GlobalEvents.fireEvent('endpointexception', callbackParams);
+    }
+  },
+
+  /**
+   * Returns direct function by endpoint name and optional component's config (if not provided, component's instance
+   * will be used instead)
+   * @method netzkeGetDirectFunction
+   * @param methodName {String}
+   * @param {Object} [config]
+   */
+  netzkeGetDirectFunction: function(methodName, config) {
+    config = config || this;
+    return Netzke.remotingMethods[config.id][methodName];
+  },
+
+  /**
+   * Reversed array of server configs for each parent component up the tree
+   * @method netzkeBuildParentConfigs
+   */
+  netzkeBuildParentConfigs: function() {
+    var res = [],
+        parent = this;
+    while (parent) {
+      var cfg = Ext.clone(parent.serverConfig);
+      res.unshift(cfg);
+      parent = parent.netzkeGetParentComponent();
+    }
+    return res;
+  },
+
+  /**
+    * Replaces actions configs with Ext.Action instances, assigning default handler to them
+    * @method netzkeNormalizeActions
+    * @param config {Object}
+    */
+  netzkeNormalizeActions : function(config){
+    var normActions = {};
+    for (var name in config.actions) {
+      // Configure the action
+      var actionConfig = Ext.apply({}, config.actions[name]); // do not modify original this.actions
+      actionConfig.customHandler = actionConfig.handler;
+      actionConfig.handler = Ext.Function.bind(this.netzkeActionHandler, this); // handler common for all actions
+      actionConfig.name = name;
+
+      // instantiate Ext.Action
+      normActions[name] = new Ext.Action(actionConfig);
+    }
+    this.actions = normActions;
+    delete(config.actions);
+  },
+
+  /**
+   * Dynamically loads child Netzke component
+   * @method netzkeLoadComponent
+   * @param {String} name Component name as declared in the Ruby class with `component` DSL
+   * @param {Object} [options] May contain the following optional keys:
+   *   * **container** {Ext.container.Container|Integer}
+   *
+   *     The instance (or id) of a container with the "fit" layout where the loaded component will be added to; the previously existing component will be destroyed
+   *
+   *   * **append** {Boolean}
+   *
+   *     If set to `true`, do not clear the container before adding the loaded component
+   *
+   *   * **configOnly** {Boolean}
+   *
+   *     If set to `true`, do not instantiate/insert the component, instead pass its config to the callback function
+   *
+   *   * **serverConfig** {Object}
+   *
+   *     Config accessible inside the `component` DSL block as `client_config`; this allows reconfiguring child components by the client-side code
+   *
+   *   * **callback** {Function}
+   *
+   *     Function that gets called after the component is loaded; it receives the component's instance (or component config if `configOnly` is set) as parameter; if the function returns `false`, the loaded component will not be automatically inserted or (in case of window) shown.
+   *
+   *   * **scope** {Object}
+   *
+   *     Scope for the callback; defaults to the instance of the component.
+   *
+   * @example
+   *
+   * Loads 'info' and adds it to `this` container, removing anything from it first:
+   *
+   *     this.netzkeLoadComponent('info');
+   *
+   * Loads 'info' and adds it to `win` container, envoking a callback in `this` scope, passing it an instance of 'info':
+   *
+   *     this.netzkeLoadComponent('info', { container: win, callback: function(instance){} });
+   *
+   * Loads configuration for the 'info' component, envoking a callback in `this` scope, passing it the loaded config for 'info'.
+   *
+   *     this.netzkeLoadComponent('info', { configOnly: true, callback: function(config){} });
+   *
+   * Loads two 'info' instances in different containers and with different configurations:
+   *
+   *     this.netzkeLoadComponent('info', {
+   *       container: 'tab1',
+   *       serverConfig: { user: 'john' } // on the server: client_config[:user] == 'john'
+   *     });
+   *
+   *     this.netzkeLoadComponent('info', {
+   *       container: 'tab2',
+   *       serverConfig: { user: 'bill' } // on the server: client_config[:user] == 'bill'
+   *     });
+   */
+  netzkeLoadComponent: function(name, options){
+    var container, serverParams, containerEl;
+    options = options || {};
+
+    container = this.netzkeChooseContainer(options);
+    serverParams = this.netzkeBuildServerLoadingParams(name, options);
+
+    this.netzkeShowLoadingMask(container);
+
+    // Call the endpoint
+    this.server.deliverComponent(serverParams, function(result, success) {
+      this.netzkeHideLoadingMask(container);
+
+      if (success) {
+        this.netzkeHandleLoadingResponse(container, result, options);
+      } else {
+        this.netzkeHandleLoadingError(result);
+      }
+    });
+  },
+
+  /**
+   * Handles loading error
+   * @method netzkeHandleLoadingError
+   */
+  netzkeHandleLoadingError: function(error){
+    this.netzkeNotify(error);
+  },
+
+  /**
+   * TODO
+   * @method netzkeBuildServerLoadingParams
+   */
+  netzkeBuildServerLoadingParams: function(name, params) {
+    return Ext.apply(params.serverParams || {}, {
+      name: name,
+      client_config: params.serverConfig,
+      item_id: params.itemId || name, // TODO: make optional
+      cache: Netzke.cache.join() // coma-separated list of xtypes of already loaded classes
+    });
+  },
+
+  /**
+   * Decides, based on params passed to `netzkeLoadComponent`, what container the component should be loaded into.
+   * @method netzkeChooseContainer
+   * @param params Object
+   */
+  netzkeChooseContainer: function(params) {
+    if (!params.container) return this;
+    return Ext.isString(params.container) ? Ext.getCmp(params.container) : params.container;
+  },
+
+  /**
+   * Handles regular server response (may include error)
+   * @method netzkeHandleLoadingResponse
+   */
+  netzkeHandleLoadingResponse: function(container, result, params){
+    if (result.error) {
+      this.netzkeNotify(result.error);
+    } else {
+      this.netzkeProcessDeliveredComponent(container, result, params);
+    }
+  },
+
+  /**
+   * Processes delivered component
+   * @method netzkeProcessDeliveredComponent
+   */
+  netzkeProcessDeliveredComponent: function(container, result, params){
+    var config = result.config, instance, doNotInsert, currentInstance;
+    config.netzkeParent = this;
+
+    this.netzkeEvalJs(result.js);
+    this.netzkeEvalCss(result.css);
+
+    if (params.configOnly) {
+      if (params.callback) params.callback.apply((params.scope || this), [config, params]);
+    } else {
+      // we must destroy eventual existing component with the same ID
+      currentInstance = Ext.getCmp(config.id);
+      if (currentInstance) currentInstance.destroy();
+
+      instance = Ext.create(config);
+
+      if (params.callback) {
+        doNotInsert = params.callback.apply((params.scope || this), [instance, params]) == false;
+      }
+
+      if (doNotInsert) return;
+
+      if (instance.isFloating()) { // windows are not containable
+        instance.show();
+      } else {
+        if (params.replace) {
+          this.netzkeReplaceChild(params.replace, instance)
+        } else {
+          if (!params.append) container.removeAll();
+          container.add(instance);
+        }
+      }
+    }
+  },
+
+  /**
+   * Masks container in which a child component is being loaded
+   * @method netzkeShowLoadingMask
+   */
+  netzkeShowLoadingMask: function(container){
+    if (container.rendered) container.mask();
+  },
+
+  /**
+   * Unmasks loading container
+   * @method netzkeHideLoadingMask
+   */
+  netzkeHideLoadingMask: function(container){
+    if (container.rendered) container.unmask();
+  },
+
+  /**
+   * Returns parent Netzke component
+   * @method netzkeGetParentComponent
+   */
+  netzkeGetParentComponent: function(){
+    return this.netzkeParent;
+  },
+
+  /**
+   * Reloads itself by instructing the parent to call `netzkeLoadComponent`.
+   * Note: in order for this to work, the component must be nested in a container with the 'fit' layout.
+   * @method netzkeReload
+   */
+  netzkeReload: function(){
+    var parent = this.netzkeGetParentComponent();
+
+    if (parent) {
+      parent.netzkeReloadChild(this);
+    } else {
+      window.location.reload();
+    }
+  },
+
+  /**
+   * Given child component and new serverConfig, reloads the component
+   * @method netzkeReloadChild
+   * @param child Netzke.Base
+   * @param serverConfig Object
+   */
+  netzkeReloadChild: function(child, serverConfig){
+    this.netzkeLoadComponent(child.name, {
+      configOnly: true,
+      serverConfig: serverConfig,
+      callback: function(cfg) {
+        this.netzkeReplaceChild(child, cfg);
+      }
+    });
+  },
+
+  /**
+   * Replaces given (Netzke or Ext JS) component and new config, replaces former with latter, by instructing the parent
+   * component to re-insert the component at the same index. Override if you need something more fancy (e.g. active tab
+   * when it gets re-inserted)
+   * @method netzkeReplaceChild
+   * @param child {Netzke.Base}
+   * @param config {Obect}
+   */
+  netzkeReplaceChild: function(child, config){
+    var parent = child.up();
+    if (!parent) return;
+    var index = parent.items.indexOf(child);
+    Ext.suspendLayouts();
+    parent.remove(child);
+    var res = parent.insert(index, config);
+    Ext.resumeLayouts(true);
+    return res;
+  },
+
+  /**
+  * Instantiates and returns a Netzke component by its name.
+  * @method netzkeInstantiateComponent
+  * @param name {String} Child component's name/itemId
+  */
+  netzkeInstantiateComponent: function(name) {
+    name = name.camelize(true);
+    var cfg = this.netzkeComponents[name];
+    return Ext.createByAlias(this.netzkeComponents[name].alias, cfg)
+  },
+
+  /**
+  * Returns *instantiated* child component by its relative path
+  * @method netzkeGetComponent
+  * @param path {String} Component path, which may contain the 'parent' for walking up the hierarchy, e.g.
+  * `parent__sibling`. If this is empty, the method will return `this`.
+  */
+  netzkeGetComponent: function(path){
+    if (path === "") {return this};
+    path = path.underscore();
+    var split = path.split("__"), res;
+    if (split[0] === 'parent') {
+      split.shift();
+      var childInParentScope = split.join("__");
+      res = this.netzkeGetParentComponent().netzkeGetComponent(childInParentScope);
+    } else {
+      res = Ext.getCmp(this.id+"__"+path);
+    }
+    return res;
+  },
+
+  /**
+  * Triggers a notification unless `quiet` config option is `true`.
+  * @method netzkeNotify
+  * @param {String} msg Notification body
+  * @param {Object} options Notification options (such as `title`, `delay`)
+  */
+  netzkeNotify: function(msg, options){
+    if (this.quiet !== true) this.netzkeNotifier.msg(msg, options);
+  },
+
+  /**
+  * Common handler for all netzke's actions.
+  * @method netzkeActionHandler
+  * @param {Ext.Component} comp Component that triggered the action (e.g. button or menu item)
+  */
+  netzkeActionHandler: function(comp){
+    var actionName = comp.name;
+    // If firing corresponding event doesn't return false, call the handler
+    if (this.fireEvent(actionName+'click', comp)) {
+      var action = this.actions[actionName];
+      var customHandler = action.initialConfig.customHandler;
+      var methodName = (customHandler && customHandler.camelize(true)) || "netzkeOn" + actionName.camelize();
+      if (!this[methodName]) {throw "Netzke: handler '" + methodName + "' is undefined in '" + this.id + "'";}
+
+      // call the handler passing it the triggering component
+      this[methodName](comp);
+    }
+  },
+
+  /**
+   * TODO
+   * @method netzkeProcessPlugins
+   */
+  netzkeProcessPlugins: function(config) {
+    if (config.netzkePlugins) {
+      if (!this.plugins) this.plugins = [];
+      Ext.each(config.netzkePlugins, function(p){
+        this.plugins.push(this.netzkeInstantiateComponent(p));
+      }, this);
+      delete config.netzkePlugins;
+    }
   }
 });