skozlov-netzke-core 0.1.0.2 → 0.4.1

data/CHANGELOG

@@ -1,3 +1,111 @@
+v0.4.1
+2009-09-06
+Version bumb to force github rebuild the gem (Manifest is now included)
+
+v0.4.0
+2009-09-05
+Major refactoring.
+
+v0.3.2
+2009-06-05
+Netzke doesn't overwrite session[:user] anymore to not cause authentication-related problems.
+
+v0.3.1
+2009-05-07
+Fix: persistent_config_manager can now be set to nil, and it will work fine
+
+v0.3.0
+2009-05-07
+Refactor: got rid of NetzkeLayout model, now all layouts are stored in netzke_preferences
+New: persistent_config now has a method for_widget that accepts a block
+autotest compatibility
+New: String#to_b converts a string to true/false
+New: Netzke::Base.session introduced for session data
+New: weak_children_config and strong_children_config can now be declared by a widget, which specifies weak and strong configuration that every child of this widget will receive (e.g. display/hide configuration tool)
+Fix: (degradation) flash message is now shown again in case of erroneous attempt to load a widget
+New: widgets now can check session[:netzke_just_logged_in] and session[:netzke_just_logged_out] automatically set by Netzke after login/logout
+
+v0.2.11
+Introduction of getOwnerWidget()-method to Ext.Component. It provides the Netzke widget this Component belongs to.
+
+v0.2.10
+Removed dependency on 'json' gem.
+Rails v2.3.2 compatibility.
+
+v0.2.9
+Actions, toolbars and tools reworked for easier configuration.
+Menus introduced (based on actions).
+Significant code clean-up.
+Bug fix (nasty one): Ext.widgetMixIn was getting messed up along with dynamic widget loading.
+Must work in IE now.
+
+v0.2.8
+Support for extra javascripts and stylesheets per widget.
+
+v0.2.7
+QuickTips get initialized now, as otherwise Ext 2.2.1 doesn't properly destroy() BoxComponents for me.
+
+v0.2.6
+FeedackGhost is now capable of displaying multiple flash messages.
+Dependencies slightly refactored.
+An informative exception added to Base#aggregatee_instance.
+JS-level inheritance enabled.
+Work-around for the problem with Ext 2.2.1 in loadWidget.
+Events "<action_id>click" added to the widgets along with the actions.
+aggregatee_missing method added to Netzke::Base - called when a non-existing aggregate of a widget is tried to be invoked
+Code readability improvements.
+
+v0.2.5
+Minor code restructuring.
+
+v0.2.4
+Some minor improvements.
+
+v0.2.3
+FeedbackGhost will show the feedback on the top of the screen independent of the page scrolling.
+Ext.Panel#loadWidget will accept null as url to delete the currently loaded widget
+Bug fix: persistent_config works again
+
+v0.2.2
+js_ext_config instance method added for overwriting
+Multiuser support
+Using Rails.logger for logging
+"config"-class method for every class inheriting Netzke::Base - for class-level configurations
+
+v0.2.1
+Fixed the path to ext-base-min.js for production mode.
+Also works in Safari now.
+
+v0.2.0
+* Some re-factoring and redesign. Now simple compound widgets can be created on the fly in the controller
+* Added ext_widget[:quiet] configuration option to suppress widget's feedback
+* Support for extra CSS sources, similar to JS
+* NETZKE_BOOT_CONFIG introduced to specify which Netzke functionality should be disabled to reduce the size of /netzke/netzke.[js|css]
+* FeedbackGhost widget added - invisible widget providing feedback to the user
+* netzke_widget controller class-method renamed into netzke
+* JS-comments now get stripped also from the extra files that get included in the netzke-* gems.
+* Permissions joined js_config
+* Bug fixes
+
+v0.1.4
+Helpers added to facilitate ExtJS/netzke.js inclusion
+The route defined for netzke_controller
+netzke.html.erb-layout is not needed anymore, so not produced by the generator
+Now compliant with Rails' forgery protection
+
+v0.1.3
+Generators fixed
+
+v0.1.2
+Fixed the bug with <widget>_class_definition returning empty string on sequential loading.
+
+v0.1.1.1
+Meta: moving from GitHub to RubyForge
+
+v0.1.1
+Inter-widget dependencies code reworked
+JS-class code generation code slightly reworked
+
 v0.1.0.2
 Meta: fix outdated Manifest
 

