skozlov-netzke-core 0.1.0.2 → 0.4.1

data/lib/app/controllers/netzke_controller.rb

@@ -1,5 +1,9 @@
 class NetzkeController < ActionController::Base
 
+  def index
+    redirect_to :action => :test_widgets
+  end
+
   # collect javascripts from all plugins that registered it in Netzke::Base.config[:javascripts]
   def netzke
     respond_to do |format|
@@ -9,8 +13,80 @@ class NetzkeController < ActionController::Base
           f = File.new(path)
           res << f.read
         end
+        render :text => res.strip_js_comments
+      }
+      
+      format.css {
+        res = ""
+        Netzke::Base.config[:stylesheets].each do |path|
+          f = File.new(path)
+          res << f.read
+        end
         render :text => res
       }
     end
   end
+  
+  #
+  # Primitive tests to quickly test the widgets
+  #
+  
+  # FormPanel
+  netzke :form_panel, :persistent_config => false, :label_align => "top", :columns => [
+    {:name => 'field_one', :xtype => 'textarea'},
+    {:name => 'field_two', :xtype => 'textarea'}
+  ]
+  
+  # BorderLayoutPanel
+  netzke :border_layout_panel, :regions => {
+    :west => {
+      :widget_class_name => "Panel",
+      :region_config => {:width => 300, :split => true}
+    },
+    :center => {
+      :widget_class_name => "Panel"
+    }
+  }
+  
+  # TabPanel
+  netzke :tab_panel, :items => [{
+    :widget_class_name => "Panel",
+    :ext_config => {
+      :html => "Panel 1",  
+    },
+    :active => true
+  },{
+    :widget_class_name => "Panel",
+    :ext_config => {
+      :html => "Panel 2",  
+    }
+  }]
+  
+  # AccordionPanel
+  netzke :accordion_panel, :items => [{
+    :widget_class_name => "Panel",
+    :ext_config => {
+      :html => "Panel 1",
+    }
+    # :active => true
+  },{
+    :widget_class_name => "Panel",
+    :ext_config => {
+      :html => "Panel 2",  
+    }
+  }]
+  
+  # BasicApp
+  netzke :basic_app
+
+  def test_widgets
+    html = "<h3>Quick primitive widgets tests</h3>"
+    
+    self.class.widget_config_storage.each_key.map(&:to_s).sort.each do |w|
+      html << "<a href='#{w}_test'>#{w.to_s.humanize}</a><br/>\n"
+    end
+    
+    render :text => html
+  end
+
 end

data/lib/app/models/netzke_preference.rb

@@ -1,66 +1,155 @@
+#
+# TODO: would be great to support something like this:
+# NetzkePreference["name"].merge!({:a => 1, :b => 2}) # if NetzkePreference["name"] returns a hash
+# or
+# NetzkePreference["name"] << 2 # if NetzkePreference["name"] returns an array
+# etc
+#
 class NetzkePreference < ActiveRecord::Base
-  CONVERTION_METHODS= {'Fixnum' => 'to_i', 'String' => 'to_s', 'Float' => 'to_f', 'Symbol' => 'to_sym'}
-
-  def self.user=(user)
-    @@user = user
-  end
+  belongs_to :user
+  belongs_to :role
   
-  def self.user
-    @@user ||= nil
-  end
+  ELEMENTARY_CONVERTION_METHODS= {'Fixnum' => 'to_i', 'String' => 'to_s', 'Float' => 'to_f', 'Symbol' => 'to_sym'}
   
-  def self.custom_field=(value)
-    @@custom_field = value
+  def self.widget_name=(value)
+    @@widget_name = value
   end
   
-  def self.custom_field
-    @@custom_field ||= nil
+  def self.widget_name
+    @@widget_name ||= nil
   end
   
   def normalized_value
-    klass = read_attribute(:pref_type)
+    klass      = read_attribute(:pref_type)
     norm_value = read_attribute(:value)
-    if klass.nil?
-      # do not cast
-      r = norm_value
-    elsif klass == 'Boolean'
-      r = norm_value == 'false' ? false : (norm_value == 'true' || norm_value)
-    elsif klass == 'NilClass'
-      r = nil
-    elsif klass == 'Array'
-      r = JSON.parse(norm_value)
+    
+    case klass
+    when nil             then r = norm_value  # do not cast
+    when 'Boolean'       then r = norm_value == 'false' ? false : (norm_value == 'true' || norm_value)
+    when 'NilClass'      then r = nil
+    when 'Array', 'Hash' then r = ActiveSupport::JSON.decode(norm_value)
     else
-      r = norm_value.send(CONVERTION_METHODS[klass])
+      r = norm_value.send(ELEMENTARY_CONVERTION_METHODS[klass])
     end
     r
   end
   
   def normalized_value=(new_value)
