netzke-basepack 0.5.8 → 0.5.9

data/lib/netzke/grid_panel/grid_panel_columns.rb

@@ -0,0 +1,226 @@
+module Netzke
+  class GridPanel < Base
+    module GridPanelColumns
+      module ClassMethods
+        # Columns to be displayed by the FieldConfigurator, "meta-columns". Each corresponds to a configuration
+        # option for each column in the grid.
+        def meta_columns
+          [
+            # Whether the column will be present in the grid, also in :hidden or :meta state. The value for this column will
+            # always be sent to/from the JS grid to the server
+            {:name => "included",      :attr_type => :boolean, :width => 40, :header => "Incl", :default_value => true},
+
+            # The name of the column. May be any accessible method or attribute of the data_class.
+            {:name => "name",          :attr_type => :string, :width => 200},
+
+            # The header for the column.
+            {:name => "label",         :attr_type => :string, :width => 200, :header => "Header"},
+
+            # The default value of this column. Is used when a new row in the grid gets created.
+            {:name => "default_value", :attr_type => :string, :width => 200},
+
+            # Options for drop-downs
+            {:name => "combobox_options",       :attr_type => :string, :editor => "textarea", :width => 200},
+
+            # Whether the column is editable in the grid.
+            {:name => "read_only",     :attr_type => :boolean, :header => "R/O", :tooltip => "Read-only"},
+
+            # Whether the column will be in the hidden state (hide/show columns from the column menu, if it's enabled).
+            {:name => "hidden",        :attr_type => :boolean},
+
+            # Whether the column should have "grid filters" enabled 
+            # (see here: http://www.extjs.com/deploy/dev/examples/grid-filtering/grid-filter-local.html)
+            {:name => "with_filters",  :attr_type => :boolean, :default_value => true, :header => "Filters"},
+
+            #
+            # Below some rarely used parameters, hidden by default (you can always un-hide them from the column menu).
+            #
+
+            # The column's width
+            {:name => "width",         :attr_type => :integer, :hidden => true},
+
+            # Whether the column should be hideable
+            {:name => "hideable",      :attr_type => :boolean, :default_value => true, :hidden => true},
+
+            # Whether the column should be sortable (why change it? normally it's hardcoded)
+            {:name => "sortable",      :attr_type => :boolean, :default_value => true, :hidden => true},
+
+            #
+            # And finally some meta columns that we probably never want to see in the GUI
+            #
+            {:name => "editor",        :attr_type => :string, :meta => true}
+          ]
+        end
+        
+      end
+      
+      module InstanceMethods
+        
+        # Normalized columns for the grid, e.g.:
+        # [{:name => :id, :hidden => true, ...}, {:name => :name, :editable => false, ...}, ...]
+        def columns(only_included = true)
+          @columns ||= begin
+            if cols = load_columns
+              filter_out_excluded_columns(cols) if only_included
+              cols
+            else
+              initial_columns(only_included)
+            end
+          end
+        end
+
+        # Columns that we fall back to when neither persistent columns, nor configured columns are present.
+        # If there's a model-level field configuration, it's being used.
+        # Otherwise the defaults straight from the ActiveRecord model ("netzke_attributes").
+        # Override this method if you want to provide a fix set of columns in your subclass.
+        def default_columns
+          @default_columns ||= load_model_level_attrs || data_class.netzke_attributes
+          # @default_columns ||= load_model_level_attrs || data_class.netzke_attributes
+        end
+        
+        # Columns that represent a smart merge of default_columns and columns passed during the configuration.
+        def initial_columns(only_included = true)
+          # Normalize here, as from the config we can get symbols (names) instead of hashes
+          columns_from_config = config[:columns] && normalize_attr_config(config[:columns])
+
+          if columns_from_config
+            # reverse-merge each column hash from config with each column hash from exposed_attributes (columns from config have higher priority)
+            for c in columns_from_config
+              corresponding_default_column = default_columns.find{ |k| k[:name] == c[:name] }
+              c.reverse_merge!(corresponding_default_column) if corresponding_default_column
+            end
+            columns_for_create = columns_from_config
+          else
+            # we didn't have columns configured in widget's config, so, use the columns from the data class
+            columns_for_create = default_columns
+          end
+          
+          filter_out_excluded_columns(columns_for_create) if only_included
+          
+          # Make the column config complete with the defaults
+          columns_for_create.each do |c|
+            detect_association(c)
+            set_default_header(c)
+            set_default_editor(c)
+            set_default_width(c)
+            set_default_hidden(c)
+            set_default_editable(c)
+            set_default_sortable(c)
+            set_default_filterable(c)
+          end
+
+          columns_for_create
+        end
+        
+      end
+      
+      private
+        def filter_out_excluded_columns(cols)
+          cols.reject!{ |c| c[:included] == false }
+        end
+      
+        # Stores modified columns in persistent storage
+        def save_columns!
+          NetzkeFieldList.update_list_for_current_authority(global_id, columns(false), data_class.name)
+        end
+      
+        def load_columns
+          NetzkeFieldList.read_list(global_id) if persistent_config_enabled?
+        end
+        
+        def load_model_level_attrs
+          NetzkeModelAttrList.read_list(data_class.name)
+        end
+        
+        # whether a column is bound to the primary_key
+        def reflects_primary_key?(c)
+          c[:name] == data_class.primary_key
+        end
+      
+        def set_default_header(c)
+          c[:label] ||= c[:name].humanize
+        end
+        
+        def set_default_editor(c)
+          c[:editor] ||= editor_for_attr_type(c[:attr_type])
+        end
+        
+        def set_default_width(c)
+          c[:width] ||= 50 if c[:attr_type] == :boolean
+          c[:width] ||= 150 if c[:attr_type] == :datetime
+        end
+        
+        def set_default_hidden(c)
+          c[:hidden] = true if reflects_primary_key?(c) && c[:hidden].nil?
+        end
+        
+        def set_default_editable(c)
+          c[:editable] = c[:read_only].nil? ? !(reflects_primary_key?(c) || c[:virtual]) : !c[:read_only]
+          c.delete(:read_only)
+        end
+        
+        def set_default_sortable(c)
+          c[:sortable] = !c[:virtual]
+        end
+        
+        def set_default_filterable(c)
+          c[:filterable] = !c[:virtual]
+        end
+        
+        # Returns editor's xtype for a column type
+        def editor_for_attr_type(type)
+          attr_type_to_editor_map[type]
+        end
+        
+        def editor_for_association
+          :combobox
+        end
+   
+        # Returns a hash that maps a column type to the editor xtype. Override if you want different editors.
+        def attr_type_to_editor_map
+          {
+            :integer => :numberfield,
+            :boolean => :checkbox,
+            :date => :datefield,
+            :datetime => :xdatetime,
+            :text => :textarea,
+            :string => :textfield
+          }
+        end
+      
+        # Detects an association column and sets up the proper editor.
+        # If a column is a foreign key (e.g. "category_id"), also renames the column into "normalized" association column, e.g.:
+        #   category__name
+        # If association doesn't respond to methods "name", "title" or "label", falls back to "id", e.g.:
+        #   category__id
+        def detect_association(c)
+          # named as foreign key of some association?
+          assoc = data_class.reflect_on_all_associations.detect{|a| a.primary_key_name == c[:name]}
+          
+          if assoc && !assoc.options[:polymorphic]
+            assoc_method = %w{name title label id}.detect{|m| (assoc.klass.instance_methods + assoc.klass.column_names).include?(m) } || assoc.klass.primary_key
+            c[:name] = "#{assoc.name}__#{assoc_method}"
+          end
+          
+          # named with an double-underscore notation? surely an association column then
+          if !assoc && c[:name].index('__')
+            assoc_name, assoc_method = c[:name].split('__')
+            assoc = data_class.reflect_on_association(assoc_name.to_sym)
+          end
+          
+          if assoc && assoc_method
+            assoc_column = assoc.klass.columns_hash[assoc_method]
+            assoc_method_type = assoc_column.try(:type)
+            
+            # if association column is boolean, display a checkbox (or alike), otherwise - a combobox (or alike)
+            c[:editor] = assoc_method_type == :boolean ? editor_for_attr_type(:boolean) : editor_for_association
+          end
+        end
+      
+      def self.included(receiver)
+        receiver.extend         ClassMethods
+        receiver.send :include, InstanceMethods
+      end
+    end
+  end
+end

