netzke-basepack 0.4.2 → 0.5.1

data/lib/netzke/border_layout_panel.rb

@@ -1,97 +1,103 @@
 module Netzke
+  # Represents the Ext.Panel with layout 'border'. May serve as parent class for compound widgets.
+  # 
+  # == Features:
+  # * Responds to region resizing, storing the sizes in persistent config
+  # 
+  # == Future features:
+  # * Stores expand/collapse state in the persistent config
+  # 
+  # == Non-functional features:
+  # * (JavaScript) Creates convinient methods to access aggregatees inside the regions, like
+  # <tt>getCenterWidget()</tt>, <tt>getWestWidget()</tt>, etc
+  # 
+  # == Configuration:
+  # <tt>:regions</tt> - a hash in form:
+  #       
+  #     {:center => {<netzke widget config>}, :east => {<another netzke widget config>}, ...}
+  # 
+  # <tt>:regions => :center/:west/:etc => :region_config</tt> - configuration options for
+  # Ext.layout.BorderLayout.SplitRegion.
+  #     
+  # == Example configuration:
+  # 
+  #     :regions => {
+  #       :center => {:widget_class_name => "Panel", :ext_config => {:html => "A panel"}}, 
+  #       :west => {
+  #         :widget_class_name => "GridPanel", 
+  #         :data_class_name => "User", 
+  #         :region_config => {
+  #           :width => 100,
+  #           :split => true
+  #         }
+  #       }
+  #     }
   class BorderLayoutPanel < Base
-    interface :resize_region
-    
     REGIONS = %w(center west east south north).map(&:to_sym)
 