-    # norm_value = (new_value.to_s if new_value == true or new_value == false) || new_value
-    case new_value.class.to_s
-    when "Array"
-      write_attribute(:value, new_value.to_json)
-    else
-      write_attribute(:value, new_value.to_s)
+    case new_value.class.name
+    when "Array" then write_attribute(:value, new_value.to_json)
+    when "Hash"  then write_attribute(:value, new_value.to_json)
+    else              write_attribute(:value, new_value.to_s)
     end
     write_attribute(:pref_type, [TrueClass, FalseClass].include?(new_value.class) ? 'Boolean' : new_value.class.to_s)
   end
   
   def self.[](pref_name)
-    pref_name = pref_name.to_s
-    conditions = {:name => pref_name, :user_id => self.user, :custom_field => self.custom_field}
-    pref = self.find(:first, :conditions => conditions)
-    # pref = @@user.nil? ? self.find_by_name(pref_name) : self.find_by_name_and_user_id(pref_name, @@user.id)
+    pref_name  = normalize_preference_name(pref_name)
+    pref       = self.pref_to_read(pref_name)
     pref && pref.normalized_value
   end
   
   def self.[]=(pref_name, new_value)
-    pref_name = pref_name.to_s
-    conditions = {:name => pref_name, :user_id => self.user, :custom_field => self.custom_field}
-    pref = self.find(:first, :conditions => conditions) || self.create(conditions)
-    # pref = self.user.nil? ? self.find_or_create_by_name(pref_name) : self.find_or_create_by_name_and_user_id(pref_name, self.user.id)
-    pref.normalized_value = new_value
-    pref.save!
+    pref_name  = normalize_preference_name(pref_name)
+    pref       = self.pref_to_write(pref_name)
+    
+    # if assigning nil, simply delete the eventually found preference
+    if new_value.nil?
+      pref && pref.destroy
+    else
+      # pref ||= self.new(conditions(pref_name))
+      pref.normalized_value = new_value
+      pref.save!
+    end
+  end
+
+  # Overwrite pref_to_read, pref_to_write methods, and find_all_for_widget if you want a different way of 
+  # identifying the proper preference based on your own authorization strategy.
+  #
+  # The default strategy is:
+  #   1) if no masq_user or masq_role defined
+  #     pref_to_read will search for the preference for user first, then for user's role
+  #     pref_to_write will always find or create a preference for the current user (never for its role)
+  #   2) if masq_user or masq_role is defined
+  #     pref_to_read and pref_to_write will always take the masquerade into account, e.g. reads/writes will go to
+  #     the user/role specified
+  #   
+  def self.pref_to_read(name)
+    name = name.to_s
+    session = Netzke::Base.session
+    cond = {:name => name, :widget_name => self.widget_name}
+    
+    if session[:masq_user]
+      # first, get the prefs for this user it they exist
+      res = self.find(:first, :conditions => cond.merge({:user_id => session[:masq_user]}))
+      # if it doesn't exist, get them for the user's role
+      user = User.find(session[:masq_user])
+      res ||= self.find(:first, :conditions => cond.merge({:role_id => user.role.id}))
+    elsif session[:masq_role]
+      res = self.find(:first, :conditions => cond.merge({:role_id => session[:masq_role]}))
+    elsif session[:netzke_user_id]
+      user = User.find(session[:netzke_user_id])
+      res = self.find(:first, :conditions => cond.merge({:user_id => user.id}))
+      res ||= self.find(:first, :conditions => cond.merge({:role_id => user.role.id}))
+    else
+      res = self.find(:first, :conditions => cond)
+    end
+    
+    res      
+  end
+  
+  def self.pref_to_write(name)
+    name = name.to_s
+    session = Netzke::Base.session
+    cond = {:name => name, :widget_name => self.widget_name}
+    
+    if session[:masq_user]
+      cond.merge!({:user_id => session[:masq_user]})
+      res = self.find(:first, :conditions => cond)
+      res ||= self.new(cond)
+    elsif session[:masq_role]
+      # first, delete all the corresponding preferences for the users that have this role
+      Role.find(session[:masq_role]).users.each do |u|
+        self.delete_all(cond.merge({:user_id => u.id}))
+      end
+      cond.merge!({:role_id => session[:masq_role]})
+      res = self.find(:first, :conditions => cond)
+      res ||= self.new(cond)
+    elsif session[:netzke_user_id]
+      res = self.find(:first, :conditions => cond.merge({:user_id => session[:netzke_user_id]}))
+      res ||= self.new(cond.merge({:user_id => session[:netzke_user_id]}))
+    else
+      res = self.find(:first, :conditions => cond)
+      res ||= self.new(cond)
+    end
+    res
+  end
+  
+  def self.find_all_for_widget(name)
+    session = Netzke::Base.session
+    cond = {:widget_name => name}
+    
+    if session[:masq_user] || session[:masq_role]
+      cond.merge!({:user_id => session[:masq_user], :role_id => session[:masq_role]})
+      res = self.find(:all, :conditions => cond)
+    elsif session[:netzke_user_id]
+      user = User.find(session[:netzke_user_id])
+      res = self.find(:all, :conditions => cond.merge({:user_id => session[:netzke_user_id]}))
+      res += self.find(:all, :conditions => cond.merge({:role_id => user.role.try(:id)}))
+    else
+      res = self.find(:all, :conditions => cond)
+    end
+    
+    res      
+  end
+  
+  def self.delete_all_for_widget(name)
+    self.destroy(find_all_for_widget(name))
+  end
+  
+  private
+  def self.normalize_preference_name(name)
+    name.to_s.gsub(".", "__").gsub("/", "__")
   end
   
 end

