netzke-basepack 0.6.3 → 0.6.4

data/lib/netzke/basepack/grid_panel/columns.rb

@@ -3,67 +3,97 @@ module Netzke
     class GridPanel < Netzke::Base
       module Columns
         extend ActiveSupport::Concern
+        extend ActiveSupport::Memoizable
+
+        # 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},
+        #     ]
+        #   end
+        #
+        # end
 
-        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).
-              #
+        # Normalized columns for the grid, e.g.:
+        # [{:name => :id, :hidden => true, ...}, {:name => :name, :editable => false, ...}, ...]
+        # Possible options:
+        # * +with_excluded+ - when set to true, also excluded columns will be returned (handy for dynamic column configuration)
+        # * +with_meta+ - when set to true, the meta column will be included as the last column
+        def columns(options = {})
+          [].tap do |cols|
+            if loaded_columns = load_columns
+              filter_out_excluded_columns(loaded_columns) unless options[:with_excluded]
+              cols.concat(reverse_merge_equally_named_columns(loaded_columns, initial_columns(options[:with_excluded])))
+            else
+              cols.concat(initial_columns(options[:with_excluded]))
+            end
 
-              # The column's width
-              {:name => "width",         :attr_type => :integer, :hidden => true},
+            append_meta_column(cols) if options[:with_meta]
+          end
+        end
 
-              # Whether the column should be hideable
-              {:name => "hideable",      :attr_type => :boolean, :default_value => true, :hidden => true},
+        memoize :columns
 
-              # Whether the column should be sortable (why change it? normally it's hardcoded)
-              {:name => "sortable",      :attr_type => :boolean, :default_value => true, :hidden => true},
-            ]
+        def append_meta_column(cols)
+          cols << {}.tap do |c|
+            c.merge!(
+              :name => "_meta",
+              :meta => true,
+              :getter => lambda do |r|
+                meta_data(r)
+              end
+            )
+            c[:default_value] = meta_default_data if meta_default_data.present?
           end
+        end
 
+        # default_value for the meta column; used when a new record is being created in the grid
+        def meta_default_data
+          get_default_association_values.present? ? { :association_values => get_default_association_values.literalize_keys } : {}
         end
 
-        # 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
-              reverse_merge_equally_named_columns(cols, initial_columns)
-              cols
-            else
-              initial_columns(only_included)
-            end
-          end
+        # Override it when you need extra meta data to be passed through the meta column
+        def meta_data(r)
+          { :association_values => get_association_values(r).literalize_keys }
         end
 
         # Columns as a hash, for easier access to a specific column
@@ -80,7 +110,7 @@ module Netzke
         end
 
         # Columns that represent a smart merge of default_columns and columns passed during the configuration.
-        def initial_columns(only_included = true)
+        def initial_columns(with_excluded = false)
           # Normalize here, as from the config we can get symbols (names) instead of hashes
           columns_from_config = config[:columns] && normalize_attrs(config[:columns])
 
@@ -101,7 +131,7 @@ module Netzke
             columns_for_create = default_columns
           end
 
-          filter_out_excluded_columns(columns_for_create) if only_included
+          filter_out_excluded_columns(columns_for_create) unless with_excluded
 
           # Make the column config complete with the defaults
           columns_for_create.each do |c|
@@ -143,7 +173,7 @@ module Netzke
           end
 
           def set_default_editor(c)
-            c[:editor] ||= editor_for_attr_type(c[:attr_type])
+            # c[:editor] ||= editor_for_attr_type(c[:attr_type]) # This is done in JS!
             c[:editor] = {:xtype => c[:editor]} if c[:editor].is_a?(Symbol)
           end
 
@@ -157,19 +187,21 @@ module Netzke
           end
 
           def set_default_editable(c)
-            not_editable_if = primary_key_attr?(c)
-            not_editable_if ||= c[:virtual]
-            not_editable_if ||= c.delete(:read_only)
+            if c[:editable].nil?
+              not_editable_if = primary_key_attr?(c)
+              not_editable_if ||= c[:virtual] && !association_attr?(c[:name])
+              not_editable_if ||= c.delete(:read_only)
 
-            editable_if = data_class.column_names.include?(c[:name])
-            editable_if ||= data_class.instance_methods.map(&:to_s).include?("#{c[:name]}=")
-            editable_if ||= association_attr?(c[:name])
+              editable_if = data_class.column_names.include?(c[:name])
+              editable_if ||= data_class.instance_methods.map(&:to_s).include?("#{c[:name]}=")
+              editable_if ||= association_attr?(c[:name])
 