data/lib/netzke/grid_panel/grid_panel_js.rb

@@ -1,26 +1,27 @@
 module Netzke
   class GridPanel < Base
+    # (Dynamic) JavaScript for GridPanel
     module GridPanelJs
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
+      
+      # The result of this method (a hash) is converted to a JSON object and passed as the configuration parameter
+      # to the constructor of our JavaScript class. Override it when you want to pass any extra configuration
+      # to the JavaScript side.
       def js_config
-        res = super
-        res.merge!(:clmns => columns)
-        res.merge!(:model => config[:model])
-        res.merge!(:inline_data => get_data) if ext_config[:load_inline_data]
-        res.merge!(:pri => data_class.primary_key)
-        res
+        super.merge(
+          :clmns => columns, # columns
+          :model => config[:model], # the model name
+          :inline_data => (get_data if ext_config[:load_inline_data]), # inline data (loaded along with the grid panel)
+          :pri => data_class.primary_key # table primary key name
+        )
       end
 
       module ClassMethods
-
+        
         def js_base_class 
           'Ext.grid.EditorGridPanel'
         end
 
-        # Ext.Component#initComponent, built up from pices (dependent on class configuration)
+        # Ext.Component#initComponent, built up from pices (dependent on class-level configuration)
         def js_init_component
         
           # Optional "edit in form"-related events