data/lib/netzke-core.rb

@@ -1,13 +1,16 @@
+require 'active_support'
+
 # NetzkeCore
-require 'netzke/js_class_builder'
 require 'netzke/base'
-require 'netzke/core_ext'
-require 'netzke/controller_extensions'
 
-# Vendor
-require 'vendor/facets/hash/recursive_merge'
+require 'netzke/action_view_ext'
+require 'netzke/controller_extensions'
+require 'netzke/core_ext'
+require 'netzke/routing'
 
+require 'netzke/feedback_ghost'
 
+# Load models and controllers from lib/app
 %w{ models controllers }.each do |dir|
   path = File.join(File.dirname(__FILE__), 'app', dir)
   $LOAD_PATH << path
@@ -15,12 +18,23 @@ require 'vendor/facets/hash/recursive_merge'
   ActiveSupport::Dependencies.load_once_paths.delete(path)
 end
 
-ActionController::Base.class_eval do
-  include Netzke::ControllerExtensions
+if defined? ActionController
+  ActionController::Base.class_eval do
+    include Netzke::ControllerExtensions
+  end
+
+  # Include the route to the Netzke controller
+  ActionController::Routing::RouteSet::Mapper.send :include, Netzke::Routing::MapperExtensions
 end
 
-# Make this plugin reloadable for easier development
+if defined? ActionView
+  ActionView::Base.send :include, Netzke::ActionViewExt
+end  
+
+# Make this plugin auto-reloadable for easier development
 ActiveSupport::Dependencies.load_once_paths.delete(File.join(File.dirname(__FILE__)))
 
-# Include the javascript
+# Include javascript & styles required by all Netzke widgets. 
+# These files will get loaded at the initial load of the framework (along with Ext).
 Netzke::Base.config[:javascripts] << "#{File.dirname(__FILE__)}/../javascripts/core.js"
+Netzke::Base.config[:stylesheets] << "#{File.dirname(__FILE__)}/../stylesheets/core.css"

data/lib/netzke/action_view_ext.rb

@@ -0,0 +1,26 @@
+module Netzke
+  module ActionViewExt
+
+    def netzke_js_include
+      res = ""
+
+      if ENV['RAILS_ENV'] == 'development'
+        res << javascript_include_tag("/extjs/adapter/ext/ext-base.js", "/extjs/ext-all-debug.js")
+      else
+        res << javascript_include_tag("/extjs/adapter/ext/ext-base.js", "/extjs/ext-all.js")
+      end
+      res << javascript_tag( "Ext.authenticityToken = '#{form_authenticity_token}'") # forgery protection
+      res << javascript_include_tag("/netzke/netzke.js")
+      
+      res
+    end
+
+    def netzke_css_include(theme_name = :default)
+      res = stylesheet_link_tag("/extjs/resources/css/ext-all.css")
+      res << stylesheet_link_tag("/extjs/resources/css/xtheme-#{theme_name}.css") unless theme_name == :default
+      res << stylesheet_link_tag("/netzke/netzke.css") # CSS from Netzke
+      res
+    end
+  end
+end
+

data/lib/netzke/base.rb

@@ -1,100 +1,362 @@
-require 'json'
+require 'netzke/base_js'
+
 module Netzke