-            c[:editable] = editable_if && !not_editable_if if c[:editable].nil?
+              c[:editable] = editable_if && !not_editable_if
+            end
           end
 
           def set_default_sortable(c)
-            c[:sortable] = !c[:virtual] if c[:sortable].nil?
+            c[:sortable] = !c[:virtual] if c[:sortable].nil? # TODO: optimize - don't set it to false
           end
 
           def set_default_filterable(c)
@@ -182,7 +214,7 @@ module Netzke
           end
 
           def editor_for_association
-            :combobox
+            :netzkeremotecombo
           end
 
           # Returns a hash that maps a column type to the editor xtype. Override if you want different editors.
@@ -191,7 +223,7 @@ module Netzke
               :integer => :numberfield,
               :boolean => :checkbox,
               :date => :datefield,
-              :datetime => :xdatetime,
+              :datetime => :datetimefield,
               :text => :textarea,
               :string => :textfield
             }
@@ -199,7 +231,7 @@ module Netzke
 
           # Detects an association column and sets up the proper editor.
           def detect_association(c)
-            assoc, assoc_method = get_assoc_and_method(c)
+            assoc, assoc_method = assoc_and_assoc_method_for_column(c)
             if assoc
               assoc_column = assoc.klass.columns_hash[assoc_method]
               assoc_method_type = assoc_column.try(:type)
@@ -209,20 +241,11 @@ module Netzke
                 c[:editor] ||= editor_for_attr_type(assoc_method_type)
               else
                 c[:editor] ||= assoc_method_type == :boolean ? editor_for_attr_type(:boolean) : editor_for_association
+                c[:assoc] = true
               end
             end
           end
 
-          def get_assoc_and_method(c)
-            if c[:name].index("__")
-              assoc_name, assoc_method = c[:name].split('__')
-              assoc = data_class.reflect_on_association(assoc_name.to_sym)
-              [assoc, assoc_method]
-            else
-              [nil, nil]
-            end
-          end
-
           # Default fields that will be displayed in the Add/Edit/Search forms
           # When overriding this method, keep in mind that the fields inside the layout must be expanded (each field represented by a hash, not just a symbol)
           def default_fields_for_forms
@@ -239,20 +262,35 @@ module Netzke
               field_config = {:name => c[:name]}
 
               # scopes for combobox options
-              field_config[:scopes] = c[:editor].is_a?(Hash) && c[:editor][:scopes]
+              field_config[:scopes] = c[:editor][:scopes] if c[:editor].is_a?(Hash)
 
               field_config
             end
           end
 
           # default_fields_for_forms extended with default values (for new-record form)
-          def default_fields_for_forms_with_default_values
-            res = default_fields_for_forms.dup
-            each_attr_in(res) do |a|
-              attr_name = a[:name].to_sym
-              a[:value] = a[:default_value] || columns_hash[attr_name].try(:fetch, :default_value, nil) || data_class.netzke_attribute_hash[attr_name].try(:fetch, :default_value, nil)
+          # def default_fields_for_forms_with_default_values
+          #   res = default_fields_for_forms.dup
+          #   each_attr_in(res) do |a|
+          #     attr_name = a[:name].to_sym
+          #     a[:value] = a[:default_value] || columns_hash[attr_name].try(:fetch, :default_value, nil) || data_class.netzke_attribute_hash[attr_name].try(:fetch, :default_value, nil)
+          #   end
+          #   res
+          # end
+
+          def columns_default_values
+            columns.inject({}) do |r,c|
+              assoc, assoc_method = assoc_and_assoc_method_for_column(c)
+              if c[:default_value].nil?
+                r
+              else
+                if assoc
+                  r.merge(assoc.options[:foreign_key] || assoc.name.to_s.foreign_key => c[:default_value])
+                else
+                  r.merge(c[:name] => c[:default_value])
+                end
+              end
             end
-            res
           end
 
           # Recursively traversess items (an array) and yields each found field (a hash with :name set)

data/lib/netzke/basepack/grid_panel/javascripts/advanced_search.js