@@ -45,13 +46,11 @@ module Netzke
               // Normalize columns passed in the config
               var normClmns = [];
               Ext.each(this.clmns, function(c){
-                if (!c.excluded) {
-                  // normalize columns
-                  if (typeof c == 'string') {
-                    normClmns.push({name:c});
-                  } else {
-                    normClmns.push(c);
-                  }
+                // normalize columns
+                if (typeof c == 'string') {
+                  normClmns.push({name:c});
+                } else {
+                  normClmns.push(c);
                 }
               });
 
@@ -61,9 +60,12 @@ module Netzke
               this.plugins = []; // checkbox colums is a special case, being a plugin
 
               var filters = [];
-            
-              // Run through columns
+              
+              // Run through columns and set up different configuration for each
               Ext.each(normClmns, function(c){
+                // We will not use meta columns as actual columns (not even hidden) - only to create the records
+                if (c.meta) return;
+                
                 // Apply default column config
                 Ext.applyIf(c, this.defaultColumnConfig);
 
@@ -71,20 +73,24 @@ module Netzke
                 c.dataIndex = c.name;
 
                 // Automatically calculated default values
-                if (!c.header) {c.header = c.name.humanize()}
+                if (!c.header) {c.header = c.label || c.name.humanize()}
 
                 // normalize editor
                 if (c.editor) {
                   c.editor = Netzke.isObject(c.editor) ? c.editor : {xtype:c.editor};
                 } else {
-                  c.editor = {xtype: 'textfield'}
+                  c.editor = {xtype: this.attrTypeEditorMap[c.attrType] || 'textfield'}
                 }
-              
+
+                // if comboboxOptions are provided, we render a combobox instead of textfield
+                if (c.comboboxOptions && c.editor.xtype === "textfield") {
+                  c.editor = {xtype: "combobox", options: c.comboboxOptions.split('\\n')}
+                }
+                
                 // collect filters
-                // Not compatible with Ext 3.0
-                //if (c.withFilters){
-                //  filters.push({type:Ext.netzke.filterMap[c.editor.xtype], dataIndex:c.name});
-                //}
+                if (c.filterable){
+                  filters.push({type:this.filterTypeForAttrType(c.attrType), dataIndex:c.name});
+                }
 
                 if (c.editor && c.editor.xtype == 'checkbox') {
                   // Special case of checkbox column
@@ -109,12 +115,17 @@ module Netzke
                   if (c.renderer && !Ext.isArray(c.renderer) && c.renderer.match(/^\\s*function\\s*\\(/)) {
                     // if the renderer is an inline function - eval it (double escaping because we are inside of the Ruby string here...)
                     eval("c.renderer = " + c.renderer + ";");
+                  } else if (Ext.isFunction(this[c.renderer])) {
+                    // whether the renderer is defined in this.scope
+                    c.renderer = this[c.renderer].createDelegate(this);
                   } else {
                     // othrewise it's a string representing the name of the renderer or an json-encoded array,
                     // where the first parameter is the renderer's name, and the rest - parameters that should be
                     // passed to the renderer at the moment of calling
                     var renderer = Ext.netzke.normalizedRenderer(c.renderer);
-                    if (renderer != null) c.renderer = renderer;
+                    if (renderer != null) {
+                      c.renderer = renderer
+                    };
                   }
                 
                   // add to the list
@@ -132,14 +143,13 @@ module Netzke
               /* ... and done with columns */
             
               // Filters
-              // Not compatible with Ext 3.0
-              // if (this.enableColumnFilters) {
-              //  this.plugins.push(new Ext.grid.GridFilters({filters:filters}));
-              // }
+              if (this.enableColumnFilters) {
+               this.plugins.push(new Ext.ux.grid.GridFilters({filters:filters}));
+              }
             
               // Create Ext.data.Record constructor specific for our particular column configuration
               this.recordConfig = [];
-              Ext.each(normClmns, function(column){this.recordConfig.push({name:column.name});}, this);
+              Ext.each(normClmns, function(column){this.recordConfig.push({name:column.name, defaultValue:column.defaultValue});}, this);
               this.Row = Ext.data.Record.create(this.recordConfig);
 
               // Drag'n'Drop
@@ -200,8 +210,9 @@ module Netzke
               this.bbar = (this.enablePagination) ? new Ext.PagingToolbar({
                 pageSize : this.rowsPerPage,
                 items : this.bbar ? ["-"].concat(this.bbar) : [],
-                store : this.store, 
-                emptyMsg: 'Empty'
+                store : this.store,
+                emptyMsg: 'Empty',
+                displayInfo: true
               }) : this.bbar;
             
               // Selection model
@@ -260,31 +271,60 @@ module Netzke
         
         end
 
+        # All the rest that makes our JavaScript class
         def js_extend_properties
           res = super
         
-          # Generic (non-optional) functionality
           res.merge!(
           {
+            # all the options are overrideable in config, of course
             :track_mouse_over => true,
             :load_mask        => true,
             :auto_scroll      => true,
 
-            :default_column_config => config_columns.inject({}){ |r, c| c.is_a?(Hash) ? r.merge(c[:name] => c[:default]) : r },
+            :default_column_config => meta_columns.inject({}){ |r, c| c.is_a?(Hash) ? r.merge(c[:name] => c[:default]) : r },
           
             :init_component => js_init_component.l,
           
+            :attr_type_editor_map => {
+              :integer  => "numberfield",
+              :boolean  => "checkbox",
+              :decimal  => "numberfield",
+              :datetime => "xdatetime",
+              :date     => "datefield",
+              :string   => "textfield"
+            },
+            
+            :filter_type_for_attr_type => <<-END_OF_JAVASCRIPT.l,
+              function(attrType){
+                var map = {
+                  integer :'Numeric',
+                  decimal :'Numeric',
+                  datetime:'Date',
+                  date    :'Date',
+                  string  :'String',
+                };
+                map['boolean'] = "Boolean"; // "boolean" is a JS reserved word
+                return map[attrType] || 'String';
+              }
+            END_OF_JAVASCRIPT
+            
             # Handlers for actions
             # 
           
             :on_add => <<-END_OF_JAVASCRIPT.l,
               function(){
-                var rowConfig = {};
-                var r = new this.Row(rowConfig); // TODO: add default values
+                var r = new this.Row();
                 r.isNew = true; // to distinguish new records
                 // r.set('id', r.id); // otherwise later r.get('id') returns empty string
                 this.stopEditing();
                 this.getStore().add(r);
+                
+                // Set default values
+                this.getStore().fields.each(function(field){
+                  r.set(field.name, field.defaultValue);
+                });
+                
                 this.tryStartEditing(this.store.indexOf(r));
               }
             END_OF_JAVASCRIPT
@@ -466,11 +506,13 @@ module Netzke
               function(row){
                 var editableIndex = 0;
                 Ext.each(this.getColumnModel().config, function(c){
-                  if (!c.hidden && c.editable && c.editor && (c.editor.xtype !== 'checkbox')) {
+                  // skip columns that cannot be edited
+                  if (!(c.hidden == true || c.editable == false || !c.editor || c.attrType == 'boolean')) {
                     return false;
                   }
                   editableIndex++;
                 });
+                
                 if (editableIndex < this.getColumnModel().config.length) {this.startEditing(row, editableIndex);}
               }
             END_OF_JAVASCRIPT
@@ -575,84 +617,44 @@ module Netzke
           # Optional edit in form functionality
           res.merge!(
           {
-            :on_successfull_record_creation => <<-END_OF_JAVASCRIPT.l,
-              function(){
-                this.formWindow.hide();
-                this.getStore().reload();
-              }
-            END_OF_JAVASCRIPT
-
-            :on_successfull_edit => <<-END_OF_JAVASCRIPT.l,
-              function(){
-                this.editFormWindow.close();
-                delete this.editFormWindow;
-                this.getStore().reload();
-              }
-            END_OF_JAVASCRIPT
-
             :on_edit_in_form => <<-END_OF_JAVASCRIPT.l,
               function(){
-                // create the window
-                delete this.editFormWindow;
-                this.editFormWindow = new Ext.Window({
-                  title: 'Edit',
-                  layout: 'fit',
-                  modal: true,
-                  width: 400,
-                  height: Ext.lib.Dom.getViewHeight() *0.9,
-                  buttons:[{
-                    text: 'OK',
-                    handler: function(){
-                      this.ownerCt.ownerCt.getWidget().onApply();
-                    }
-                  },{
-                    text:'Cancel',
-                    handler:function(){
-                      this.ownerCt.ownerCt.hide();
-                    }
-                  }]
-                });
-
-                // show it and load the correct aggregatee in it
-                this.editFormWindow.show(null, function(){
-                  var selModel = this.getSelectionModel();
-                  if (selModel.getCount() > 1) {
-
-                    // multiedit
-                    this.editFormWindow.setTitle('Multi-edit');
-                    this.loadAggregatee({
-                      id: "multiEditForm",
-                      container: this.editFormWindow.id,
-                      callback: function(aggr){
-                        // on apply attach ids of selected rows
-                        aggr.on('apply', function(){
-                          var ids = [];
-                          selModel.each(function(r){
-                            ids.push(r.id);
-                          });
-                          aggr.baseParams = {ids: Ext.encode(ids)}
-                        }, this);
-                      },
-                      scope: this
-                    });
-                  } else {
-                  
-                    // single edit
-                    this.editFormWindow.setTitle('Edit');
-                    var recordId = selModel.getSelected().id;
-                    this.loadAggregatee({
-                      id: "editForm",
-                      container: this.editFormWindow.id,
-                      params: {
-                        record_id: recordId
-                      }
-                    });
-                  }
-                }, this);
-
+                var selModel = this.getSelectionModel();
+                if (selModel.getCount() > 1) {
+                  var recordId = selModel.getSelected().id;
+                  this.loadAggregatee({id: "multiEditForm",
+                    params: {record_id: recordId},
+                    callback: function(w){
+                      var form = w.items.first();
+                      form.on('apply', function(){
+                        var ids = [];
+                        selModel.each(function(r){
+                          ids.push(r.id);
+                        });
+                        form.baseParams = {ids: Ext.encode(ids)}
+                      }, this);
+                      
+                      w.on('close', function(){
+                        if (w.closeRes === "ok") {
+                          this.store.reload();
+                        }
+                      }, this);
+                    }, scope: this});
+                } else {
+                  var recordId = selModel.getSelected().id;
+                  this.loadAggregatee({id: "editForm",
+                    params: {record_id: recordId},
+                    callback: function(form){
+                      form.on('close', function(){
+                        if (form.closeRes === "ok") {
+                          this.store.reload();
+                        }
+                      }, this);
+                    }, scope: this});
+                }
               }
             END_OF_JAVASCRIPT
-
+            
             :on_add_in_form => <<-END_OF_JAVASCRIPT.l,
               function(){
                 this.loadAggregatee({id: "addForm", callback: function(form){
@@ -679,7 +681,7 @@ module Netzke
                   modal: true,
                   width: 400,
                   height: Ext.lib.Dom.getViewHeight() *0.9,
-                  closeAction:'hide',
+                  closeAction:'close',
                   buttons:[{
                     text: 'OK',
                     handler: function(){
@@ -694,15 +696,15 @@ module Netzke
                   closePositively : function(){
                     this.conditions = this.getWidget().getForm().getValues();
                     this.closeRes = 'OK'; 
-                    this.hide();
+                    this.close();
                   },
                   closeNegatively: function(){
                     this.closeRes = 'cancel'; 
-                    this.hide();
+                    this.close();
                   }
                 });
 
-                this.searchWindow.on('hide', function(){
+                this.searchWindow.on('close', function(){
                   if (this.searchWindow.closeRes == 'OK'){
                     var searchConditions = this.searchWindow.conditions;
                     var filtered = false;
@@ -742,6 +744,11 @@ module Netzke
           res
         end
       end
+      
+      def self.included(base)
+        base.extend ClassMethods
+      end
+      
     end
   end
 end