data/LICENSE

@@ -1,20 +1,3 @@
-Copyright (c) 2008 Sergei Kozlov
+Copyright (c) 2008-2009 Sergei Kozlov
 
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+GNU GPL license v3

data/Manifest

@@ -0,0 +1,50 @@
+CHANGELOG
+LICENSE
+Manifest
+README.rdoc
+Rakefile
+TODO
+autotest/discover.rb
+generators/netzke_core/USAGE
+generators/netzke_core/netzke_core_generator.rb
+generators/netzke_core/templates/create_netzke_preferences.rb
+init.rb
+install.rb
+javascripts/core.js
+lib/app/controllers/netzke_controller.rb
+lib/app/models/netzke_preference.rb
+lib/netzke-core.rb
+lib/netzke/action_view_ext.rb
+lib/netzke/base.rb
+lib/netzke/base_js.rb
+lib/netzke/controller_extensions.rb
+lib/netzke/core_ext.rb
+lib/netzke/feedback_ghost.rb
+lib/netzke/routing.rb
+netzke-core.gemspec
+stylesheets/core.css
+tasks/netzke_core_tasks.rake
+test/app_root/app/controllers/application_controller.rb
+test/app_root/app/models/role.rb
+test/app_root/app/models/user.rb
+test/app_root/config/boot.rb
+test/app_root/config/database.yml
+test/app_root/config/environment.rb
+test/app_root/config/environments/in_memory.rb
+test/app_root/config/environments/mysql.rb
+test/app_root/config/environments/postgresql.rb
+test/app_root/config/environments/sqlite.rb
+test/app_root/config/environments/sqlite3.rb
+test/app_root/config/routes.rb
+test/app_root/db/migrate/20081222035855_create_netzke_preferences.rb
+test/app_root/db/migrate/20090423214303_create_roles.rb
+test/app_root/db/migrate/20090423222114_create_users.rb
+test/app_root/lib/console_with_fixtures.rb
+test/app_root/script/console
+test/fixtures/roles.yml
+test/fixtures/users.yml
+test/test_helper.rb
+test/unit/core_ext_test.rb
+test/unit/netzke_core_test.rb
+test/unit/netzke_preference_test.rb
+uninstall.rb

data/README.rdoc

@@ -0,0 +1,12 @@
+= netzke-core
+Create Ext JS + Rails reusable components (widgets) with minimum effort.
+
+Introduction to Netzke framework: http://github.com/skozlov/netzke/tree/master
+
+Tutorials: http://blog.writelesscode.com
+
+Live-demo: http://netzke-demo.writelesscode.com
+
+Also see netzke-basepack (pre-programmed widgets) project: http://github.com/skozlov/netzke-basepack/tree/master
+
+Copyright (c) 2009 Sergei Kozlov, released under the MIT license

data/Rakefile

@@ -2,10 +2,9 @@ require 'echoe'
 
 Echoe.new("netzke-core") do |p|
   p.author = "Sergei Kozlov"
-  p.email = "sergei@writelesscode.com"
+  p.email = "sergei@playcode.nl"
   p.summary = "Build ExtJS/Rails widgets with minimum effort"
-  p.url = "http://writelesscode.com"
-  # p.runtime_dependencies = ["searchlogic >=1.6.2"]
+  p.url = "http://playcode.nl"
   p.development_dependencies = []
   p.test_pattern = 'test/**/*_test.rb'
   p.retain_gemspec = true

data/TODO

@@ -0,0 +1,2 @@
+* Re-factor JS-level inheritance mechanisms (2009-07-5 why?)
+* Get rid of the default_config method, because the same functionality maybe achieved by overwriting the initialize method

data/autotest/discover.rb

@@ -0,0 +1,3 @@
+Autotest.add_discovery do
+  "rails"
+end

data/generators/netzke_core/netzke_core_generator.rb

@@ -2,12 +2,12 @@
 class NetzkeCoreGenerator < Rails::Generator::Base
   def manifest
     record do |m|