@@ -1,34 +1,29 @@
 {
   onSearch: function(el){
-    el.toggle(el.toggled); // do not toggle immediately
-
-    this.loadComponent({name: 'search_form', callback: function(win){
-      var currentConditionsString = this.getStore().baseParams.extra_conditions;
-      if (currentConditionsString) {
-        win.items.first().getForm().setValues(Ext.decode(currentConditionsString));
-      }
+    if (this.searchWindow) {
+      this.searchWindow.show();
+    } else {
+      this.loadComponent({name: 'search_form', callback: function(win){
+        this.searchWindow = win;
+        var currentConditionsString = this.getStore().baseParams.extra_conditions;
+        if (currentConditionsString) {
+          win.items.first().getForm().setValues(Ext.decode(currentConditionsString));
+        }
 
-      win.items.first().on('apply', function(){
-        win.onSearch();
-        return false; // do not propagate the 'apply' event
-      }, this);
+        win.items.first().on('apply', function(){
+          win.onSearch();
+          return false; // do not propagate the 'apply' event
+        }, this);
 
-      win.on('close', function(){
-        if (win.closeRes == 'OK'){
-          var searchConditions = win.conditions;
-          var filtered = false;
-          // check if there's any search condition set
-          for (var k in searchConditions) {
-            if (searchConditions[k].length > 0) {
-              filtered = true;
-              break;
-            }
+        win.on('hide', function(){
+          var query = win.getQuery();
+          if (win.closeRes == 'search'){
+            this.getStore().baseParams.query = Ext.encode(query);
+            this.getStore().load();
           }
-          el.toggle(filtered); // toggle based on the state
-          this.getStore().baseParams.extra_conditions = Ext.encode(win.conditions);
-          this.getStore().load();
-        }
-      }, this);
-    }, scope: this});
+          el.toggle(query.length > 0); // toggle based on the state
+        }, this);
+      }, scope: this});
+    }
   }
 }

data/lib/netzke/basepack/grid_panel/javascripts/{main.js → grid_panel.js}

@@ -10,11 +10,15 @@
     this.plugins = []; // checkbox colums is a special case, being a plugin
 
     var filters = [];
+    var metaColumn;
 
     // Run through columns and set up different configuration for each
     Ext.each(this.columns, function(c, i){
       // We will not use meta columns as actual columns (not even hidden) - only to create the records
-      if (c.meta) return;
+      if (c.meta) {
+        metaColumn = c;
+        return;
+      }
 
       // Apply default column config
       Ext.applyIf(c, this.defaultColumnConfig);
@@ -25,13 +29,14 @@
       // Automatically calculated default values
       if (!c.header) {c.header = c.label || c.name.humanize()}
 
-      // normalize editor
-      if (c.editor) {
-        c.editor = Ext.isObject(c.editor) ? c.editor : {xtype:c.editor};
-      } else {
-        c.editor = {xtype: this.attrTypeEditorMap[c.attrType] || 'textfield'}
+      // Set initial association values
+      if (this.inlineData) {
+        this.associationValues = this.inlineData.setAssociationValues;
       }
 
+      // normalize editor
+      this.normalizeEditor(c);
+
       // 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')}
@@ -39,7 +44,7 @@
 
       // collect filters
       if (c.filterable){
-        filters.push({type:this.filterTypeForAttrType(c.attrType), dataIndex:c.name});
+        filters.push({type: this.filterTypeForAttrType(c.attrType), dataIndex: c.name});
       }
 
       if (c.editor && c.editor.xtype == 'checkbox') {
@@ -51,38 +56,39 @@
         // a "normal" column, not a plugin
         if (!c.readOnly && !this.prohibitUpdate) {
           // c.editor contains complete config of the editor
-          var xtype = c.editor.xtype;
           c.editor = Ext.apply({
             parentId: this.id,
             name: c.name,
-            selectOnFocus:true
+            selectOnFocus: true
           }, c.editor);
         } else {
           c.editor = null;
         }
 
-        // Normalize the renderer
         this.normalizeRenderer(c);
 
-        // set the renderer
-//                  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 a 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
-//                    };
-//                  }
-//
-        // add to the list
-        // cmConfig.push(c);
+        this.setDefaultColumnType(c);
+
+        // Set rendeder for association columns (the one displaying associations by the specified method instead of id)
+        if (c.assoc) {
+          c.scope = this;
+          var passedRenderer = c.renderer; // renderer we got from normalizeRenderer
+          c.renderer = function(value, a, r, ri, ci){
+            var editor = this.getColumnModel().getColumnAt(ci).getEditor();
+            var recordFromStore = editor && editor.getStore && editor.getStore().getById(value);
+            var renderedValue;
+            if (recordFromStore) {
+              renderedValue = recordFromStore.get('field2');
+            } else if (c.assoc && r.get('_meta')) {
+              renderedValue = r.get('_meta').associationValues[c.name] || value;
+            } else {
+              renderedValue = value;
+            }
+
+            return passedRenderer ? passedRenderer.call(this, renderedValue) : renderedValue;
+          };
+        }
+
       }
 
     }, this);
@@ -90,15 +96,47 @@
     /* ... and done with columns */
 
     // Filters
+    this.gridFilters = new Ext.ux.grid.GridFilters({filters:filters, encode: true});
     if (this.enableColumnFilters) {
-     this.plugins.push(new Ext.ux.grid.GridFilters({filters:filters}));
+     this.plugins.push(this.gridFilters);
     }
 
     // Create Ext.data.Record constructor specific for our particular column configuration
     this.recordConfig = [];
-    Ext.each(this.columns, function(column){this.recordConfig.push({name:column.name, defaultValue:column.defaultValue});}, this);
+    Ext.each(this.columns, function(column){
+      var extraConfig = {};
+      if (column.attrType == 'datetime') {
+        extraConfig.type = 'date';
+        extraConfig.dateFormat = 'Y-m-d g:i:s';
+      };
+      this.recordConfig.push(Ext.apply({name: column.name, defaultValue: column.defaultValue}, extraConfig));
+    }, this);
     this.Row = Ext.data.Record.create(this.recordConfig);
 
+    // After we created the record (model), we can get rid of the meta column
+    this.columns.remove(metaColumn);
+
+    // Prepare column model config with columns in the correct order
+    var colModelConfig = [];
+
+    Ext.each(this.columnsOrder, function(c) {
+      var mainColConfig;
+      Ext.each(this.columns, function(oc) {
+        if (c.name === oc.name) {
+          mainColConfig = oc;
+          return false;
+        }
+      });
+
+      colModelConfig.push(Ext.apply(mainColConfig, c));
+    }, this);
+
+    // We don't need original columns any longer
+    delete this.columns;
+
+    // ... instead - define a custom column model
+    this.colModel = new Ext.grid.ColumnModel(colModelConfig);
+
     // Drag'n'Drop
     if (this.enableRowsReordering){
       this.ddPlugin = new Ext.ux.dd.GridDragDropRowOrder({
@@ -107,74 +145,45 @@
       this.plugins.push(this.ddPlugin);
     }
 
-    // Explicitely create the connection to get grid's data,
-    // because we don't want the app-wide Ext.Ajax to be used,
-    // as we are going to subscribe to its events
-    var connection = new Ext.data.Connection({
-      url: this.endpointUrl("get_data"),
-      extraParams: {
-        authenticity_token : Netzke.authenticityToken
-      },
-
-      // inform Ext.Ajax about our events
-      listeners: {
-        beforerequest: function(){
-          Ext.Ajax.fireEvent('beforerequest', arguments);
-        },
-        requestexception: function(){
-          Ext.Ajax.fireEvent('requestexception', arguments);
-        },
-        requestcomplete: function(){
-          Ext.Ajax.fireEvent('requestcomplete', arguments);
-        }
-      }
-    });
+    // DirectProxy that uses our Ext.direct provider
+    this.proxy = new Ext.data.DirectProxy({directFn: Netzke.providers[this.id].getData});
 
-    // besides getting data into the store, we may also get commands to execute
-    connection.on('requestcomplete', function(conn, r){
-      var response = Ext.decode(r.responseText);
+    this.proxy.on('load', function (self, t, options) {
+      // besides getting data into the store, we may also get commands to execute
+      var response = t.result;
 
       // delete data-related properties
       Ext.each(['data', 'total', 'success'], function(property){delete response[property];});
       this.bulkExecute(response);
     }, this);
 
-    // HttpProxy that uses our custom connection
-    var httpProxy = new Ext.data.HttpProxy(connection);
-
     // Data store
-    this.store = new Ext.data.Store({
-        pruneModifiedRecords: true,
-        proxy: this.proxy = httpProxy,
-        reader: new Ext.data.ArrayReader({root: "data", totalProperty: "total", successProperty: "success", id:0}, this.Row),
-        remoteSort: true,
-        listeners:{'loadexception':{
-          fn:this.loadExceptionHandler,
-          scope:this
-        }}
-    });
+    this.store = this.buildStore();
 
     // Normalize bottom bar
-    this.bbar = (this.enablePagination) ? new Ext.PagingToolbar({
+    this.bbar = (this.enablePagination) ? new Ext.PagingToolbar(Ext.copyTo({
       pageSize : this.rowsPerPage,
       items : this.bbar ? ["-"].concat(this.bbar) : [],
       store : this.store,
-      emptyMsg: 'Empty',
-      displayInfo: true
-    }) : this.bbar;
+      emptyMsg: this.i18n.empty,
+      displayInfo: true,
+      plugins: this.gridFilters ? [this.gridFilters] : []
+    }, this.i18n, 'emptyMsg,firstText,prevText,nextText,lastText,beforePageText,afterPageText,refreshText,displayMsg')) : this.bbar;
 
     // Selection model
     if (!this.sm) this.sm = new Ext.grid.RowSelectionModel();
 
-    // Now let Ext.grid.EditorGridPanel do the rest
-    // Original initComponent
+    this.view = this.buildView();
+
+    // Now let Ext.grid.EditorGridPanel do the rest (original initComponent)
     Netzke.classes.Basepack.GridPanel.superclass.initComponent.call(this);
 
-    // Hidden change event
-    if (this.persistentConfig) {this.getColumnModel().on('hiddenchange', this.onColumnHiddenChange, this);}
+    // Persistence-related events
+    if (this.persistence) {
+      // Hidden change event
+      this.getColumnModel().on('hiddenchange', this.onColumnHiddenChange, this);
 
-    // Inform the server part about column operations
-    if (this.persistentConfig) {
+      // Inform the server part about column operations
       this.on('columnresize', this.onColumnResize, this);
       this.on('columnmove', this.onColumnMove, this);
     }
@@ -210,9 +219,9 @@
         this.getStore().lastOptions = {params:{limit:this.rowsPerPage, start:0}}; // this is how PagingToolbar does it...
       }
 
-      // inlineData may also contain commands (TODO: make it DRY)
+      // inlineData may also contain commands (TODO: make it DRY, as this code repeats in multiple places...)
       // delete data-related properties
-      Ext.each(['data', 'total', 'success'], function(property){delete this.inlineData[property];}, this);
+      Ext.each(['data', 'total', 'success'], function(property){ delete this.inlineData[property]; }, this);
       this.bulkExecute(this.inlineData);
     }
 
@@ -230,6 +239,33 @@
 
     // GridView
     this.getView().getRowClass = this.defaultGetRowClass;
+
+    // When starting editing as assocition column, pre-load the combobox store from the meta column, so that we don't see the real value of this cell (the id of the associated record), but rather the associated record by the configured method.
+    this.on('beforeedit', function(e){
+      var column = this.getColumnModel().getColumnById(this.getColumnModel().getColumnId(e.column));
+      if (column.assoc && column.getEditor().isXType('combo') && e.record.get('_meta')) {
+        column.getEditor().getStore().loadData({
+          data: [[e.record.get(e.field), e.record.get('_meta').associationValues[e.field]]]
+        });
+      }
+    }, this);
+  },
+
+  buildStore: function() {
+    return new Ext.data.Store({
+      pruneModifiedRecords: true,
+      proxy: this.proxy,
+      reader: new Ext.data.ArrayReader({root: "data", totalProperty: "total", successProperty: "success", id:0}, this.Row),
+      remoteSort: true,
+      listeners:{'loadexception':{
+        fn:this.loadExceptionHandler,
+        scope:this
+      }}
+    });
+  },
+
+  buildView: function() {
+    return null;
   },
 
   filterTypeForAttrType: function(attrType){
@@ -238,9 +274,9 @@
       decimal :'Numeric',
       datetime:'Date',
       date    :'Date',
-      string  :'String'
+      string  :'String',
+      'boolean': 'Boolean'
     };
-    map['boolean'] = "Boolean"; // "boolean" is a JS reserved word
     return map[attrType] || 'String';
   },
 
@@ -249,11 +285,15 @@
     "float"  : "numberfield",
     "boolean": "checkbox",
     decimal  : "numberfield",
-    datetime : "xdatetime",
+    datetime : "datetimefield",
     date     : "datefield",
     string   : "textfield"
   },
 
+  setAssociationValues: function(assocObj) {
+    this.associationValues = assocObj;
+  },
+
   onAdd: function(){
       var r = new this.Row();
       r.isNew = true; // to distinguish new records
@@ -270,7 +310,7 @@
     },
 
   onDel: function() {
-      Ext.Msg.confirm(this.i18n.confirm, this.i18n.areYouSure, function(btn){
+      Ext.Msg.confirm(this.i18n.confirmation, this.i18n.areYouSure, function(btn){
         if (btn == 'yes') {
           var records = [];
           this.getSelectionModel().each(function(r){
@@ -492,14 +532,26 @@
     },
 
   defaultGetRowClass: function(r){
-      return r.isNew ? "grid-dirty-record" : ""
-    },
+    return r.isNew ? "grid-dirty-record" : ""
+  },
 
   selectFirstRow: function(){
-      this.getSelectionModel().suspendEvents();
-      this.getSelectionModel().selectRow(0);
-      this.getSelectionModel().resumeEvents();
-    },
+    this.getSelectionModel().suspendEvents();
+    this.getSelectionModel().selectRow(0);
+    this.getSelectionModel().resumeEvents();
+  },
+
+  setDefaultColumnType: function(c) {
+    if (c.xtype || c.renderer) return;
+
+    switch (c.attrType) {
+      case 'datetime': {
+        c.xtype = 'datecolumn';
+        c.format = c.format || "Y-m-d g:i:s";
+        break;
+      }
+    }
+  },
 
   // Normalizes the renderer for a column.
   // Renderer may be:
@@ -517,34 +569,56 @@
   // * ["Some.scope.Format.customRenderer", 10, 20, 30] (if Some.scope.Format.customRenderer is a function)
   // * "function(v){ return 'Value: ' + v; }"
   normalizeRenderer: function(c) {
-      if (!c.renderer) return;
+    if (!c.renderer) return;
 
-      var name, args = [];
+    var name, args = [];
 
-      if ('string' === typeof c.renderer) {
-        name = c.renderer;
-      } else {
-        name = c.renderer[0];
-        args = c.renderer.slice(1);
-      }
+    if ('string' === typeof c.renderer) {
+      name = c.renderer;
+    } else {
+      name = c.renderer[0];
+      args = c.renderer.slice(1);
+    }
+
+    // First check whether Ext.util.Format has it
+    if (Ext.isFunction(Ext.util.Format[name])) {
+       c.renderer = Ext.util.Format[name].createDelegate(this, args, 1);
+    } else if (Ext.isFunction(this[name])) {
+      // ... then if our own class has it
+      c.renderer = this[name].createDelegate(this, args, 1);
+    } else {
+      // ... and, as last resort, evaluate it (allows passing inline javascript function as renderer)
+      eval("c.renderer = " + c.renderer + ";");
+    }
+  },
 
-      // First check whether Ext.util.Format has it
-      if (Ext.isFunction(Ext.util.Format[name])) {
-         c.renderer = Ext.util.Format[name].createDelegate(this, args, 1);
-      } else if (Ext.isFunction(this[name])) {
-        // ... then if our own class has it
-        c.renderer = this[name].createDelegate(this, args, 1);
+  normalizeEditor: function(c) {
+    if (c.assoc) {
+    } else {
+      if (c.editor) {
+        c.editor = Ext.isObject(c.editor) ? c.editor : {xtype:c.editor};
       } else {
-        // ... and, as last resort, evaluate it (allows passing inline javascript function as renderer)
-        eval("c.renderer = " + c.renderer + ";");
+        c.editor = {xtype: this.attrTypeEditorMap[c.attrType] || 'textfield'}
       }
-    },
+    }
+
+  },
 
   onEdit: function(){
     var row = this.getSelectionModel().getSelected();
     if (row){
       this.tryStartEditing(this.store.indexOf(row));
     }
+  },
+
+  // Not a very clean approach to clean-up. The problem is that this way the advanced search functionality stops being really pluggable. With Ext JS 4 find the way to make it truely so.
+  onDestroy: function(){
+    Netzke.classes.Basepack.GridPanel.superclass.onDestroy.call(this);
+
+    // Destroy the search window (here's the problem: we are not supposed to know it exists)
+    if (this.searchWindow) {
+      this.searchWindow.destroy();
+    }
   }
 
   // :reorder_columns => <<-END_OF_JAVASCRIPT.l,