+  # = Base
+  # Base class for every Netzke widget
+  #
+  # To instantiate a widget in the controller:
+  #
+  #     netzke :widget_name, configuration_hash
+  # 
+  # == Configuration
+  # * <tt>:widget_class_name</tt> - name of the widget class in the scope of the Netzke module, e.g. "FormPanel".
+  # When a widget is defined in the controller and this option is omitted, widget class is deferred from the widget's
+  # name. E.g.:
+  # 
+  #   netzke :grid_panel, :data_class_name => "User"
+  # 
+  # In this case <tt>:widget_class_name</tt> is assumed to be "GridPanel"
+  # 
+  # * <tt>:ext_config</tt> - a config hash that is used to create a javascript instance of the widget. Every
+  # configuration that comes here will be available inside the javascript instance of the widget. 
+  # * <tt>:persistent_config</tt> - if set to <tt>true</tt>, the widget will use persistent storage to store its state;
+  # for instance, Netzke::GridPanel stores there its columns state (width, visibility, order, headers, etc).
+  # A widget may or may not provide interface to its persistent settings. GridPanel and FormPanel from netzke-basepack
+  # are examples of widgets that by default do.
+  # 
+  # Examples of configuration:
+  #
+  #     netzke :books, 
+  #       :widget_class_name => "GridPanel", 
+  #       :data_class_name => "Book", # GridPanel specific option
+  #       :ext_config => {
+  #         :icon_cls => 'icon-grid', 
+  #         :title => "My books"
+  #       }
+  # 
+  #     netzke :form_panel, 
+  #       :data_class_name => "User" # FormPanel specific option
   class Base
-    # Global Netzke configuration
-    def self.config
-      @@config ||= {
-        :javascripts => ["#{File.dirname(__FILE__)}/../../javascripts/core.js"] # locations of javascript files (which automatically will be collected into one file and sent as netzke.js)
-      }
-    end
-    
-    # Helper class to read/write from/to widget's persistent preferences. TODO: rework it.
-    class Config
-      def initialize(widget_name)
-        @widget_name = widget_name
+    include Netzke::BaseJs # javascript (client-side)
+
+    module ClassMethods
+      # Class-level Netzke::Base configuration. The defaults also get specified here.
+      def config
+        set_default_config({
+          # which javascripts and stylesheets must get included at the initial load (see netzke-core.rb)
+          :javascripts               => [],
+          :stylesheets               => [],
+          
+          :persistent_config_manager => "NetzkePreference",
+          :ext_location              => defined?(RAILS_ROOT) && "#{RAILS_ROOT}/public/extjs",
+          :default_config => {
+            :persistent_config => true,
+            :ext_config => {}
+          }
+        })
       end
-      def []=(k,v)
-        NetzkePreference.custom_field = @widget_name
-        NetzkePreference[k] = v
+
+      def configure(*args)
+        if args.first.is_a?(Symbol)
+          # first arg is a Symbol
+          config[args.first] = args.last
+        else
+          config.deep_merge!(args.first)
+        end
+
+        enforce_config_consistency
       end
-      def [](k)
-        NetzkePreference.custom_field = @widget_name
-        NetzkePreference[k]
+      
+      def enforce_config_consistency; end
+
+      # "Netzke::SomeWidget" => "SomeWidget"
+      def short_widget_class_name
+        self.name.split("::").last
       end
-    end
-  
-    # client-side code (generates JS-classes of the widgets)
-    include Netzke::JsClassBuilder
 
-    attr_accessor :config, :server_confg, :parent, :logger, :id_name, :permissions
-    attr_reader :pref
+      # Multi-user support (deprecated in favor of controller sessions)
+      def user
+        @@user ||= nil
+      end
 
-    def initialize(config = {}, parent = nil)
-      @logger = Logger.new("debug.log")
-      @config = initial_config.recursive_merge(config)
-      @parent = parent
-      @id_name = parent.nil? ? config[:name].to_s : "#{parent.id_name}__#{config[:name]}"
+      def user=(user)
+        @@user = user
+      end
+
+      # Access to controller sessions
+      def session
+        @@session ||= {}
+      end
+
+      def session=(s)
+        @@session = s
+      end
+
+      # called by controller at the moment of successfull login
+      def login
+        session[:_netzke_next_request_is_first_after_login] = true
+      end
       
-      @flash = []
-      @pref = Config.new(@id_name)
+      # called by controller at the moment of logout
+      def logout
+        session[:_netzke_next_request_is_first_after_logout] = true
+      end
+
+      # Use this class method to declare connection points between client side of a widget and its server side. 
+      # A method in a widget class with the same name will be (magically) called by the client side of the widget. 
+      # See netzke-basepack's GridPanel for an example.
+      def api(*api_points)
+        apip = read_inheritable_attribute(:api_points) || []
+        api_points.each{|p| apip << p}
+        write_inheritable_attribute(:api_points, apip)
+
+        # It may be needed later for security
+        api_points.each do |apip|
+          module_eval <<-END, __FILE__, __LINE__
+          def api_#{apip}(*args)
+            #{apip}(*args).to_nifty_json
+          end
+          # FIXME: commented out because otherwise ColumnOperations stop working
+          # def #{apip}(*args)
+          #   flash :warning => "API point '#{apip}' is not implemented for widget '#{short_widget_class_name}'"
+          #   {:flash => @flash}
+          # end
+          END
+        end
+      end
+
+      def api_points
+        read_inheritable_attribute(:api_points)
+      end
       