-      m.directory "public/javascripts/netzke"
-      # m.file 'netzke.js', "public/javascripts/netzke/netzke.js"
-      m.file 'netzke.html.erb', "app/views/layouts/netzke.html.erb"
-      m.migration_template 'create_netzke_preferences.rb', "db/migrate", {:migration_file_name => "create_netzke_preferences"}
-      # FIXME: how do we avoid getting the same migration IDs?
-      m.migration_template 'create_netzke_layouts.rb', "db/migrate", {:migration_file_name => "create_netzke_layouts"}
+      # FIXME: how do we avoid getting the same migration timestamps?
+      # Work-around
+      time = Time.now.utc.strftime("%Y%m%d%H%M%S")
+      m.directory 'db/migrate'
+      # m.file 'create_netzke_layouts.rb', "db/migrate/#{time}_create_netzke_layouts.rb"
+      m.file 'create_netzke_preferences.rb', "db/migrate/#{time.to_i+1}_create_netzke_preferences.rb"
     end
   end
 end

data/generators/netzke_core/templates/create_netzke_preferences.rb

@@ -3,10 +3,10 @@ class CreateNetzkePreferences < ActiveRecord::Migration
     create_table :netzke_preferences do |t|
       t.string :name
       t.string :pref_type
-      t.string :value
+      t.string :value, :limit => 65535
       t.integer :user_id
       t.integer :role_id
-      t.string :custom_field
+      t.string :widget_name
 
       t.timestamps
     end

data/javascripts/core.js

@@ -1,124 +1,487 @@
+/*
+This file gets loaded along with the rest of Ext library at the initial load
+*/
+
 Ext.BLANK_IMAGE_URL = "/extjs/resources/images/default/s.gif";
-Ext.componentCache = {};
+Ext.namespace('Ext.netzke'); // namespace for extensions that depend on Ext
+Ext.namespace('Netzke'); // namespace for extensions that do not depend on Ext
+Ext.netzke.cache = {};
+
+Ext.QuickTips.init(); // seems obligatory in Ext v2.2.1, otherwise Ext.Component#destroy() stops working properly
+
+// To comply with Rails' forgery protection
+Ext.Ajax.extraParams = {
+  authenticity_token : Ext.authenticityToken
+};
+
+// Type detection functions
+Netzke.isObject = function(o) {
+  return (o != null && typeof o == "object" && o.constructor.toString() == Object.toString());
+}
+
+// Some Ruby-ish String extensions
+// from http://code.google.com/p/inflection-js/
+String.prototype.camelize=function(lowFirstLetter)
+{
+  var str=this.toLowerCase();
+  var str_path=str.split('/');
+  for(var i=0;i<str_path.length;i++)
+  {
+    var str_arr=str_path[i].split('_');
+    var initX=((lowFirstLetter&&i+1==str_path.length)?(1):(0));
+    for(var x=initX;x<str_arr.length;x++)
+      str_arr[x]=str_arr[x].charAt(0).toUpperCase()+str_arr[x].substring(1);
+    str_path[i]=str_arr.join('');
+  }
+  str=str_path.join('::');
+  return str;
+};
 
-Ext.namespace('Ext.netzke');
+String.prototype.capitalize=function()
+{
+  var str=this.toLowerCase();
+  str=str.substring(0,1).toUpperCase()+str.substring(1);
+  return str;
+};
 
