netzke-core 0.7.7 → 0.8.0

data/config/ci/before-travis.sh

@@ -2,10 +2,9 @@
 sh -e /etc/init.d/xvfb start
 
 # fetch extjs
-wget http://cdn.sencha.io/ext-4.0.7-gpl.zip
-unzip -q -d test/core_test_app/public/ -n ext-4.0.7-gpl.zip
-mv test/core_test_app/public/ext-4.0.7-gpl test/core_test_app/public/extjs
+wget http://cdn.sencha.io/ext-4.1.1a-gpl.zip
+unzip -q -d test/core_test_app/public/ -n ext-4.1.1a-gpl.zip
+mv test/core_test_app/public/ext-4.1.1a test/core_test_app/public/extjs
 
 # cp db configuration
 cp test/core_test_app/config/database.yml.travis  test/core_test_app/config/database.yml
-

data/javascripts/base.js

@@ -1,15 +1,18 @@
 /**
-This file gets loaded along with the rest of Ext library at the initial load
+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.classes'); // namespace for all component classes
+Ext.ns(Netzke.classNamespace); // namespace for all component classes
 Ext.ns('Netzke.classes.Core'); // namespace for Core mixins
 
 Netzke.deprecationWarning = function(msg){
@@ -41,28 +44,6 @@ Netzke.isLoading=function () {
   return Netzke.runningRequests != 0;
 }
 
-// Similar to Ext.apply, but can accept any number of parameters, e.g.
-//
-//     Netzke.chainApply(targetObject, {...}, {...}, {...});
-Netzke.chainApply = function(){
-  var res = {};
-  Ext.each(arguments, function(o){
-    Ext.apply(res, o);
-  });
-  return res;
-};
-
-/* Similar to Rails' alias_method_chain. Usefull when using mixins. E.g.:
-
-    Netzke.aliasMethodChain(this, "initComponent", "netzke")
-
-    will result in 2 new methods on this.initComponentWithNetzke and this.initComponentWithoutNetzke
-*/
-Netzke.aliasMethodChain = function(klass, method, feature) {
-  klass[method + "Without" + feature.capitalize()] = klass[method];
-  klass[method] = klass[method + "With" + feature.capitalize()];
-};
-
 // xtypes of cached Netzke classes
 Netzke.cache = [];
 
@@ -70,38 +51,14 @@ Netzke.componentNotInSessionHandler = function() {
   throw "Netzke: component not in Rails session. Define Netzke.componentNotInSessionHandler to handle this.";
 };
 