-      @config[:ext_config] ||= {} # configuration used to instantiate JS class
+      # returns an instance of a widget defined in the config
+      def instance_by_config(config)
+        widget_class = "Netzke::#{config[:widget_class_name]}".constantize
+        widget_class.new(config)
+      end
+      
+      # persistent_config and layout manager classes
+      def persistent_config_manager_class
+        Netzke::Base.config[:persistent_config_manager].try(:constantize)
+      rescue NameError
+        nil
+      end
+
+      # Return persistent config class
+      def persistent_config
+        # if the class is not present, fake it (it will not store anything, and always return nil)
+        if persistent_config_manager_class.nil?
+          {}
+        else
+          persistent_config_manager_class
+        end
+      end
+      
+      private
+      def set_default_config(c)
+        @@config ||= {}
+        @@config[self.name] ||= c
+      end
       
-      process_permissions_config
     end
+    extend ClassMethods
     
-    def initial_config
-      {}
+    attr_accessor :parent, :name, :id_name, :permissions, :session
+
+    api :load_aggregatee_with_cache # every widget gets this api
+
+    # Widget initialization process
+    # * the config hash is available to the widget after the "super" call in the initializer
+    # * override/add new default configuration options into the "default_config" method 
+    # (the config hash is not yet available)
+    def initialize(config = {}, parent = nil)
+      @session       = Netzke::Base.session
+      @passed_config = config # configuration passed at the moment of instantiation
+      @parent        = parent
+      @name          = config[:name].nil? ? short_widget_class_name.underscore : config[:name].to_s
+      @id_name       = parent.nil? ? @name : "#{parent.id_name}__#{@name}"
+      @flash         = []
     end
 
-    # 'Netzke::Grid' => 'Grid'
-    def short_widget_class_name
-      self.class.short_widget_class_name
+    # add flatten method to Hash
+    Hash.class_eval do 
+      def flatten(preffix = "")
+        res = []
+        self.each_pair do |k,v|
+          if v.is_a?(Hash)
+            res += v.flatten(k)
+          else
+            res << {
+              :name => ((preffix.to_s.empty? ? "" : preffix.to_s + "__") + k.to_s).to_sym, 
+              :value => v,
+              :type => (["TrueClass", "FalseClass"].include?(v.class.name) ? 'Boolean' : v.class.name).to_sym
+            }
+          end
+        end
+        res
+      end
+    end
+
+    def default_config
+      self.class.config[:default_config].nil? ? {} : {}.merge!(self.class.config[:default_config])
+    end
+
+    # Access to the config that takes into account all possible ways to configure a widget. *Read only*.
+    def config
+      # Translates into something like this:
+      #     @config ||= default_config.
+      #                 deep_merge(@passed_config).
+      #                 deep_merge(persistent_config_hash).
+      #                 deep_merge(strong_parent_config).
+      #                 deep_merge(strong_session_config)
+      @config ||= independent_config.
+                    deep_merge(strong_parent_config).
+                    deep_merge(strong_session_config)
+                    
+    end
+    
+    def flat_config(key = nil)
+      fc = config.flatten
+      key.nil? ? fc : fc.select{ |c| c[:name] == key.to_sym }.first.try(:value)
+    end
+
+    def strong_parent_config
+      @strong_parent_config ||= parent.nil? ? {} : parent.strong_children_config
+    end
+
+    # Config that is not overwritten by parents and sessions
+    def independent_config
+      @independent_config ||= initial_config.deep_merge(persistent_config_hash)
+    end
+
+    def flat_independent_config(key = nil)
+      fc = independent_config.flatten
+      key.nil? ? fc : fc.select{ |c| c[:name] == key.to_sym }.first.try(:value)
     end
     
-    def self.short_widget_class_name
-      name.split("::").last
+    def flat_default_config(key = nil)
+      fc = default_config.flatten
+      key.nil? ? fc : fc.select{ |c| c[:name] == key.to_sym }.first.try(:value)
+    end
+
+    # Static, hardcoded config. Consists of default values merged with config that was passed during instantiation
+    def initial_config
+      @initial_config ||= default_config.deep_merge(@passed_config)
     end
     
