netzke-basepack 0.5.8 → 0.5.9

data/lib/netzke/form_panel/form_panel_api.rb

@@ -29,7 +29,6 @@ module Netzke
           begin
             @record.send("#{k}=",v)
           rescue StandardError => exc
-            logger.debug "!!! FormPanelApi#create_or_update_record exception: #{exc.inspect}\n"
             flash :error => exc.message
             success = false
             break
@@ -66,12 +65,12 @@ module Netzke
   
       def configuration_panel__fields__get_combobox_options(params)
         query = params[:query]
-        {:data => (predefined_columns.map{ |c| c[:name].to_s }).grep(/^#{query}/).map{ |n| [n] }}.to_nifty_json
+        {:data => (default_columns.map{ |c| c[:name].to_s }).grep(/^#{query}/).map{ |n| [n] }}.to_nifty_json
       end
   
       # Returns array of form values according to the configured columns
       def array_of_values
-        @record && @record.to_array(columns, self)
+        @record && @record.to_array(fields, self)
       end
     end
   end

data/lib/netzke/form_panel/form_panel_fields.rb

@@ -0,0 +1,147 @@
+module Netzke
+  class FormPanel < Base
+    module FormPanelFields
+      module ClassMethods
+        # Columns to be displayed by the FieldConfigurator, "meta-columns". Each corresponds to a configuration
+        # option for each field in the form.
+        def meta_columns
+          [
+            {:name => "included", :attr_type => :boolean, :width => 40, :header => "Incl", :default_value => true},
+            {:name => "name", :attr_type => :string, :editor => :combobox, :width => 200},
+            {:name => "label", :attr_type => :string, :header => "Label"},
+            {:name => "default_value", :attr_type => :string}
+          ]
+        end
+      end
+      
+      module InstanceMethods
+        def fields
+          @fields ||= begin
+            flds = load_fields
+            flds ||= initial_fields
+            
+            flds.map! do |c|
+              value = record.send(c[:name])
+              value.nil? ? c : c.merge(:value => value)
+            end if record
+            
+            flds
+          end
+        end
+
+        def default_fields
+          @default_fields ||= load_model_level_attrs || (data_class && data_class.netzke_attributes) || []
+        end
+
+        def initial_fields(only_included = true)
+          ::ActiveSupport::Deprecation.warn("The :columns option for FormPanel is deprecated. Use :fields instead", caller) if config[:columns]
+          
+          # Normalize here, as from the config we can get symbols (names) instead of hashes
+          fields_from_config = (config[:columns] || config[:fields]) && normalize_attr_config(config[:columns] || config[:fields])
+
+          if fields_from_config
+            # reverse-merge each column hash from config with each column hash from exposed_attributes (fields from config have higher priority)
+            for c in fields_from_config
+              corresponding_exposed_column = default_fields.find{ |k| k[:name] == c[:name] }
+              c.reverse_merge!(corresponding_exposed_column) if corresponding_exposed_column
+            end
+            fields_for_create = fields_from_config
+          elsif default_fields
+            # we didn't have fields configured in widget's config, so, use the fields from the data class
+            fields_for_create = default_fields
+          else
+            raise ArgumentError, "No fields specified for widget '#{global_id}'"
+          end
+          
+          fields_for_create.reject!{ |c| c[:included] == false }
+          
+          fields_for_create.map! do |c|
+            if data_class
+
+              detect_association_with_method(c)
+              
+              # detect association column (e.g. :category_id)
+              if assoc = data_class.reflect_on_all_associations.detect{|a| a.primary_key_name == c[:name]}
+                c[:xtype] ||= xtype_for_association
+                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
+
+              c[:hidden] = true if c[:name] == data_class.primary_key && c[:hidden].nil? # hide ID column by default
+            end
+
+            set_default_field_label(c)
+            
+            c[:xtype] ||= xtype_for_attr_type(c[:attr_type]) # unless xtype_map[type].nil?
+            c
+          end
+
+          fields_for_create
+
+        end
+      end
+      
+      private
+        # Stores modified fields in persistent storage (not used in forms, as we can't modify them on the fly, only via FieldsConfigurator)
+        # def save_fields!
+        #   NetzkeFieldList.update_list_for_current_authority(global_id, fields, data_class.name)
+        # end
+      
+        def load_fields
+          NetzkeFieldList.read_list(global_id) if persistent_config_enabled?
+        end
+        
+        def load_model_level_attrs
+          NetzkeModelAttrList.read_list(data_class.name) if data_class
+        end
+        
+        def set_default_field_label(c)
+          c[:label] ||= c[:name].humanize
+        end
+      
+        def attr_type_to_xtype_map
+          {
+            :integer => :numberfield,
+            :boolean => :xcheckbox,
+            :date => :datefield,
+            :datetime => :xdatetime,
+            :text => :textarea,
+            :json => :jsonfield
+            # :string => :textfield
+          }
+        end
+        
+        def xtype_for_attr_type(type)
+          attr_type_to_xtype_map[type]
+        end
+        
+        def xtype_for_association
+          :combobox
+        end
+        
+        def detect_association_with_method(c)
+          if c[:name].to_s.index('__')
+            assoc_name, method = c[:name].split('__').map(&:to_sym)
+            if assoc = data_class.reflect_on_association(assoc_name)
+              assoc_column = assoc.klass.columns_hash[method.to_s]
+              assoc_method_type = assoc_column.try(:type)
+              if assoc_method_type
+                c[:xtype] ||= assoc_method_type == :boolean ? xtype_for_attr_type(assoc_method_type) : :combobox
+              end
+            end
+          end
+          
+        end
+
+      
+      def self.included(receiver)
+        receiver.extend         ClassMethods
+        receiver.send :include, InstanceMethods
+
+        receiver.class_eval do
+          alias :initial_columns :initial_fields
+        end
+      end
+    end
+  end
+end

data/lib/netzke/form_panel/form_panel_js.rb

@@ -1,8 +1,13 @@
 module Netzke
   class FormPanel < Base
     module FormPanelJs
-      def self.included(base)
-        base.extend ClassMethods
+      # parameters used to instantiate the JS object
+      def js_config
+        res = super
+        res.merge!(:fields => fields)
+        res.merge!(:model => data_class.name) if data_class
+        res.merge!(:pri => data_class.primary_key) if data_class
+        res
       end
 
       module ClassMethods
@@ -24,21 +29,22 @@ module Netzke
                 var index = 0;
             
                 // Process columns
-                Ext.each(this.clmns, function(field){
-                  if (typeof field == 'string') field = {name:field}; // normalize field
+                Ext.each(this.fields, function(field){
                   if (!field.hidden || field.name == this.pri) {
                     recordFields.push({name:field.name, mapping:index++});
-
+                    
                     var defaultColumnConfig = Ext.apply({}, this.defaultColumnConfig);
                     var columnConfig = Ext.apply(defaultColumnConfig, field);
 
                     // apply dynamically defined properties
-                    Ext.apply(columnConfig, {
-                      fieldLabel: columnConfig.fieldLabel || columnConfig.name.humanize(),
-                      hideLabel: columnConfig.hidden, // completely hide fields marked "hidden"
-                      parentId: this.id,
-                      name: columnConfig.name,
-                      checked: columnConfig.xtype == "xcheckbox" ? columnConfig.value : null // checkbox state
+                    Ext.applyIf(columnConfig, {
+                      xtype     : this.attrTypeEditorMap[columnConfig.attrType],
+                      fieldLabel: columnConfig.fieldLabel || columnConfig.label || columnConfig.name.humanize(),
+                      hideLabel : columnConfig.hidden, // completely hide fields marked "hidden"
+                      parentId  : this.id,
+                      name      : columnConfig.name,
+                      value     : columnConfig.value || columnConfig.defaultValue,
+                      checked   : columnConfig.attrType == "boolean" ? columnConfig.value : null // checkbox state
                     });
 
                     this.items.push(columnConfig);
@@ -48,7 +54,7 @@ module Netzke
                 var Record = Ext.data.Record.create(recordFields);
                 this.reader = new Ext.data.RecordArrayReader({root:"data"}, Record);
             
-                delete this.clmns; // we don't need them anymore
+                delete this.fields; // we don't need them anymore
             
                 // Now let Ext.form.FormPanel do the rest
                 #{js_full_class_name}.superclass.initComponent.call(this);
@@ -58,6 +64,15 @@ module Netzke
               }
             END_OF_JAVASCRIPT
 
+            :attr_type_editor_map => {
+              :integer  => "numberfield",
+              :boolean  => "checkbox",
+              :decimal  => "numberfield",
+              :datetime => "xdatetime",
+              :date     => "datefield",
+              :string   => "textfield"
+            },
+
             # Defaults for each field
             :defaults       => {
               :anchor       => '-20', # to leave some space for the scrollbar
@@ -74,9 +89,9 @@ module Netzke
               }
             },
         
-            :default_column_config => config_columns.inject({}){ |r, c| r.merge!({
-              c[:name] => c[:default]
-            }) },
+            # :default_column_config => meta_columns.inject({}){ |r, c| r.merge!({
+            #   c[:name] => c[:default_value]
+            # })},
         
             :set_form_values => <<-END_OF_JAVASCRIPT.l,
               function(values){
@@ -138,6 +153,11 @@ module Netzke
         end
     
       end
+    
+      def self.included(base)
+        base.extend ClassMethods
+      end
+    
     end
   end
 end

data/lib/netzke/grid_panel.rb

@@ -1,5 +1,6 @@
 require "netzke/grid_panel/grid_panel_js"
 require "netzke/grid_panel/grid_panel_api"
+require "netzke/grid_panel/grid_panel_columns"
 require "netzke/plugins/configuration_tool"
 require "netzke/data_accessor"
 
@@ -58,13 +59,45 @@ module Netzke
   # * <tt>:mode</tt> - when set to <tt>:config</tt>, GridPanel loads in configuration mode
   # 
   # Additionally supports Netzke::Base config options.
+  # 
+  # == Column
+  # Here's how the GridPanel decides which columns in which sequence and with which configuration to display.
+  # First, the column configs are aquired from this GridPanel's persistent storage, as an array of hashes, each 
+  # representing a column configuration, such as:
+  #
+  #   {:name => :created_at, :header => "Created", :tooltip => "When the record was created"}
+  # 
+  # This hash *overrides* (deep_merge) the hard-coded configuration, an example of which can be specifying 
+  # columns for a GridPanel instance, e.g.:
+  # 
+  #   :columns => [{:name => :created_at, :sortable => false}]
+  # 
+  # ... which in its turn overrides the defaults provided by persistent storage managed by the AttributesConfigurator
+  # that provides *model-level* (as opposed to a widget-level) configuration of a database model 
+  # (which is used by both grids and forms in Netzke).
+  # And lastly, the defaults for AttributesConfigurator are calculated from the database model itself, powered by Netzke.
+  # For example, in the model you can specify virtual attributes and their types that will be picked up by Netzke, the default
+  # order of columns, or excluded columns. For details see <tt>Netzke::ActiveRecord::Attributes</tt>.
+  # 
+  # The columns are displayed in the order specified by what's found first in the following sequence:
+  #   GridPanel instance's persistent storage
+  #   hardcoded config
+  #   AttributesConfigurator persistent storage
+  #   netzke_expose_attributes in the database model
+  #   database columns + (eventually) virtual attributes specified with netzke_attribute
   class GridPanel < Base
-      # javascript (client-side)
+    # javascript (client-side)
     include GridPanelJs
-      # API (server-side)
+    
+    # API (server-side)
     include GridPanelApi
-      # Code shared between GridPanel, FormPanel, and other widgets that serve as interface to database tables
+    
+    # Columns
+    include GridPanelColumns
+    
+    # Code shared between GridPanel, FormPanel, and other widgets that serve as interface to database tables
     include Netzke::DataAccessor
+    
 
     def self.enforce_config_consistency
       config[:default_config][:ext_config][:enable_edit_in_form]    &&= config[:edit_in_form_available]
@@ -111,24 +144,19 @@ module Netzke
       # Checkcolumn
       ext_examples = Netzke::Base.config[:ext_location] + "/examples/"
       res << ext_examples + "ux/CheckColumn.js"
-      # res << "#{File.dirname(__FILE__)}/grid_panel/javascripts/check-column.js"
-      
       
       # Filters
-      # Not compatible with Ext 3.0
-      # if config[:column_filters_available]
-      #   ext_examples = Netzke::Base.config[:ext_location] + "/examples/"
-      #   res << ext_examples + "grid-filtering/menu/EditableItem.js"
-      #   res << ext_examples + "grid-filtering/menu/RangeMenu.js"
-      #   res << ext_examples + "grid-filtering/grid/GridFilters.js"
-      # 
-      #   %w{Boolean Date List Numeric String}.unshift("").each do |f|
-      #     res << ext_examples + "grid-filtering/grid/filter/#{f}Filter.js"
-      #   end
-      #   
-      #   res << "#{File.dirname(__FILE__)}/grid_panel/javascripts/filters.js"
-      #   
-      # end
+      if config[:column_filters_available]
+        ext_examples = Netzke::Base.config[:ext_location] + "/examples/"
+        res << ext_examples + "ux/gridfilters/menu/ListMenu.js"
+        res << ext_examples + "ux/gridfilters/menu/RangeMenu.js"
+        res << ext_examples + "ux/gridfilters/GridFilters.js"
+      
+        %w{Boolean Date List Numeric String}.unshift("").each do |f|
+          res << ext_examples + "ux/gridfilters/filter/#{f}Filter.js"
+        end
+        
+      end
       
       # DD
       if config[:rows_reordering_available]
@@ -137,7 +165,7 @@ module Netzke
 
       res
     end
-
+    
     # Define connection points between client side and server side of GridPanel. 
     # See implementation of equally named methods in the GridPanelApi module.
     api :get_data, :post_data, :delete_data, :resize_column, :move_column, :hide_column, :get_combobox_options, :move_rows
@@ -147,9 +175,14 @@ module Netzke
 
     # (We can't memoize this method because at some point we extend it, e.g. in Netzke::DataAccessor)
     def data_class
-      ::ActiveSupport::Deprecation.warn("data_class_name option is deprecated. Use model instead", caller) if config[:data_class_name]
-      model_name = config[:model] || config[:data_class_name]
-      @data_class ||= model_name.nil? ? raise(ArgumentError, "No model specified for widget #{global_id}") : model_name.constantize
+      @data_class ||= begin
+        klass = "Netzke::ModelExtensions::#{config[:model]}For#{short_widget_class_name}".constantize rescue nil
+        klass || begin
+          ::ActiveSupport::Deprecation.warn("data_class_name option is deprecated. Use model instead", caller) if config[:data_class_name]
+          model_name = config[:model] || config[:data_class_name]
+          model_name.nil? ? raise(ArgumentError, "No model specified for widget #{global_id}") : model_name.constantize
+        end
+      end
     end
     
     def initialize(config = {}, parent = nil)
@@ -158,52 +191,31 @@ module Netzke
       apply_helpers
     end
 
-    # Columns to be displayed by the FieldConfigurator. 
-    def self.config_columns
-      [
-        {:name => :name,       :type => :string, :editor => :combobox, :width => 200},
-        {:name => :excluded,   :type => :boolean, :editor => :checkbox, :width => 40, :header => "Excl"},
-        {:name => :value},
-        {:name => :header},
-        {:name => :hidden,     :type => :boolean, :editor => :checkbox},
-        {:name => :editable,  :type => :boolean, :editor => :checkbox, :header => "Editable", :default => true},
-        {:name => :editor,     :type => :string, :editor => {:xtype => :combobox, :options => Netzke::Ext::FORM_FIELD_XTYPES}},
-        {:name => :renderer,   :type => :string},
-        
-        # maybe later
-        # {:name => :xtype, :type => :string, :editor => {:xtype => :combobox, :options => Netzke::Ext::COLUMN_XTYPES}},
-        
-        # {:name => :renderer, :type => :string, :editor => {:xtype => :jsonfield}},
-        
-        # Filters not supported in Ext 3.0
-        # {:name => :with_filters,   :type => :boolean, :editor => :checkbox, :default => true, :header => "Filters"},
-
-        # some rarely used configurations, hidden
-        {:name => :width,      :type => :integer, :editor => :numberfield, :hidden => true},
-        {:name => :hideable,   :type => :boolean, :editor => :checkbox, :default => true, :hidden => true},
-        {:name => :sortable,   :type => :boolean, :editor => :checkbox, :default => true, :hidden => true},
-      ]
-    end
+    # def data_class
+    #   klass = "Netzke::ModelExtensions::#{data_class.name}#{short_widget_class_name}Ext".constantize rescue nil
+    #   klass || data_class
+    # end
     
+    # Fields to be displayed in the "General" tab of the configuration panel
     def self.property_fields
       res = [
         {:name => :ext_config__title,               :type => :string},
         {:name => :ext_config__header,              :type => :boolean, :default => true},
         {:name => :ext_config__enable_context_menu, :type => :boolean, :default => true},
-        {:name => :ext_config__context_menu,        :type => :json},
+        # {:name => :ext_config__context_menu,        :type => :json},
         {:name => :ext_config__enable_pagination,   :type => :boolean, :default => true},
         {:name => :ext_config__rows_per_page,       :type => :integer},
-        {:name => :ext_config__bbar,                :type => :json},
+        # {:name => :ext_config__bbar,                :type => :json},
         {:name => :ext_config__prohibit_create,     :type => :boolean},
         {:name => :ext_config__prohibit_update,     :type => :boolean},
         {:name => :ext_config__prohibit_delete,     :type => :boolean},
         {:name => :ext_config__prohibit_read,       :type => :boolean}
       ]
       
-      res << {:name => :ext_config__enable_extended_search, :type => :boolean} if config[:extended_search_available]
-      res << {:name => :ext_config__enable_edit_in_form, :type => :boolean} if config[:edit_in_form_available]
+      # res << {:name => :ext_config__enable_extended_search, :type => :boolean} if config[:extended_search_available]
+      # res << {:name => :ext_config__enable_edit_in_form, :type => :boolean} if config[:edit_in_form_available]
       
-      # TODO: buggy thing
+      # TODO: a buggy thing
       # res << {:name => :layout__columns,                 :type => :json}
       
       res
@@ -237,9 +249,9 @@ module Netzke
       res << {
         :persistent_config => true,
         :name              => 'columns',
-        :class_name => "FieldsConfigurator",
+        :class_name        => "FieldsConfigurator",
         :active            => true,
-        :widget            => self
+        :owner             => self
       }
       res << {
         :name               => 'general',
@@ -252,15 +264,30 @@ module Netzke
 
     def actions
       # Defaults
-      { 
-        :add          => {:text => 'Add',     :disabled      => ext_config[:prohibit_create]},
-        :edit         => {:text => 'Edit',    :disabled      => true},
-        :del          => {:text => 'Delete',  :disabled      => true},
-        :apply        => {:text => 'Apply',   :disabled      => ext_config[:prohibit_update] && ext_config[:prohibit_create]},
-        :add_in_form  => {:text => 'Add in form', :disabled  => !ext_config[:enable_edit_in_form]},
+      actions = {                                     
+        :add          => {:text => 'Add',          :disabled => ext_config[:prohibit_create]},
+        :edit         => {:text => 'Edit',         :disabled => true},
+        :del          => {:text => 'Delete',       :disabled => true},
+        :apply        => {:text => 'Apply',        :disabled => ext_config[:prohibit_update] && ext_config[:prohibit_create]},
+        :add_in_form  => {:text => 'Add in form',  :disabled => !ext_config[:enable_edit_in_form]},
         :edit_in_form => {:text => 'Edit in form', :disabled => true},
-        :search       => {:text => 'Search', :disabled       => !ext_config[:enable_extended_search], :checked => true}
+        :search       => {:text => 'Search',       :disabled => !ext_config[:enable_extended_search], :checked => true}
       }
+      
+      if Netzke::Base.config[:with_icons]
+        icons_uri = Netzke::Base.config[:icons_uri]
+        actions.deep_merge!(
+          :add => {:icon => icons_uri + "add.png"},
+          :edit => {:icon => icons_uri + "table_edit.png"},
+          :del => {:icon => icons_uri + "table_row_delete.png"},
+          :apply => {:icon => icons_uri + "tick.png"},
+          :add_in_form => {:icon => icons_uri + "application_form_add.png"},
+          :edit_in_form => {:icon => icons_uri + "application_form_edit.png"},
+          :search => {:icon => icons_uri + "find.png"}
+        )
+      end
+      
+      actions
     end
 
     def initial_late_aggregatees
@@ -276,7 +303,7 @@ module Netzke
           },
           :item => {
             :class_name => "FormPanel",
-            :model => data_class.name,
+            :model => config[:model],
             :persistent_config => config[:persistent_config],
             :strong_default_attrs => config[:strong_default_attrs],
             :ext_config => {
@@ -290,38 +317,50 @@ module Netzke
         },
         
         :edit_form => {
-          :class_name => "FormPanel",
-          :model => data_class.name,
-          :persistent_config => config[:persistent_config],
+          :class_name => "GridPanel::RecordFormWindow",
           :ext_config => {
-            :bbar => false,
-            :header => false,
-            :mode => ext_config[:mode]
-          }
+            :title => "Edit #{data_class.name.humanize}",
+            :button_align => "right"
+          },
+          :item => {
+            :class_name => "FormPanel",
+            :model => config[:model],
+            :persistent_config => config[:persistent_config],
+            :ext_config => {
+              :bbar => false,
+              :header => false,
+              :mode => ext_config[:mode]
+            }
+          },
         },
         
-        :multi_edit_form => {
-          :class_name => "FormPanel",
-          :model => data_class.name,
-          :persistent_config => config[:persistent_config],
-          :ext_config => {
-            :bbar => false,
-            :header => false,
-            :mode => ext_config[:mode]
-          }
-        },
+        # :edit_form => {
+        #   :class_name => "FormPanel",
+        #   :model => data_class.name,
+        #   :persistent_config => config[:persistent_config],
+        #   :ext_config => {
+        #     :bbar => false,
+        #     :header => false,
+        #     :mode => ext_config[:mode]
+        #   }
+        # },
         
-        :new_record_form => {
-          :class_name => "FormPanel",
-          :model => data_class.name,
-          :persistent_config => config[:persistent_config],
-          :strong_default_attrs => config[:strong_default_attrs],
+        :multi_edit_form => {
+          :class_name => "GridPanel::RecordFormWindow",
           :ext_config => {
-            :bbar => false,
-            :header => false,
-            :mode => ext_config[:mode]
+            :title => "Edit #{data_class.name.humanize}",
+            :button_align => "right"
           },
-          :record => data_class.new
+          :item => {
+            :class_name => "FormPanel",
+            :model => config[:model],
+            :persistent_config => config[:persistent_config],
+            :ext_config => {
+              :bbar => false,
+              :header => false,
+              :mode => ext_config[:mode]
+            }
+          }
         }
       }) if ext_config[:enable_edit_in_form]
       
@@ -329,7 +368,7 @@ module Netzke
       res.merge!({
         :search_panel => {
           :class_name => "SearchPanel",
-          :search_class_name => data_class.name,
+          :search_class_name => config[:model],
           :persistent_config => config[:persistent_config],
           :ext_config => {
             :header => false, 
@@ -342,129 +381,7 @@ module Netzke
       res
     end
 
-
     include Plugins::ConfigurationTool if config[:config_tool_available] # it will load ConfigurationPanel into a modal window
     
-    def columns
-      @columns ||= get_columns
-    end
-
-    # Normalized columns
-    def normalized_columns
-      @normalized_columns ||= normalize_columns(columns)
-    end
-
-    def get_columns
-      if persistent_config_enabled?
-        columns = persistent_config['layout__columns'] || default_columns
-        res = normalize_array_of_columns(columns)
-      else
-        res = default_columns
-      end
-
-      # denormalize
-      res.map{ |c| c.is_a?(Hash) && c.reject{ |k,v| k == :name }.empty? ? c[:name].to_sym : c }
-    end
-    
-    # Normalizes the column at position +index+ and returns it.
-    def column_at(index)
-      if columns[index].is_a?(Hash)
-        columns[index]
-      else
-        column_name = columns.delete_at(index)
-        normalized_column = normalize_column(column_name)
-        columns.insert(index, normalized_column)
-        normalized_column
-      end
-    end
-    
-    # Stores modified columns in persistent storage
-    def save_columns!
-      persistent_config[:layout__columns] = columns
-    end
-    
-    TYPE_EDITOR_MAP = {
-      :integer => :numberfield,
-      :boolean => :checkbox,
-      :date => :datefield,
-      :datetime => :xdatetime,
-      :text => :textarea
-      # :string => :textfield
-    }
-    
-    def default_columns
-      # columns specified in widget's config
-      columns_from_config = config[:columns] && normalize_columns(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_exposed_column = predefined_columns.find{ |k| k[:name] == c[:name] }
-          c.reverse_merge!(corresponding_exposed_column) if corresponding_exposed_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 = predefined_columns
-      end
-      
-      columns_for_create.map! do |c|
-        # detect ActiveRecord column type (if the column is "real") or fall back to :virtual
-        type = (data_class.columns_hash[c[:name].to_s] && data_class.columns_hash[c[:name].to_s].type) || :virtual
-
-        # detect :assoc__method columns
-        if c[:name].to_s.index('__')
-          assoc_name, method = c[:name].to_s.split('__').map(&:to_sym)
-          if assoc = data_class.reflect_on_association(assoc_name)
-            assoc_column = assoc.klass.columns_hash[method.to_s]
-            assoc_method_type = assoc_column.try(:type)
-            if assoc_method_type
-              c[:editor] ||= TYPE_EDITOR_MAP[assoc_method_type] == :checkbox ? :checkbox : :combobox
-            end
-            type = :association
-          end
-        end
-        
-        # detect association column (e.g. :category_id)
-        assoc = data_class.reflect_on_all_associations.detect{|a| a.primary_key_name.to_sym == c[:name]}
-        if  assoc && !assoc.options[:polymorphic]
-          c[:editor] ||= :combobox
-          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}".to_sym
-          type = :association
-        end
-        
-        # Some smart defaults
-        
-        # default editor, dependent on column type
-        c[:editor] ||= TYPE_EDITOR_MAP[type] unless TYPE_EDITOR_MAP[type].nil?
-        # narrow column for checkbox
-        c[:width] ||= 50 if c[:editor] == :checkbox
-        # wider column for xdatetime
-        c[:width] ||= 120 if c[:editor] == :xdatetime
-        # hide ID column
-        c[:hidden] = true if c[:name] == data_class.primary_key.to_sym && c[:hidden].nil?
-        # make ID column read-only
-        c[:editable] = false if c[:name] == data_class.primary_key.to_sym && c[:editable].nil?
-        
-        # Some default limitations for virtual columns
-        if type == :virtual
-          # disable filters
-          # c[:with_filters].nil? && c[:with_filters] = false
-          # disable sorting
-          c[:sortable].nil? && c[:sortable] = false
-          # read-only
-          # c[:read_only].nil? && c[:read_only] = true
-          c[:editable].nil? && c[:editable] = false
-        end
-        
-        # denormalize column (save space)
-        c.reject{ |k,v| k == :name }.empty? ? c[:name] : c
-      end
-      
-      columns_for_create
-      
-    end
-    
   end
 end