-Netzke.classes.Core.Mixin = {};
-
-// Properties/methods common to all Netzke component classes
-Netzke.componentMixin = Ext.applyIf(Netzke.classes.Core.Mixin, {
+Ext.define("Netzke.classes.Core.Mixin", {
   isNetzke: true, // to distinguish Netzke components from regular Ext components
 
-  /*
-  Detects component placeholders in the passed object (typically, "items"),
-  and merges them with the corresponding config from this.netzkeComponents.
-  This way it becomes ready to be instantiated properly by Ext.
-  */
-  detectComponents: function(o){
-    if (Ext.isObject(o)) {
-      if (o.items) this.detectComponents(o.items);
-    } else if (Ext.isArray(o)) {
-      var a = o;
-      Ext.each(a, function(c, i){
-        if (c.netzkeComponent) {
-          var cmpName = c.netzkeComponent,
-              cmpCfg = this.netzkeComponents[cmpName.camelize(true)];
-          if (!cmpCfg) throw "Netzke: unknown component reference " + cmpName;
-          a[i] = Ext.apply(cmpCfg, c);
-          delete a[i].netzkeComponent; // not needed any longer
-        } else if (c.items) this.detectComponents(c.items);
-      }, this);
-    }
-  },
-
-  /*
-  Evaluates CSS
+  /**
+  * Evaluates CSS
+  * @private
   */
-  evalCss : function(code){
+  netzkeEvalCss : function(code){
     var head = Ext.fly(document.getElementsByTagName('head')[0]);
     Ext.core.DomHelper.append(head, {
       tag: 'style',
@@ -110,24 +67,24 @@ Netzke.componentMixin = Ext.applyIf(Netzke.classes.Core.Mixin, {
     });
   },
 
-  /*
-  Evaluates JS
+  /**
+  * Evaluates JS
+  * @private
   */
-  evalJs : function(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".
+  /**
+  * 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
   */
-  localId : function(parent){
+  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:
@@ -135,7 +92,7 @@ Netzke.componentMixin = Ext.applyIf(Netzke.classes.Core.Mixin, {
       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, bulkExecute will be called on that component with the value passed as the argument.
+      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");
@@ -144,22 +101,25 @@ Netzke.componentMixin = Ext.applyIf(Netzke.classes.Core.Mixin, {
       // same as: this.setTitle('Suprise!'); this.setDisabled(true);
       [{setTitle:'Suprise!'}, {setDisabled:true}]
 
-      // the same as this.getChildNetzkeComponent('users').bulkExecute([{setTitle:'Suprise!'}, {setDisabled:true}]);
+      // the same as this.netzkeGetComponent('users').netzkeBulkExecute([{setTitle:'Suprise!'}, {setDisabled:true}]);
       {users: [{setTitle:'Suprise!'}, {setDisabled:true}] }
+  @private
   */
-  bulkExecute : function(instructions){
+  netzkeBulkExecute : function(instructions){
     if (Ext.isArray(instructions)) {
-      Ext.each(instructions, function(instruction){ this.bulkExecute(instruction)}, this);
+      Ext.each(instructions, function(instruction){ this.netzkeBulkExecute(instruction)}, this);
     } else {
       for (var instr in instructions) {
+        var args = instructions[instr];
+
         if (Ext.isFunction(this[instr])) {
           // Executing the method.
-          this[instr].apply(this, [instructions[instr]]);
+          this[instr].apply(this, args);
         } else {
-          var childComponent = this.getChildNetzkeComponent(instr);
+          var childComponent = this.netzkeGetComponent(instr);
           if (childComponent) {
-            childComponent.bulkExecute(instructions[instr]);
-          } else {
+            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 + "'"
           }
         }
@@ -167,96 +127,72 @@ Netzke.componentMixin = Ext.applyIf(Netzke.classes.Core.Mixin, {
     }
   },
 
-  // Used by Touch components
-  endpointUrl: function(endpoint){
-    return Netzke.RelativeUrlRoot + "/netzke/dispatcher?address=" + this.id + "__" + endpoint;
-  },
-
-  // Does the call to the server and processes the response
-  callServer : function(intp, params, callback, scope){
-    Netzke.runningRequests++;
-    if (!params) params = {};
-      Ext.Ajax.request({
-      params: params,
-      url: this.endpointUrl(intp),
-      callback: function(options, success, response){
-        if (success && response.responseText) {
-          // execute commands from server
-          this.bulkExecute(Ext.decode(response.responseText));
-
-          // provide callback if needed
-          if (typeof callback == 'function') {
-            if (!scope) scope = this;
-            callback.apply(scope, [this.latestResult]);
-          }
-        }
-        Netzke.runningRequests--;
-      },
-      scope : this
-    });
-  },
-
-  setResult: function(result) {
+  /**
+   * @private
+   */
+  netzkeSetResult: function(result) {
     this.latestResult = result;
   },
 
-  // When an endpoint call is issued while the session has expired, this method is called. Override it to do whatever is appropriate.
-  componentNotInSession: function() {
+  /**
+  * When an endpoint call is issued while the session has expired, this method is called. Override it to do whatever is appropriate.
+  * @private
+  */
+  netzkeComponentNotInSession: function() {
     Netzke.componentNotInSessionHandler();
-  }
-});
-
-
-// DEPRECATED as whole. Netzke extensions for Ext.Container.
-Ext.override(Ext.Container, {
-  // Instantiates an component by its config. If it appears to be a window, shows it instead of adding as item.
-  instantiateChild: function(config){
-    Netzke.deprecationWarning("instantiateChild is deprecated");
-    var instance = Ext.createByAlias( config.alias, config );
-    this.insertNetzkeComponent(instance);
-    return instance;
   },
 
-  insertNetzkeComponent: function(cmp) {
-    this.removeChild(); // first delete previous component
-    this.add(cmp);
-
-    // Sometimes a child is getting loaded into a hidden container...
-    if (this.isVisible()) {
-      this.doLayout();
-    } else {
-      this.on('show', function(cmp){cmp.doLayout();}, {single: true});
-    }
+  /**
+   * Returns a URL for old-fashion requests (used at multi-part form non-AJAX submissions)
+   * @private
+   */
+  netzkeEndpointUrl: function(endpoint){
+    return Netzke.ControllerUrl + "dispatcher?address=" + this.id + "__" + endpoint;
   },
 
   /**
-    Get Netzke component that this Ext.Container is part of (*not* the parent component, for which call getParent)
-    It searches up the Ext.Container hierarchy until it finds a Container that has isNetzke property set to true
-    (or until it reaches the top).
-  */
-  getOwnerComponent: function(){
-    Netzke.deprecationWarning("getOwnerComponent is deprecated");
-    if (this.initialConfig.isNetzke) {
-      return this;
-    } else {
-      if (this.ownerCt){
-        return this.ownerCt.getOwnerComponent();
-      } else {
-        return null;
+   * @private
+   */
+  netzkeNormalizeConfigArray: function(items){
+    var cfg, ref, cmpName, cmpCfg, actName, actCfg;
+
+    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};
       }
-    }
-  },
 
-  // Get the component that we are hosting
-  getNetzkeComponent: function(){
-    Netzke.deprecationWarning("getNetzkeComponent is deprecated");
-    return this.items ? this.items.first() : null; // need this check in case when the container is not yet rendered, like an inactive tab in the TabPanel
-  },
+      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);
+
+      } else if (cfg.netzkeComponent) {
+        // replace with component config
+        cmpName = cfg.netzkeComponent;
+        cmpCfg = this.netzkeComponents[cmpName.camelize(true)];
+        if (!cmpCfg) throw "Netzke: unknown component " + cmpName;
+        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
+        items[i] = Ext.apply(this[cfg.camelize(true)+"Config"](this.passedConfig), {netzkeParent: this});
 
-  // Remove the child
-  removeChild: function(){
-    Netzke.deprecationWarning("removeChild is deprecated");
-    var currentChild = this.getNetzkeComponent();
-    if (currentChild) {this.remove(currentChild);}
+      } else {
+        // recursion
+        for (key in cfg) {
+          if (Ext.isArray(cfg[key])) {
+            this.netzkeNormalizeConfigArray(cfg[key]);
+          }
+        }
+      }
+    }, this);
   }
 });

data/javascripts/ext.js

@@ -1,14 +1,11 @@
-// Enable Ext 4 migration errors traceback display
-if (Ext.Compat) Ext.Compat.showErrors = true;
+// This file has stuff related to Ext JS (as apposed to Touch)
 
 // Because of Netzke's double-underscore notation, Ext.TabPanel should have a different id-delimiter (yes, this should be in netzke-core)
 Ext.TabPanel.prototype.idDelimiter = "___";
 
+// Enable quick tips
 Ext.QuickTips.init();
 
-// We don't want no state managment by default, thank you!
-Ext.state.Provider.prototype.set = Ext.emptyFn;
-
 // Checking Ext JS version: both major and minor versions must be the same
 (function(){
   var requiredVersionMajor = 4,
@@ -55,9 +52,6 @@ Ext.define('Netzke.FeedbackGhost', {
   }
 });
 
-// Mix it into every Netzke component as feedbackGhost
-Netzke.componentMixin.feedbackGhost = Ext.create("Netzke.FeedbackGhost");
-
 Ext.define('Netzke.classes.NetzkeRemotingProvider', {
   extend: 'Ext.direct.RemotingProvider',
 
@@ -89,9 +83,41 @@ Ext.define('Netzke.classes.NetzkeRemotingProvider', {
   }
 });
 
+// Override Ext.Component's constructor to enable Netzke features
+Ext.define(null, {
+  override: 'Ext.Component',
+  constructor: function(config) {
+    if (this.isNetzke) {
+
+      this.netzkeComponents = config.netzkeComponents;
+      this.passedConfig = config;
+
+      // process and get rid of endpoints config
+      this.netzkeProcessEndpoints(config);
+
+      // process and get rid of plugins config
+      this.netzkeProcessPlugins(config);
+
+      this.netzkeNormalizeActions(config);
+
+      this.netzkeNormalizeConfig(config);
+
+      this.netzkeNormalizeTools(config);
+
+      // This is where the references to different callback functions will be stored
+      this.callbackHash = {};
+
+      // This is where we store the information about components that are currently being loaded with this.loadComponent()
+      this.componentsBeingLoaded = {};
+    }
+
+    this.callOverridden([config]);
+  }
+});
+
 Netzke.directProvider = new Netzke.classes.NetzkeRemotingProvider({
   type: "remoting",       // create a Ext.direct.RemotingProvider
-  url: Netzke.RelativeUrlRoot + "/netzke/direct/", // url to connect to the Ext.Direct server-side router.
+  url: Netzke.ControllerUrl + "direct/", // url to connect to the Ext.Direct server-side router.
   namespace: "Netzke.providers", // namespace to create the Remoting Provider in
   actions: {},
   maxRetries: Netzke.core.directMaxRetries,
@@ -102,58 +128,35 @@ Netzke.directProvider = new Netzke.classes.NetzkeRemotingProvider({
 Ext.Direct.addProvider(Netzke.directProvider);
 
 // Methods/properties that each and every Netzke component will have
-Ext.apply(Netzke.classes.Core.Mixin, {
+Ext.define(null, {
+  override: 'Netzke.classes.Core.Mixin',
+  feedbackGhost: Ext.create("Netzke.FeedbackGhost"),
+
   /*
   Mask shown during loading of a component. Set to false to not mask. Pass config for Ext.LoadMask for configuring msg/cls, etc.
   Set msg to null if mask without any msg is desirable.
   */
-  componentLoadMask: true,
-
-  /* initComponent common for all Netzke components */
-  initComponentWithNetzke: function(){
-    this.normalizeActions();
-
-    this.detectActions(this);
-
-    // Detects component placeholders in the passed object (typically, "items"),
-    // and merges them with the corresponding config from this.netzkeComponents.
-    // This way it becomes ready to be instantiated properly by Ext.
-    this.detectComponents(this.items);
-
-    this.normalizeTools();
-
-    this.processEndpoints();
-
-    this.processPlugins();
-
-    // This is where the references to different callback functions will be stored
-    this.callbackHash = {};
-
-    // This is where we store the information about components that are currently being loaded with this.loadComponent()
-    this.componentsBeingLoaded = {};
-
-    // Set title
-    if (this.mode === "config"){
-      if (!this.title) {
-        this.title = '[' + this.id + ']';
-      } else {
-        this.title = this.title + ' [' + this.id + ']';
-      }
-    } else {
-      if (!this.title) {
-        this.title = this.id.humanize();
-      }
+  netzkeLoadMask: true,
+
+  /**
+   * 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
+   * @private
+   */
+  netzkeNormalizeConfig: function(config) {
+    for (key in config) {
+      if (Ext.isArray(config[key])) this.netzkeNormalizeConfigArray(config[key]);
     }
-
-    // Call the original initComponent
-    this.initComponentWithoutNetzke();
   },
 
-  /*
-  Dynamically creates methods for endpoints, so that we could later call them like: this.myEndpointMethod()
+  /**
+  * Dynamically creates methods for endpoints, so that we could later call them like: this.myEndpointMethod()
+  * @private
   */
-  processEndpoints: function(){
-    var endpoints = this.endpoints || [];
+  netzkeProcessEndpoints: function(config){
+    var endpoints = config.endpoints || [];
     endpoints.push('deliver_component'); // all Netzke components get this endpoint
     var directActions = [];
     var that = this;
@@ -164,12 +167,12 @@ Ext.apply(Netzke.classes.Core.Mixin, {
         Netzke.runningRequests++;
 
         scope = scope || that;
-        Netzke.providers[this.id][intp.camelize(true)].call(scope, arg, function(result, remotingEvent) {
+        Netzke.providers[config.id][intp.camelize(true)].call(scope, arg, function(result, remotingEvent) {
           if(remotingEvent.message) {
             console.error("RPC event indicates an error: ", remotingEvent);
             throw new Error(remotingEvent.message);
           }
-          that.bulkExecute(result); // invoke the endpoint result on the calling component
+          that.netzkeBulkExecute(result); // invoke the endpoint result on the calling component
           if(typeof callback == "function") {
             callback.call(scope, that.latestResult); // invoke the callback on the provided scope, or on the calling component if no scope set. Pass latestResult to callback
           }
@@ -178,92 +181,86 @@ Ext.apply(Netzke.classes.Core.Mixin, {
       }
     }, this);
 
-    Netzke.directProvider.addAction(this.id, directActions);
+    Netzke.directProvider.addAction(config.id, directActions);
+
+    delete config.endpoints;
   },
 
-  normalizeTools: function() {
-    if (this.tools) {
+  /**
+   * @private
+   */
+  netzkeNormalizeTools: function(config) {
+    if (config.tools) {
       var normTools = [];
-      Ext.each(this.tools, function(tool){
+      Ext.each(config.tools, function(tool){
         // Create an event for each action (so that higher-level components could interfere)
         this.addEvents(tool.id+'click');
 
-        var handler = Ext.Function.bind(this.toolActionHandler, this, [tool]);
+        var handler = Ext.Function.bind(this.netzkeToolHandler, this, [tool]);
         normTools.push({type : tool, handler : handler, scope : this});
       }, this);
       this.tools = normTools;
+      delete config.tools;
     }
   },
 
-  /*
-  Replaces actions configs with Ext.Action instances, assigning default handler to them
-  */
-  normalizeActions : function(){
+  /**
+    * Replaces actions configs with Ext.Action instances, assigning default handler to them
+    * @private
+    */
+  netzkeNormalizeActions : function(config){
     var normActions = {};
-    for (var name in this.actions) {
+    for (var name in config.actions) {
       // Create an event for each action (so that higher-level components could interfere)
       this.addEvents(name+'click');
 
       // Configure the action
-      var actionConfig = Ext.apply({}, this.actions[name]); // do not modify original this.actions
+      var actionConfig = Ext.apply({}, config.actions[name]); // do not modify original this.actions
       actionConfig.customHandler = actionConfig.handler;
-      actionConfig.handler = Ext.Function.bind(this.actionHandler, this); // handler common for all actions
+      actionConfig.handler = Ext.Function.bind(this.netzkeActionHandler, this); // handler common for all actions
       actionConfig.name = name;
       normActions[name] = new Ext.Action(actionConfig);
     }
-    delete(this.actions);
     this.actions = normActions;
+    delete(config.actions);
   },
 
-  /*
-  Detects action configs in the passed object, and replaces them with instances of Ext.Action created by normalizeActions().
-  This detects action in arbitrary level of nesting, which means you can put any other components in your toolbar, and inside of them specify menus/items or even toolbars.
-  */
-  detectActions: function(o){
-    if (Ext.isObject(o)) {
-      if ((typeof o.handler === 'string') && Ext.isFunction(this[o.handler.camelize(true)])) {
-         // This button config has a handler specified as string - replace it with reference to a real function if it exists
-        o.handler = this[o.handler.camelize(true)].createDelegate(this);
-      }
-      // TODO: this should be configurable!
-      Ext.each(["bbar", "tbar", "fbar", "menu", "items", "contextMenu", "buttons", "dockedItems"], function(key){
-        if (o[key]) {
-          var items = [].concat(o[key]); // we need to do it in order to esure that this instance has a separate bbar/tbar/etc, NOT shared via class' prototype
-          delete(o[key]);
-          o[key] = items;
-          this.detectActions(o[key]);
-        }
-      }, this);
-    } else if (Ext.isArray(o)) {
-      var a = o;
-      Ext.each(a, function(el, i){
-        if (Ext.isObject(el)) {
-          if (el.action) {
-            if (!this.actions[el.action.camelize(true)]) throw "Netzke: action '"+el.action+"' not defined";
-            a[i] = this.actions[el.action.camelize(true)];
-            delete(el);
-          } else {
-            this.detectActions(el);
-          }
-        }
-      }, this);
-    }
-  },
-
-  /*
-  Dynamically loads a Netzke component.
-  Config options:
-  'name' (required) - the name of the child component to load
-  'container' - if specified, the id (or instance) of a panel with the 'fit' layout where the loaded component will be added to; the previously existing component will be destroyed
-  'callback' - function that gets called after the component is loaded; it receives the component's instance as parameter
-  'scope' - scope for the callback
-  */
-  loadNetzkeComponent: function(params){
-    if (params.id) {
-      params.name = params.id;
-      Netzke.deprecationWarning("Using 'id' in loadComponent is deprecated. Use 'name' instead.");
+  /**
+   * Dynamically loads a Netzke component.
+   * @param {String} name
+   * @param {Object} config Can contain the following keys:
+   *   'container' - if specified, the instance (or id) of a panel with the 'fit' layout where the loaded component will be added to; the previously existing component will be destroyed
+   *   'append' - if set to +true+, do not clear the container before adding the loaded component
+   *   'callback' - function that gets called after the component is loaded; it receives the component's instance as parameter
+   *   'configOnly' - if set to +true+, do not instantiate the component, instead pass its config to the callback function
+   *   'params' - object passed to the endpoint, may be useful for extra configuration
+   *   'scope' - scope for the callback
+   *
+   * Examples:
+   *
+   *    this.netzkeLoadComponent('info');
+   *
+   * loads 'info' and adds it to +this+ container, removing anything from it first.
+   *
+   *    this.netzkeLoadComponent('info', {container: win, callback: function(instance){}, scope: this});
+   *
+   * loads 'info' and adds it to +win+ container, envoking a callback in +this+ scope, passing it an instance of 'info'.
+   *
+   *    this.netzkeLoadComponent('info', {configOnly: true, callback: function(config){}, scope: this});
+   *
+   * loads configuration for the 'info' component, envoking a callback in +this+ scope, passing it the loaded config for 'info'.
+   */
+  netzkeLoadComponent: function(){
+    var params;
+
+    if (Ext.isString(arguments[0])) {
+      params = arguments[1] || {};
+      params.name = arguments[0];
+    } else {
+      params = arguments[0];
     }
 
+    if (params.container == undefined) params.container = this;
     params.name = params.name.underscore();
 
     // params that will be provided for the server API call (deliver_component); all what's passed in params.params is merged in. This way we exclude from sending along such things as :scope, :callback, etc.
@@ -281,8 +278,8 @@ Ext.apply(Netzke.classes.Core.Mixin, {
 
     // Show loading mask if possible
     var containerEl = (containerCmp || this).getEl();
-    if (this.componentLoadMask && containerEl){
-      storedConfig.loadMaskCmp = new Ext.LoadMask(containerEl, this.componentLoadMask);
+    if (this.netzkeLoadMask && containerEl){
+      storedConfig.loadMaskCmp = new Ext.LoadMask(containerEl, this.netzkeLoadMask);
       storedConfig.loadMaskCmp.show();
     }
 
@@ -290,19 +287,14 @@ Ext.apply(Netzke.classes.Core.Mixin, {
     this.deliverComponent(serverParams);
   },
 
-  // DEPRECATED in favor or loadNetzkeComponent
-  loadComponent: function(params) {
-    Netzke.deprecationWarning("loadComponent is deprecated in favor of loadNetzkeComponent");
-    params.container = params.container || this.getId(); // for backward compatibility
-    this.loadNetzkeComponent(params);
-  },
-
-  /*
-  Called by the server after we ask him to load a component
+  /**
+   * Called by the server after we ask him to load a component
+   * @private
   */
-  componentDelivered: function(config){
+  netzkeComponentDelivered: function(config){
     // retrieve the loading config for this component
     var storedConfig = this.componentsBeingLoaded[config.name] || {};
+    var callbackParam;
     delete this.componentsBeingLoaded[config.name];
 
     if (storedConfig.loadMaskCmp) {
@@ -310,29 +302,36 @@ Ext.apply(Netzke.classes.Core.Mixin, {
       storedConfig.loadMaskCmp.destroy();
     }
 
-    var componentInstance = Ext.createByAlias(config.alias, config);
-
-    if (storedConfig.container) {
-      var containerCmp = storedConfig.container;
-      if (!storedConfig.append) containerCmp.removeAll();
-      containerCmp.add(componentInstance);
-
-      if (containerCmp.isVisible()) {
-        containerCmp.doLayout();
-      } else {
-        // if loaded into a hidden container, we need a little trick
-        containerCmp.on('show', function(cmp){ cmp.doLayout(); }, {single: true});
+    if (storedConfig.configOnly) {
+      callbackParam = config;
+    } else {
+      var componentInstance = Ext.ComponentManager.create(config);
+
+      // there's no sense in adding a window-type components
+      if (storedConfig.container && !componentInstance.isFloating()) {
+        var containerCmp = storedConfig.container;
+        if (!storedConfig.append) containerCmp.removeAll();
+        containerCmp.add(componentInstance);
+
+        if (containerCmp.isVisible()) {
+          containerCmp.doLayout();
+        } else {
+          // if loaded into a hidden container, we need a little trick
+          containerCmp.on('show', function(cmp){ cmp.doLayout(); }, {single: true});
+        }
       }
+      callbackParam = componentInstance;
     }
 
     if (storedConfig.callback) {
-      storedConfig.callback.call(storedConfig.scope || this, componentInstance);
+      storedConfig.callback.call(storedConfig.scope || this, callbackParam);
     }
-
-    this.fireEvent('componentload', componentInstance);
   },
 
-  componentDeliveryFailed: function(params) {
+  /**
+   * @private
+   */
+  netzkeComponentDeliveryFailed: function(params) {
     var storedConfig = this.componentsBeingLoaded[params.componentName] || {};
     delete this.componentsBeingLoaded[params.componentName];
 
@@ -344,24 +343,10 @@ Ext.apply(Netzke.classes.Core.Mixin, {
     this.netzkeFeedback({msg: params.msg, level: "Error"});
   },
 
-  /*
-  DEPRECATED. Instantiates and renders a component with given config and container.
+  /**
+  * Returns parent Netzke component
   */
-  instantiateAndRenderComponent: function(config, containerId){
-    var componentInstance;
-    if (containerId) {
-      var container = Ext.getCmp(containerId);
-      componentInstance = container.instantiateChild(config);
-    } else {
-      componentInstance = this.instantiateChild(config);
-    }
-    return componentInstance;
-  },
-
-  /*
-  Returns parent Netzke component
-  */
-  getParentNetzkeComponent: function(){
+  netzkeGetParentComponent: function(){
     // simply cutting the last part of the id: some_parent__a_kid__a_great_kid => some_parent__a_kid
     var idSplit = this.id.split("__");
     idSplit.pop();
@@ -370,63 +355,46 @@ Ext.apply(Netzke.classes.Core.Mixin, {
     return parentId === "" ? null : Ext.getCmp(parentId);
   },
 
-  // DEPRECATED
-  getParent: function() {
-    Netzke.deprecationWarning("getParent is deprecated in favor of getParentNetzkeComponent");
-    return this.getParentNetzkeComponent();
-  },
-
-  /*
-  Reloads current component (calls the parent to reload us as its component)
+  /**
+   * Reloads current component (calls the parent to reload us as its component)
   */
-  reload: function(){
-    var parent = this.getParentNetzkeComponent();
+  netzkeReload: function(){
+    var parent = this.netzkeGetParentComponent();
     if (parent) {
-      parent.loadNetzkeComponent({id:this.localId(parent), container:this.ownerCt.id});
+      parent.netzkeLoadComponent({id:this.netzkeLocalId(parent), container:this.ownerCt.id});
     } else {
       window.location.reload();
     }
   },
 
-  /*
-  DEPRECATED: Reconfigures the component
+  /**
+  * Instantiates and returns a Netzke component by its name.
+  * @private
   */
-  reconfigure: function(config){
-    this.ownerCt.instantiateChild(config)
-  },
-
-  /*
-  Instantiates and returns a Netzke component by its name.
-  */
-  instantiateChildNetzkeComponent: function(name) {
+  netzkeInstantiateComponent: function(name) {
     name = name.camelize(true);
     return Ext.createByAlias(this.netzkeComponents[name].alias, this.netzkeComponents[name])
   },
 
-  /*
-  Returns *instantiated* child component by its relative id, which may contain the 'parent' part to walk _up_ the hierarchy
+  /**
+  * Returns *instantiated* child component by its relative id, which may contain the 'parent' part to walk _up_ the hierarchy
+  * @private
   */
-  getChildNetzkeComponent: function(id){
+  netzkeGetComponent: function(id){
     if (id === "") {return this};
     id = id.underscore();
     var split = id.split("__");
     if (split[0] === 'parent') {
       split.shift();
       var childInParentScope = split.join("__");
-      return this.getParentNetzkeComponent().getChildNetzkeComponent(childInParentScope);
+      return this.netzkeGetParentComponent().netzkeGetComponent(childInParentScope);
     } else {
       return Ext.getCmp(this.id+"__"+id);
     }
   },
 
-  // DEPRECATED
-  getChildComponent: function(id) {
-    Netzke.deprecationWarning("getChildComponent is deprecated in favor of getChildNetzkeComponent");
-    return this.getChildNetzkeComponent(id);
-  },
-
-  /*
-  Provides a visual feedback. TODO: refactor
+  /**
+  * Provides a visual feedback. TODO: refactor
   */
   netzkeFeedback: function(msg){
     if (this.initialConfig && this.initialConfig.quiet) {
@@ -451,31 +419,29 @@ Ext.apply(Netzke.classes.Core.Mixin, {
     }
   },
 
-  // DEPRECATED in favor of netzkeFeedback
-  feedback: function(msg) {
-    Netzke.deprecationWarning("feedback is deprecated in favor of netzkeFeedback");
-    this.netzkeFeedback(msg);
-  },
-
-  /*
-  Common handler for all netzke's actions. <tt>comp</tt> is the Component that triggered the action (e.g. button or menu item)
+  /**
+  * Common handler for all netzke's actions. <tt>comp</tt> is the Component that triggered the action (e.g. button or menu item)
+  * @private
   */
-  actionHandler: function(comp){
+  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)) || "on" + actionName.camelize();
-      if (!this[methodName]) {throw "Netzke: action handler '" + methodName + "' is undefined"}
+      if (!this[methodName]) {throw "Netzke: handler '" + methodName + "' is undefined in '" + this.id + "'";}
 
       // call the handler passing it the triggering component
       this[methodName](comp);
     }
   },
 
-  // Common handler for tools
-  toolActionHandler: function(tool){
+  /**
+   * Common handler for tools
+   * @private
+   */
+  netzkeToolHandler: function(tool){
     // If firing corresponding event doesn't return false, call the handler
     if (this.fireEvent(tool.id+'click')) {
       var methodName = "on"+tool.camelize();
@@ -484,14 +450,18 @@ Ext.apply(Netzke.classes.Core.Mixin, {
     }
   },
 
-  processPlugins: function() {
-    if (this.netzkePlugins) {
+  /**
+   * @private
+   */
+  netzkeProcessPlugins: function(config) {
+    if (config.netzkePlugins) {
       if (!this.plugins) this.plugins = [];
-      Ext.each(this.netzkePlugins, function(p){
-        this.plugins.push(this.instantiateChildNetzkeComponent(p));
+      Ext.each(config.netzkePlugins, function(p){
+        this.plugins.push(this.netzkeInstantiateComponent(p));
       }, this);
+      delete config.netzkePlugins;
     }
   },
 
-  onComponentLoad:Ext.emptyFn // gets overridden
+  // netzkeOnComponentLoad: Ext.emptyFn // gets overridden
 });