-    #
-    # Use this class-method to declare connection points between client side of a widget and its server side. A method in a widget class with the same name will be (magically) called by the client-side of the widget. See Grid widget for an example
-    #
-    def self.interface(*interface_points)
-      interfacep = read_inheritable_attribute(:interface_points) || []
-      interface_points.each{|p| interfacep << p}
-      write_inheritable_attribute(:interface_points, interfacep)
+    def flat_initial_config(key = nil)
+      fc = initial_config.flatten
+      key.nil? ? fc : fc.select{ |c| c[:name] == key.to_sym }.first.try(:value)
+    end
+
+    def build_persistent_config_hash
+      return {} if !initial_config[:persistent_config]
       
-      interface_points.each do |interfacep|
-        module_eval <<-END, __FILE__, __LINE__
-        def interface_#{interfacep}(*args)
-          #{interfacep}(*args).to_js
+      prefs = NetzkePreference.find_all_for_widget(id_name)
+      res = {}
+      prefs.each do |p|
+        hsh_levels = p.name.split("__").map(&:to_sym)
+        tmp_res = {} # it decends into itself, building itself
+        anchor = {} # it will keep the tail of tmp_res
+        hsh_levels.each do |level_prefix|
+          tmp_res[level_prefix] ||= level_prefix == hsh_levels.last ? p.normalized_value : {}
+          anchor = tmp_res[level_prefix] if level_prefix == hsh_levels.first
+          tmp_res = tmp_res[level_prefix]
         end
-        # FIXME: commented out because otherwise ColumnOperations stop working
-        # def #{interfacep}(*args)
-        #   flash :warning => "API point '#{interfacep}' is not implemented for widget '#{short_widget_class_name}'"
-        #   {:flash => @flash}
-        # end
-        END
+        # Now 'anchor' is a hash that represents the path to the single value, 
+        # for example: {:ext_config => {:title => 100}} (which corresponds to ext_config__title)
+        # So we need to recursively merge it into the final result
+        res.deep_merge!(hsh_levels.first => anchor)
       end
+      res
+    end
+
+    def persistent_config_hash
+      @persistent_config_hash ||= build_persistent_config_hash
+    end
+
+    def ext_config
+      config[:ext_config] || {}
     end
     
-    def self.interface_points
-      read_inheritable_attribute(:interface_points)
+    # Like normal config, but stored in session
+    def weak_session_config
+      widget_session[:weak_session_config] ||= {}
     end
+
+    def strong_session_config
+      widget_session[:strong_session_config] ||= {}
+    end
+
+    # configuration of all children will get deep_merge'd with strong_children_config
+    # def strong_children_config= (c)
+    #   @strong_children_config = c
+    # end
+
+    # This config will be picked up by all the descendants
+    def strong_children_config
+      @strong_children_config ||= parent.nil? ? {} : parent.strong_children_config
+    end
+    
+    # configuration of all children will get reverse_deep_merge'd with weak_children_config
+    # def weak_children_config= (c)
+    #   @weak_children_config = c
+    # end
     
-    def interface_points
-      self.class.interface_points
+    def weak_children_config
+      @weak_children_config ||= {}
+    end
+    
+    def widget_session
+      session[id_name] ||= {}
     end
 
-    interface :get_widget # default
+    # Rails' logger
+    def logger
+      Rails.logger
+    end
 
+    def dependency_classes
+      res = []
+      non_late_aggregatees.keys.each do |aggr|
+        res += aggregatee_instance(aggr).dependency_classes
+      end
+      res << short_widget_class_name
+      res.uniq
+    end
+    
+    # Store some setting in the database as if it was a hash, e.g.:
+    #     persistent_config["window.size"] = 100
+    #     persistent_config["window.size"] => 100
+    # This method is user-aware
+    def persistent_config
+      if config[:persistent_config]
+        config_class = self.class.persistent_config
+        config_class.widget_name = id_name # pass to the config class our unique name
+        config_class
+      else
+        # if we can't use presistent config, all the calls to it will always return nil, and the "="-operation will be ignored
+        logger.debug "==> NETZKE: no persistent config is set up for widget '#{id_name}'"
+        {}
+      end
+    end
+    
+    # 'Netzke::Grid' => 'Grid'
+    def short_widget_class_name
+      self.class.short_widget_class_name
+    end
+    
     ## Dependencies
     def dependencies
-      @dependencies ||= initial_dependencies
+      @dependencies ||= begin
+        non_late_aggregatees_widget_classes = non_late_aggregatees.values.map{|v| v[:widget_class_name]}
+        (initial_dependencies + non_late_aggregatees_widget_classes << self.class.short_widget_class_name).uniq
+      end
     end
     
+    # override this method if you need some extra dependencies, which are not the aggregatees
     def initial_dependencies
-      config[:dependencies] || []
+      []
     end
     
     ### Aggregation