-    #
-    # JS-class generation
-    #
-    module ClassMethods
-      def js_listeners
-        {
-          :afterlayout => {:fn => "this.setResizeEvents".l, :scope => this}
-        }
-      end
-
-      def js_before_constructor
-        <<-JS.l
-          var items = [];
-          Ext.each(['center', 'west', 'east', 'south', 'north'], function(r){
-            var configName = r+'Config';
-            if (config[configName]){
-              var regionConfig = config.regions[r] || {};
-              regionConfig.layout = 'fit';
-              regionConfig.region = r;
-              regionConfig.items = [new Ext.netzke.cache[config[configName].widgetClassName](config[configName])]
-              items.push(regionConfig);
-              
-              // A function to access a region widget (even if the widget gets reloaded, the function will work).
-              // E.g.: getEastWidget()
-              this['get'+r.capitalize()+'Widget'] = function(){
-                return this.find('region', r)[0].getWidget()
-              }.createDelegate(this)
-              
-              
-            };
-          }, this)
-        JS
-      end
-
-      def js_default_config
-        super.merge({
-          :layout => 'border',
-          :items => "items".l
-        })
-      end
-
-      def js_extend_properties
-        {
-          :get_region_widget => <<-JS.l,
-            function(region){
-              return this.find('region', region)[0].getWidget()
-            }
-          JS
-          :set_resize_events => <<-JS.l,
+    # JavaScript part
+    def self.js_extend_properties
+      {
+        :layout => 'border',
+        
+        :init_component => <<-END_OF_JAVASCRIPT.l,
           function(){
-            this.items.each(function(item, index, length){
-              if (!item.oldSize) item.oldSize = item.getSize();
-              if (item.region == 'east' || item.region == 'west') item.on('resize', function(panel, w, h){
-                if (panel.oldSize.width != w) {
-                  Ext.Ajax.request({
-                    url:this.initialConfig.interface.resizeRegion,
-                    params: {region_name: panel.region, new_width:w}
-                  });
-                  panel.oldSize.width = w;
-                }
-                return true;
-              }, this);
-              else if (item.region == 'south' || item.region == 'north') item.on('resize', function(panel, w, h){
-                if (panel.oldSize.height != h) {
-                  Ext.Ajax.request({
-                    url:this.initialConfig.interface.resizeRegion,
-                    params: {region_name: panel.region, new_height:h}
-                  });
-                  panel.oldSize.height = h;
-                }
-                return true;
-              }, this);
+            this.items = [];
+            Ext.each(['center', 'west', 'east', 'south', 'north'], function(r){
+              var configName = r+'Config';
+              if (this[configName]){
+                var regionConfig = this.regions[r] || {};
+                regionConfig.layout = 'fit';
+                regionConfig.region = r;
+                regionConfig.items = [new Ext.netzke.cache[this[configName].widgetClassName](this[configName])]
+                this.items.push(regionConfig);
+
+                // A function to access a region widget (even if the widget gets reloaded, the function will work).
+                // E.g.: getEastWidget()
+                this['get'+r.capitalize()+'Widget'] = function(){
+                  return this.find('region', r)[0].getWidget()
+                }.createDelegate(this);
+              };
             }, this);
-            this.un('afterlayout', this.setResizeEvents, this); // to avoid redefinition of resize events
+            
+            // Now let Ext.Panel do the rest
+            Ext.netzke.cache.BorderLayoutPanel.superclass.initComponent.call(this);
+            
+            // First time on "afterlayout", set resize events
+            this.on('afterlayout', this.setResizeEvents, this, {single: true});
           }
-        JS
-      }
-      end
-    end
-    extend ClassMethods
-    
-    # default instance-level configuration
-    def initial_config
-      {
-        :persistent_config => true
-      }
+        END_OF_JAVASCRIPT
+        
+        :get_region_widget => <<-END_OF_JAVASCRIPT.l,
+          function(region){
+            return this.find('region', region)[0].getWidget();
+          }
+        END_OF_JAVASCRIPT
+        
+        :set_resize_events => <<-END_OF_JAVASCRIPT.l,
+        function(){
+          this.items.each(function(item, index, length){
+            if (!item.oldSize) item.oldSize = item.getSize();
+            if (item.region == 'east' || item.region == 'west') item.on('resize', function(panel, w, h){
+              if (panel.oldSize.width != w) {
+                this.resizeRegion({region_name: panel.region, new_width:w});
+                panel.oldSize.width = w;
+              }
+              return true;
+            }, this);
+            else if (item.region == 'south' || item.region == 'north') item.on('resize', function(panel, w, h){
+              if (panel.oldSize.height != h) {
+                this.resizeRegion({region_name: panel.region, new_height:h});
+                panel.oldSize.height = h;
+              }
+              return true;
+            }, this);
+          }, this);
+        }
+      END_OF_JAVASCRIPT
+    }
     end
-    
+
     def initial_aggregatees
       config[:regions] || {}
     end
@@ -105,25 +111,18 @@ module Netzke
       REGIONS.each do |r|
         if region_aggr = aggregatees[r]
           regions.merge!(r => region_aggr[:region_config] || {})
-          height = persistent_config["#{r}_height"] ||= regions[r][:height] if regions[r][:height]
-          width = persistent_config["#{r}_width"] ||= regions[r][:width] if regions[r][:width]
-          regions[r].merge!(:height => height)
-          regions[r].merge!(:width => width)
         end
       end
       super.merge(:regions => regions)
     end
-  
+
+    # API
+    api :resize_region # handles regions resize
     def resize_region(params)
-      persistent_config["#{params["region_name"]}_width"] = params["new_width"].to_i if params["new_width"]
-      persistent_config["#{params["region_name"]}_height"] = params["new_height"].to_i if params["new_height"]
+      persistent_config["regions__#{params["region_name"]}__region_config__width"] = params["new_width"].to_i if params["new_width"]
+      persistent_config["regions__#{params["region_name"]}__region_config__height"] = params["new_height"].to_i if params["new_height"]
       {}
     end
     
-    protected
-  
-    def extend_functions; ""; end
-    def js_extra_events; ""; end
-    
   end
 end

data/lib/netzke/configuration_panel.rb

@@ -0,0 +1,24 @@
+module Netzke
+  # TabPanel-based widget that wraps-up "configuration widgets" that each widget can define 
+  # (along) with including the Plugins::ConfigurationTool tool.
+  class ConfigurationPanel < TabPanel
+    api :commit
+    def commit(params)
+      commit_data = ActiveSupport::JSON.decode params[:commit_data]
+      commit_data.each_pair do |k,v|
+        aggregatee_instance(k).commit(v)
+      end
+      {:reload_parent => true, :feedback => (@flash.empty? ? nil : @flash)}
+    end
+    
+    def self.js_extend_properties
+      {
+        :reload_parent => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            this.getParent().reload();
+          }
+        END_OF_JAVASCRIPT
+      }
+    end
+  end
+end

data/lib/netzke/data_accessor.rb

@@ -0,0 +1,71 @@
+module Netzke
+  # This module is included into such data-driven widgets as GridPanel, FormPanel, etc. It provides for
+  # flexible pre-configuration of (virtual) attributes.
+  #
+  # TODO: show examples of how to create the helpers
+  module DataAccessor
+    
+    # This method should be called from the constructor of the widget. It dynamically includes:
+    # 1) helpers into the data model for this widget; those may contain instance methods used as virtual attributes
+    # 2) generic (used by all "data accessor" widgets) extensions into the data model for this widget
+    def apply_helpers
+      # Generic extensions to the data model
+      if data_class # because some widgets, like FormPanel, may have it optional
+        data_class.send(:include, Netzke::ActiveRecord::DataAccessor) if !data_class.include?(Netzke::ActiveRecord::DataAccessor)
+      
+        # Model helpers
+        const_name = "Netzke::Helpers::#{data_class.name}"
+        model_extensions = const_name.constantize rescue nil
+        data_class.send(:include, model_extensions) if model_extensions && !data_class.include?(model_extensions)
+      end
+    end
+
+    # Returns columns that are exposed by the class and the helpers
+    def predefined_columns
+      helper_module = "Netzke::Helpers::#{short_widget_class_name}#{data_class.name}".constantize rescue nil
+      
+      data_class_columns = data_class && data_class.column_names.map(&:to_sym) || []
+      
+      if helper_module
+        exposed_attributes = helper_module.respond_to?(:exposed_attributes) ? normalize_array_of_columns(helper_module.exposed_attributes) : nil
+        virtual_attributes = helper_module.respond_to?(:virtual_attributes) ? helper_module.virtual_attributes : []
+        excluded_attributes = helper_module.respond_to?(:excluded_attributes) ? helper_module.excluded_attributes : []
+        attributes_config = helper_module.respond_to?(:attributes_config) ? helper_module.attributes_config : {}
+        
+        res = exposed_attributes || data_class_columns + virtual_attributes
+        
+        res = normalize_columns(res)
+        
+        res.reject!{ |c| excluded_attributes.include? c[:name] }
+
+        res.map!{ |c| c.merge!(attributes_config[c[:name]] || {})}
+      else
+        res = normalize_columns(data_class_columns)
+      end
+      
+      res
+    end
+
+    # Make sure we have keys as symbols, not strings
+    def normalize_array_of_columns(arry)
+      arry.map do |f| 
+        if f.is_a?(Hash)
+          f.symbolize_keys
+        else
+          f.to_sym
+        end
+      end
+    end
+    
+    # From symbol to config hash
+    def normalize_column(field)
+      field.is_a?(Symbol) ? {:name => field} : field
+    end
+    
+    # From symbols to config hashes
+    def normalize_columns(items)
+      items.map{|c| normalize_column(c)}
+    end
+    
+  end
+end

data/lib/netzke/ext.rb

@@ -0,0 +1,6 @@
+module Netzke
+  # Ext-related module. Some constants provide meta-information about the Ext.library.
+  module Ext
+    FORM_FIELD_XTYPES = %w{ textfield numberfield textarea combobox checkbox xdatetime }
+  end
+end

data/lib/netzke/field_model.rb

@@ -1,6 +1,6 @@
 module Netzke
   class FieldModel < Hash
-    include ActiveRecordExtensions
+    include BasepackActiveRecord
     
     def self.new_from_hash(hsh)
       self.new.replace(hsh)

data/lib/netzke/fields_configurator.rb

@@ -1,23 +1,27 @@
 module Netzke
+  # == FieldsConfigurator
+  # Provides dynamic configuring columns/fields for GridPanel and FormPanel.
+  # Configuration parameters:
+  # * <tt>:widget</tt> - widget to configure columns/fields for
   class FieldsConfigurator < GridPanel
-    interface :load_defaults
+    api :load_defaults
 
-    def self.js_base_class
-      GridPanel
-    end
-    
     def initialize(*args)
       super
-
-      NetzkeLayoutItem.widget      = config[:widget].id_name
-      config[:data_class_name]     = "NetzkeLayoutItem"
+      NetzkeAutoColumn.widget = config[:widget]
     end
 
-    def initial_config
-      super.recursive_merge({
+    def default_config
+      super.deep_merge({
         :name              => 'columns',
-        :widget_class_name => "GridPanel",
-        :ext_config        => {:title => false}
+        :data_class_name   => "NetzkeAutoColumn",
+        :ext_config        => {
+          :header => false,
+          :enable_extended_search => false,
+          :enable_edit_in_form => false,
+          :enable_rows_reordering => GridPanel.config[:rows_reordering_available],
+          :enable_pagination => false
+        },
       })
     end
     
@@ -27,44 +31,65 @@ module Netzke
       )
     end
     
-    def bbar
-      super << "-" << "defaults"
+    def independent_config
+      res = super
+      res[:ext_config][:bbar] = %w{ edit apply - defaults }
+      res
     end
-    
+        
+    def predefined_columns
+      [{:name => :id}, *config[:widget].class.config_columns]
+    end
+        
     def self.js_extend_properties
-      super.merge({
-        :defaults => <<-JS.l,
+      {
+        # Disable the 'gear' tool for now
+        :gear => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            this.feedback("You can't configure configurator (yet)");
+          }
+        END_OF_JAVASCRIPT
+        
+        # we need to provide this function so that the server-side commit would happen
+        :get_commit_data => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            return null; // because our commit data is already at the server
+          }
+        END_OF_JAVASCRIPT
+        
+        :defaults => <<-END_OF_JAVASCRIPT.l,
           function(){
             Ext.Msg.confirm('Confirm', 'Are you sure?', function(btn){
               if (btn == 'yes') {
-                Ext.Ajax.request({
-                  url:this.initialConfig.interface.loadDefaults,
-                  callback:function(){
-                    this.store.reload();
-                  },
-                  scope:this
-                })
+                this.loadDefaults();
               }
             }, this);
           }
-        JS
-      })
+        END_OF_JAVASCRIPT
+      }
     end
     
     def load_defaults(params)