-// helper method to do multiple Ext.apply's
-Ext.chainApply = function(objectArray){
-	var res = {};
-	Ext.each(objectArray, function(obj){Ext.apply(res, obj)});
-	return res;
+String.prototype.humanize=function(lowFirstLetter)
+{
+  var str=this.toLowerCase();
+  str=str.replace(new RegExp('_id','g'),'');
+  str=str.replace(new RegExp('_','g'),' ');
+  if(!lowFirstLetter)str=str.capitalize();
+  return str;
 };
 
-// implementation of totalProperty, successProperty and root configuration options for ArrayReader
+// Implementation of totalProperty, successProperty and root configuration options for ArrayReader
 Ext.data.ArrayReader = Ext.extend(Ext.data.JsonReader, {
-    readRecords : function(o){
-     	var sid = this.meta ? this.meta.id : null;
-    	var recordType = this.recordType, fields = recordType.prototype.fields;
-    	var records = [];
-			// console.info(this.meta);
-    	var root = o[this.meta.root] || o, totalRecords = o[this.meta.totalProperty], success = o[this.meta.successProperty];
-	    for(var i = 0; i < root.length; i++){
-		    var n = root[i];
-	        var values = {};
-	        var id = ((sid || sid === 0) && n[sid] !== undefined && n[sid] !== "" ? n[sid] : null);
-	        for(var j = 0, jlen = fields.length; j < jlen; j++){
-                var f = fields.items[j];
-                var k = f.mapping !== undefined && f.mapping !== null ? f.mapping : j;
-                var v = n[k] !== undefined ? n[k] : f.defaultValue;
-                v = f.convert(v, n);
-                values[f.name] = v;
-            }
-	        var record = new recordType(values, id);
-	        record.json = n;
-	        records[records.length] = record;
-	    }
-	    return {
-	        records : records,
-	        totalRecords : totalRecords,
-					success : success
-	    };
+  readRecords : function(o){
+    var sid = this.meta ? this.meta.id : null;
+    var recordType = this.recordType, fields = recordType.prototype.fields;
+    var records = [];
+    var root = o[this.meta.root] || o, totalRecords = o[this.meta.totalProperty], success = o[this.meta.successProperty];
+    for(var i = 0; i < root.length; i++){
+      var n = root[i];
+      var values = {};
+      var id = ((sid || sid === 0) && n[sid] !== undefined && n[sid] !== "" ? n[sid] : null);
+      for(var j = 0, jlen = fields.length; j < jlen; j++){
+        var f = fields.items[j];
+        var k = f.mapping !== undefined && f.mapping !== null ? f.mapping : j;
+        var v = n[k] !== undefined ? n[k] : f.defaultValue;
+        v = f.convert(v, n);
+        values[f.name] = v;
+      }
+      var record = new recordType(values, id);
+      record.json = n;
+      records[records.length] = record;
     }
+    return {
+      records : records,
+      totalRecords : totalRecords,
+      success : success
+    };
+  }
 });
 
-// Methods common to all widget classes
+// Properties/methods common to all widget classes
 Ext.widgetMixIn = {
-	widgetInit:function(config){
-    this.app = Ext.getCmp('application');
-    if (config.tools) Ext.each(config.tools, function(i){i.on.click = this[i.on.click].createDelegate(this)}, this);
-    if (config.actions) Ext.each(config.actions, function(i){i.handler = this[i.handler].createDelegate(this);}, this);
-	},
-
-	setEvents: function(){
-		this.on('beforedestroy', function(){
-			// clean-up menus
-			if (this.app && !!this.app.unhostMenus) {
-				// alert('beforedestroy');
-				this.app.unhostMenus(this)
-			}
-		}, this);
-		
-		this.on('render', this.onWidgetLoad, this);
-	},
-
-	feedback:function(msg){
-		if (this.app && !!this.app.showFeedback) {
-			this.app.showFeedback(msg)
-		} else {
-			// there's no application to show the feedback - so, we do it ourselves
-			if (typeof msg == 'string'){
-				alert(msg)
-			} else {
-				var compoundResponse = ""
-				Ext.each(msg, function(m){
+  height: 400,
+  width: 800,
+  border: false,
+  is_netzke: true, // to distinguish Netzke components from regular Ext components
+  
+  /*
+  Loads aggregatee into a container. Sends the widgets cache info to the server.
+  */
+  loadAggregatee: function(params){
+    // build the cached widget list
+    var cachedWidgetNames = [];
+    for (name in Ext.netzke.cache) {
+      cachedWidgetNames.push(name);
+    }
+    
+    params.cache = Ext.encode(cachedWidgetNames);
+    
+    // remember the passed callback
+    if (params.callback) {
+      this.callbackHash[params.id] = params.callback;
+      delete params.callback;
+      delete params.scope;
+    }
+    
+    // visually disable the container while the widget is being loaded
+    // Ext.getCmp(params.container).disable();
+    Ext.getCmp(params.container).removeChild(); // simply cleanup the area, which speaks for itself
+    
+    // remote api call
+    this.loadAggregateeWithCache(params);
+  },
+  
+  /*
+  Called by the server as callback about loaded widget
+  */
+  widgetLoaded : function(params){
+    if (this.fireEvent('widgetload')) {
+      // Enable the container after the widget is succesfully loaded
+      // this.getChildWidget(params.id).ownerCt.enable();
+      
+      // provide the callback to that widget that was loading the child, passing the child itself
+      if (this.callbackHash[params.id]) {
+        this.callbackHash[params.id].call(params.scope || this, this.getChildWidget(params.id));
+        delete this.callbackHash[params.id];
+      }
+    }
+  },
+  
+  /*
+  Returns the parent widget
+  */
+  getParent: 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();
+    var parentId = idSplit.join("__");
+    
+    return parentId === "" ? null : Ext.getCmp(parentId);
+  },
+  
+  /*
+  Reloads current widget (calls the parent to reload it as its aggregatee)
+  */
+  reload : function(){
+    var parent = this.getParent();
+    if (parent) {
+      parent.loadAggregatee({id:this.localId(parent), container:this.ownerCt.id});
+    } else {
+      window.location.reload();
+    }
+  },
+  
+  /*
+  Gets id in the context of provided parent. 
+  For example, the widgets "properties", being a child of "books" has global id "books__properties", 
+  which *is* its widegt's real id. This methods, with the instance of "books" passed as parameter, 
+  returns "properties".
+  */
+  localId : function(parent){
+    return this.id.replace(parent.id + "__", "");
+  },
+  
+  /*
+  Instantiates and inserts a widget into a container with layout 'fit'.
+  Arg: an JS object with the following keys:
+    - id: id of the receiving container
+    - config: configuration of the widget to be instantiated and inserted into the container
+  */
+  renderWidgetInContainer : function(params){
+    var cont = Ext.getCmp(params.container);
+    cont.instantiateChild(params.config);
+  },
+  
+  /*
+  Reconfigures the widget
+  */
+  reconfigure: function(config){
+    this.ownerCt.instantiateChild(config)
+  },
+  
+  /*
+  Evaluates CSS
+  */
+  css : function(code){
+    var linkTag = document.createElement('style');
+    linkTag.type = 'text/css';
+    linkTag.innerHTML = code;
+    document.body.appendChild(linkTag);
+  },
+  
+  /*
+  Evaluates JS
+  */
+  js : function(code){
+    eval(code);
+  },
+  
+  /*
+  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 widget can provide any set of commands to its client side.
+  Args:
+    - instructions: array of methods, in the order of execution. 
+      Each item is an object in one of the following 2 formats:
+        1) {method1:args1, method2:args2}, where methodN is a name of a public method of this widget; these methods are called in no particular order
+        2) {widget:widget_id, methods:arrayOfMethods}, used for recursive call to bulkExecute on some child widget
+
+  Example: 
+    - [
+        // the same as this.feedback("Your order is accepted")
+        {feedback: "You order is accepted"}, 
+
+        // the same as this.getChildWidget('users').bulkExecute([{setTitle:'Suprise!'}, {setDisabled:true}])
+        {widget:'users', methods:[{setTitle:'Suprise!'}, {setDisabled:true}] },
+
+        // ... etc:
+        {updateStore:{records:[[1, 'Name1'],[2, 'Name2']], total:10}},
+        {setColums:[{},{}]},
+        {setMenus:[{},{}]},
+        ...
+      ]
+  */
+  bulkExecute : function(instructions){
+    if (Ext.isArray(instructions)) {
+      Ext.each(instructions, function(instruction){ this.bulkExecute(instruction)}, this);
+    } else {
+      for (var instr in instructions) {
+        if (this[instr]) {
+          this[instr].apply(this, [instructions[instr]]);
+        } else {
+          var childWidget = this.getChildWidget(instr);
+          if (childWidget) {
+            childWidget.bulkExecute(instructions[instr]);
+          } else {
+            throw "Unknown method or child widget '" + instr +"' in widget '" + this.id + "'"
+          }
+        }
+      }
+    }
+  },
+  
+  // Get the child widget
+  getChildWidget : function(id){
+    return id === 'parent' ? this.getParent() : Ext.getCmp(this.id+"__"+id);
+  },
+  
+  // Common handler for actions
+  actionHandler : function(action){
+    // If firing corresponding event doesn't return false, call the handler
+    if (this.fireEvent(action.name+'click', action)) {
+      this[(action.fn || action.name)](action);
+    }
+  },
+
+  // Common handler for tools
+  toolActionHandler : function(tool){
+    // If firing corresponding event doesn't return false, call the handler
+    if (this.fireEvent(tool.id+'click')) {
+      this[tool]();
+    }
+  },
+
+  // Does the call to the server and processes the response
+  callServer : function(intp, params, callback, scope){
+    if (!params) params = {};
+    Ext.Ajax.request({
+      params : params,
+      url : this.id + "__" + intp,
+      callback : function(options, success, response){
+        if (success) {
+          // execute commands from server
+          this.bulkExecute(Ext.decode(response.responseText));
+          
+          // provade callback if needed
+          if (typeof callback == 'function') { 
+            if (!scope) scope = this;
+            callback.apply(scope);
+          }
+        }
+      },
+      scope : this
+    });
+  },
+
+  /* Parse the bbar and tbar (both Arrays), replacing the strings with the corresponding methods. For example:
+    replaceStringsWithActions( ['add', {text:'Menu', menu:['edit', 'delete']}] )
+    => [scope.actions['add'], {text:'Menu', menu:[scope.actions['edit'], scope.actions['delete']]}]
+  */
+  normalizeMenuItems: function(arry, scope){
+    var res = []; // new array
+    Ext.each(arry, function(o){
+      if (typeof o === "string") {
+        var camelized = o.camelize(true);
+        if (scope.actions[camelized]){
+          res.push(scope.actions[camelized]);
+        } else {
+          // if there's no action with this name, maybe it's a separator or something
+          res.push(o);
+        }
+      } else if (Netzke.isObject(o)) {
+        // look inside the objects...
+        for (var key in o) {
+          if (Ext.isArray(o[key])) {
+            // ... and recursively process inner arrays found
+            o[key] = this.normalizeMenuItems(o[key], scope);
+          }
+        }
+        res.push(o);
+      }
+    }, this);
+    return res;
+  },
+  
+
+  // Every Netzke widget 
+  commonBeforeConstructor : function(config){
+    this.actions = {};
+
+    // Generate methods for api points
+    if (!config.api) { config.api = []; }
+    config.api.push('load_aggregatee_with_cache'); // all netzke widgets get this API
+    Ext.each(config.api, function(intp){
+      this[intp.camelize(true)] = function(args, callback, scope){ this.callServer(intp, args, callback, scope); }
+    }, this);
+
+    // Create Ext.Actions based on config.actions
+    if (config.actions) {
+      this.testActions = {};
+      for (var name in config.actions) {
+        // Create an event for each action (so that higher-level widgets could interfere)
+        this.addEvents(name+'click');
+
+        // Configure the action
+        var actionConfig = config.actions[name];
+        actionConfig.handler = this.actionHandler.createDelegate(this);
+        actionConfig.name = name;
+        this.actions[name] = new Ext.Action(actionConfig);
+      }
+
+      config.bbar = config.bbar && this.normalizeMenuItems(config.bbar, this);
+      config.tbar = config.tbar && this.normalizeMenuItems(config.tbar, this);
+      config.menu = config.menu && this.normalizeMenuItems(config.menu, this);
+      config.contextMenu = config.contextMenu && this.normalizeMenuItems(config.contextMenu, this);
+      
+      // TODO: need to rethink this action related stuff
+      config.actions = this.actions;
+      
+    }
+
+    // Normalize tools
+    if (config.tools) {
+      var normTools = [];
+      Ext.each(config.tools, function(tool){
+        // Create an event for each action (so that higher-level widgets could interfere)
+        this.addEvents(tool.id+'click');
+
+        var handler = this.toolActionHandler.createDelegate(this, [tool]);
+        normTools.push({id : tool, handler : handler, scope : this});
+      }, this);
+      config.tools = normTools;
+    }
+    
+    // Set title
+    if (!config.title) config.title = config.id.humanize();
+  },
+
+  // At this moment component is fully initializied
+  commonAfterConstructor : function(config){
+    // From everywhere accessible FeedbackGhost
+    this.feedbackGhost = Ext.getCmp('feedback_ghost');
+
+    // Add the menus
+    if (this.initialConfig.menu) {this.addMenu(this.initialConfig.menu, this);}
+
+    // generic events
+    this.addEvents(
+      'widgetload' // fired when a child is dynamically loaded
+    );
+
+    // Cleaning up on destroy
+    this.on('beforedestroy', function(){
+      this.cleanUpMenu();
+    }, this);
+    
+    this.callbackHash = {};
+
+    if (this.afterConstructor) this.afterConstructor(config);
+  },
+
+  feedback:function(msg){
+    if (this.initialConfig && this.initialConfig.quiet) {
+      return false;
+    }
+    
+    if (this.feedbackGhost) {
+      this.feedbackGhost.showFeedback(msg);
+    } else {
+      // there's no application to show the feedback - so, we do it ourselves
+      if (typeof msg == 'string'){
+        alert(msg);
+      } else {
+        var compoundResponse = "";
+        Ext.each(msg, function(m){
           compoundResponse += m.msg + "\n"
-        })
-				if (compoundResponse != "") alert(compoundResponse);
-			}
-		};
-	},
-
-	addMenus:function(menus){
-		if (this.app && !!this.app.hostMenu) {
-			Ext.each(menus, function(menu){this.app.hostMenu(menu, this)}, this)
-		}
-	},
-	
-	onWidgetLoad:Ext.emptyFn // gets overridden
+        });
+        if (compoundResponse != "") {
+          alert(compoundResponse);
+        }
+      }
+    }
+  },
+
+  addMenu : function(menu, owner){
+    if (!owner) {
+      owner = this;
+    }
+    
+    if (!!this.hostMenu) { 
+      this.hostMenu(menu, owner); 
+    } else {
+      if (this.ownerWidget) {
+        this.ownerWidget.addMenu(menu, owner);
+      }
+    }
+  },
+  
+  cleanUpMenu : function(owner){
+    if (!owner) {
+      owner = this;
+    }
+    
+    if (!!this.unhostMenu) { 
+      this.unhostMenu(owner); 
+    } else {
+      if (this.ownerWidget) {
+        this.ownerWidget.cleanUpMenu(owner);
+      }
+    }
+  },
+  
+  onWidgetLoad:Ext.emptyFn // gets overridden
 };
 
-// Make Panel with layout 'fit' capable to dynamically load widgets
-Ext.override(Ext.Panel, {
-	getWidget: function(){
-		return this.items.get(0)
-	},
-	
-	loadWidget: function(url, params){
-		if (!params) params = {}
-		
-		this.remove(this.getWidget()); // first delete previous widget
-		
-		// we will let the server know which components we have cached
-		var cachedComponentNames = [];
-		for (name in Ext.componentCache) {
-			cachedComponentNames.push(name);
-		}
-		
-		this.disable(); // to visually emphasize loading
-		
-		Ext.Ajax.request(
-			{url:url, params:Ext.apply(params, {components_cache:Ext.encode(cachedComponentNames)}), script:false, callback:function(panel, success, response){
-				var response = Ext.decode(response.responseText);
-				if (response['classDefinition']) eval(response['classDefinition']); // evaluate widget's class if it was sent
-
-				response.config.parent = this // we might want to know the parent panel in advance (e.g. to know its size)
-				var instance = new Ext.componentCache[response.config.widgetClassName](response.config)
-				
-				this.add(instance);
-				this.doLayout();
-				this.enable();
-			}, scope:this}
-		)
-		
-	}
-});
+// Netzke extensions for Ext.Container
+Ext.override(Ext.Container, {
+  /** 
+    Get Netzke widget that this Ext.Container is part of (*not* the parent widget, 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).
+  */
+  getOwnerWidget : function(){
+    if (this.initialConfig.isNetzke) {
+      return this;
+    } else {
+      if (this.ownerCt){
+        return this.ownerCt.getOwnerWidget()
+      } else {
+        return null
+      }
+    }
+  },
+  
+  // Get the widget that we are hosting
+  getWidget: function(){
+    return this.items ? this.items.get(0) : null; // need this check in case when the container is not yet rendered, like an inactive tab in the TabPanel
+  },
+  
+  removeChild : function(){
+    this.remove(this.getWidget());
+  },
+
+  instantiateChild : function(config){
+    this.remove(this.getWidget()); // first delete previous widget 
+
+    if (!config) return false; // simply remove current widget if null is passed
+
+    var instance = new Ext.netzke.cache[config.widgetClassName](config);
+    this.add(instance);
+    this.doLayout();
+  }
+});