@@ -106,11 +368,22 @@ module Netzke
       @aggregatees ||= initial_aggregatees.merge(initial_late_aggregatees.each_pair{|k,v| v.merge!(:late_aggregation => true)})
     end
     
+    def non_late_aggregatees
+      aggregatees.reject{|k,v| v[:late_aggregation]}
+    end
+    
     def add_aggregatee(aggr)
       aggregatees.merge!(aggr)
     end
     
-    # The difference between aggregatees and late aggregatees is the following: the former gets instantiated together with its aggregator and is normally instantly visible as a part of it. While a late aggregatee doesn't get instantiated along with its aggregator. Until it gets requested, it doesn't take any part in its aggregator's lifecycle. An example of late aggregatee could be a widget that is loaded by an application widget on user's request, or a preferences window that only gets instantiated when user wants to edit widget's preferences. An example of a normal aggregatee is any widget (like a grid) within a BorderLayout-based widget (i.e. aggregator) - it should get instantiated and shown along with its aggregator.
+    def remove_aggregatee(aggr)
+      if config[:persistent_config]
+        persistent_config_manager_class.delete_all_for_widget("#{id_name}__#{aggr}")
+      end
+      aggregatees[aggr] = nil
+    end
+    
+    # The difference between aggregatees and late aggregatees is the following: the former gets instantiated together with its aggregator and is normally *instantly* visible as a part of it (for example, the widget in the initially expanded panel in an Accordion). A late aggregatee doesn't get instantiated along with its aggregator. Until it gets requested from the server, it doesn't take any part in its aggregator's life. An example of late aggregatee could be a widget that is loaded dynamically into a previously collapsed panel of an Accordion, or a preferences window (late aggregatee) for a widget (aggregator) that only gets shown when user wants to edit widget's preferences.
     def initial_late_aggregatees
       {}
     end
@@ -120,19 +393,28 @@ module Netzke
     end
 
     # recursively instantiates an aggregatee based on its "path": e.g. if we have an aggregatee :aggr1 which in its turn has an aggregatee :aggr10, the path to the latter would be "aggr1__aggr10"
-    def aggregatee_instance(name)
+    def aggregatee_instance(name, strong_config = {})
       aggregator = self
       name.to_s.split('__').each do |aggr|
         aggr = aggr.to_sym
-        # TODO: should we put all the classes under Netzke::-scope?
-        # widget_class = full_widget_class_name(aggregator.aggregatees[aggr][:widget_class_name]).constantize
-        widget_class = "Netzke::#{aggregator.aggregatees[aggr][:widget_class_name]}".constantize
-        aggregator = widget_class.new(aggregator.aggregatees[aggr].merge(:name => aggr), aggregator)
+        aggregatee_config = aggregator.aggregatees[aggr]
+        raise ArgumentError, "No aggregatee '#{aggr}' defined for widget '#{aggregator.id_name}'" if aggregatee_config.nil?
+        short_class_name = aggregatee_config[:widget_class_name]
+        raise ArgumentError, "No widget_class_name specified for aggregatee #{aggr} of #{aggregator.id_name}" if short_class_name.nil?
+        widget_class = "Netzke::#{short_class_name}".constantize
+
+        conf = weak_children_config.
+          deep_merge(aggregatee_config).
+          deep_merge(strong_config). # we may want to reconfigure the aggregatee at the moment of instantiation
+          merge(:name => aggr)
+
+        aggregator = widget_class.new(conf, aggregator) # params: config, parent
+        # aggregator.weak_children_config = weak_children_config
+        # aggregator.strong_children_config = strong_children_config
       end
       aggregator
     end
     
-    
     def full_widget_class_name(short_name)
       "Netzke::#{short_name}"
     end
@@ -148,51 +430,107 @@ module Netzke
     end
 
     # permissions