-      persistent_config.for_widget(config[:widget].id_name){ |p| p[:layout__columns] = config[:widget].default_db_fields }
-      # NetzkeLayoutItem.data = config[:widget].default_db_fields
+      config[:widget].persistent_config[:layout__columns] = config[:widget].default_columns
+      NetzkeAutoColumn.rebuild_table
+      {:load_store_data => get_data, :reconfigure => js_config}
+    end
+   
+    def commit(params)
+      defaults_hash = config[:widget].class.config_columns.inject({}){ |r, c| r.merge!(c[:name] => c[:default]) }
+      config[:widget].persistent_config[:layout__columns] = NetzkeAutoColumn.all_columns.map do |c| 
+        # reject all keys that are 1) same as defaults, 2) 'position'
+        c.reject!{ |k,v| defaults_hash[k.to_sym].to_s == v.to_s || k == 'position'} 
+        c = c["name"] if c.keys.count == 1 # denormalize the column
+        c
+      end
       {}
     end
-    
-    def default_db_fields_with_widget_change
-      NetzkeLayoutItem.widget = config[:widget].id_name
-      res = default_db_fields_without_widget_change
-      NetzkeLayoutItem.widget = id_name
-      res
+   
+    # each time that we are loaded into the app, rebuild the table
+    def before_load
+      NetzkeAutoColumn.rebuild_table
     end
-    
-    alias_method_chain :default_db_fields, :widget_change
-    
+   
   end
 end