-    def available_permissions
-      []
+    # def available_permissions
+    #   []
+    # end
+
+    # def process_permissions_config
+    #   if !available_permissions.empty?
+    #     # First, process permissions from the config
+    #     @permissions = available_permissions.inject({}){|h,p| h.merge(p.to_sym => true)} # by default anything is allowed
+    # 
+    #     config[:prohibit] = available_permissions if config[:prohibit] == :all # short-cut for all permissions
+    #     config[:prohibit] = [config[:prohibit]] if config[:prohibit].is_a?(Symbol) # so that config[:prohibit] => :write works
+    #     config[:prohibit] && config[:prohibit].each{|p| @permissions.merge!(p.to_sym => false)} # prohibit
+    # 
+    #     config[:allow] = [config[:allow]] if config[:allow].is_a?(Symbol) # so that config[:allow] => :write works
+    #     config[:allow] && config[:allow].each{|p| @permissions.merge!(p.to_sym => true)} # allow
+    #     
+    #     # ... and then merge it with NetzkePreferences
+    #     available_permissions.each do |p|
+    #       # if nothing is stored in persistent_config, store the permission from the config; otherwise leave what's there
+    #       persistent_config["permissions/#{p}"].nil? && persistent_config["permissions/#{p}"] = @permissions[p.to_sym]
+    # 
+    #       # what's stored in persistent_config has higher priority, so, if there's something there, use that
+    #       persistent_permisson = persistent_config["permissions/#{p}"]
+    #       @permissions[p.to_sym] = persistent_permisson unless persistent_permisson.nil?
+    #     end
+    #   end
+    # end
+
+    # called when the method_missing tries to processes a non-existing aggregatee
+    def aggregatee_missing(aggr)
+      flash :error => "Unknown aggregatee #{aggr} for widget #{name}"
+      {:feedback => @flash}.to_nifty_json
+    end
+
+    def tools
+      persistent_config[:tools] ||= config[:tools] || []
     end
 
-    def process_permissions_config
-      if !available_permissions.empty?
-        # First, process permissions from the config
-        @permissions = available_permissions.inject({}){|h,p| h.merge(p.to_sym => true)} # by default anything is allowed
+    def menu
+      persistent_config[:menu] ||= config[:menu] == false ? nil : config[:menu]
+    end
+    
+    # some convenience for instances
+    def persistent_config_manager_class
+      self.class.persistent_config_manager_class
+    end
 
-        config[:prohibit] = available_permissions if config[:prohibit] == :all # short-cut for all permissions
-        config[:prohibit] = [config[:prohibit]] if config[:prohibit].is_a?(Symbol) # so that config[:prohibit] => :write works
-        config[:prohibit] && config[:prohibit].each{|p| @permissions.merge!(p.to_sym => false)} # prohibit
+    # override this method to do stuff at the moment of loading by some parent
+    def before_load
+      widget_session.clear
+    end
 
-        config[:allow] = [config[:allow]] if config[:allow].is_a?(Symbol) # so that config[:allow] => :write works
-        config[:allow] && config[:allow].each{|p| @permissions.merge!(p.to_sym => true)} # allow
-        
-        # ... and then merge it with NetzkePreferences
-        available_permissions.each do |p|
-          @permissions[p.to_sym] = @pref["permissions.#{p}"] if !@pref["permissions.#{p}"].nil?
-        end
-      end
+    # API
+    def load_aggregatee_with_cache(params)
+      cache = ActiveSupport::JSON.decode(params.delete(:cache))
+      relative_widget_id = params.delete(:id).underscore
+      passed_config = params[:config] && ActiveSupport::JSON.decode(params[:config]) || {}
+      passed_config = passed_config.symbolize_keys
+      widget = aggregatee_instance(relative_widget_id, passed_config)
+      
+      # inform the widget that it's being loaded
+      widget.before_load
+      
+      [{
+        :js => widget.js_missing_code(cache), 
+        :css => css_missing_code(cache)
+      }, {
+        :render_widget_in_container => {
+          :container => params[:container], 
+          :config => widget.js_config
+        }
+      }, {
+        :widget_loaded => {
+          :id => relative_widget_id
+        }
+      }]
     end
 
-    ## method dispatcher - sends method to the proper aggregatee
+    # Method dispatcher - instantiates an aggregatee and calls the method on it
+    # E.g.: 
+    #   users__center__get_data
+    #     instantiates aggregatee "users", and calls "center__get_data" on it
+    #   books__move_column
+    #     instantiates aggregatee "books", and calls "api_move_column" on it
     def method_missing(method_name, params = {})
       widget, *action = method_name.to_s.split('__')
       widget = widget.to_sym
       action = !action.empty? && action.join("__").to_sym
       
-      if action && aggregatees[widget]
-        # only actions starting with "interface_" are accessible
-        interface_action = action.to_s.index('__') ? action : "interface_#{action}"
-        aggregatee_instance(widget).send(interface_action, params)
+      if action
+        if aggregatees[widget]
+          # only actions starting with "api_" are accessible
+          api_action = action.to_s.index('__') ? action : "api_#{action}"
+          aggregatee_instance(widget).send(api_action, params)
+        else
+          aggregatee_missing(widget)
+        end
       else
         super
       end
     end
-
-    #### API section
-    def get_widget(params = {})
-      # if browser does not have our component class cached (and all dependencies), send it to him
-      components_cache = (JSON.parse(params[:components_cache]) if params[:components_cache]) || []
-      
-      {:config => js_config, :class_definition => js_missing_code(components_cache)}
-    end
-   
+    
   end
 end