wice_grid_mongoid 0.5.6

data/generators/wice_grid_assets_prototype/templates/javascripts/wice_grid_prototype.js

@@ -0,0 +1,153 @@
+function WiceGridProcessor(name, base_request_for_filter, base_link_for_show_all_records,
+                      link_for_export, parameter_name_for_query_loading, parameter_name_for_focus, environment){
+
+  this.checkIfJsFrameworkIsLoaded = function(){
+    if (typeof(Prototype) == "undefined"){
+      alert("Prototype javascript library not loaded, WiceGrid cannot proceed!")
+    }
+  }
+
+
+  this.checkIfJsFrameworkIsLoaded();
+  this.name = name;
+  this.parameter_name_for_query_loading = parameter_name_for_query_loading;
+  this.parameter_name_for_focus = parameter_name_for_focus;
+  this.base_request_for_filter = base_request_for_filter;
+  this.base_link_for_show_all_records = base_link_for_show_all_records;
+  this.link_for_export = link_for_export;
+  this.filter_declarations = new Array();
+  this.environment = environment;
+  
+  this.toString = function(){
+    return "<WiceGridProcessor instance for grid '" + this.name + "'>";
+  }
+
+
+  this.process = function(dom_id_to_focus){
+    window.location = this.build_url_with_params(dom_id_to_focus);
+  }
+
+  this.reload_page_for_given_grid_state = function(grid_state){
+    var request_path = this.grid_state_to_request(grid_state);
+    window.location = this.append_to_url(this.base_link_for_show_all_records, request_path);
+  }
+
+  this.load_query = function(query_id){
+    var request = this.append_to_url(this.build_url_with_params(),
+      (this.parameter_name_for_query_loading +  encodeURIComponent(query_id)));
+    window.location = request;
+  }
+
+  this.save_query = function(query_name, base_path_to_query_controller, grid_state, input_ids){
+    if (input_ids instanceof Array) {
+      input_ids.each(function(dom_id){
+        grid_state.push(['extra[' + dom_id + ']', $F(dom_id)])
+      });
+    }
+    
+    var request_path = this.grid_state_to_request(grid_state);
+    
+    new Ajax.Request(base_path_to_query_controller, {
+      asynchronous:true,
+      evalScripts:true,
+      parameters: request_path + '&query_name=' + encodeURIComponent(query_name)
+    })
+  }
+
+  this.grid_state_to_request = function(grid_state){
+    return res = grid_state.collect(function(pair){
+      return encodeURIComponent(pair[0]) + '=' + encodeURIComponent(pair[1]);
+    }).join('&');
+  }
+
+
+  this.append_to_url = function(url, str){
+    var sep;
+    if (url.include('?')){
+      if (/[&\?]$/.exec(url)){
+        sep = '';
+      }else{
+        sep = '&';
+      }
+    }else{
+      sep = '?';
+    }
+    return url + sep + str;
+  }
+
+
+  this.build_url_with_params = function(dom_id_to_focus){
+    var results = new Array();
+    this.filter_declarations.each(function(filter_declaration){
+      param = this.read_values_and_form_query_string(
+        filter_declaration.filter_name, filter_declaration.detached, 
+        filter_declaration.templates, filter_declaration.ids);
+      if (param && param != ''){
+        results.push(param);
+      }
+    }.bind(this));
+    var res = this.base_request_for_filter;
+    if ( results.length != 0){
+      all_filter_params = results.join('&');
+      res = this.append_to_url(res, all_filter_params);
+    }
+    if (dom_id_to_focus){
+      res = this.append_to_url(res, this.parameter_name_for_focus + dom_id_to_focus);
+    }
+    return res;
+  }
+
+  this.reset = function(){
+    window.location = this.base_request_for_filter;
+  }
+
+  this.export_to_csv = function(){
+    window.location = this.link_for_export;
+  }
+
+
+  this.register = function(func){
+    this.filter_declarations.push(func);
+  }
+
+  this.read_values_and_form_query_string = function(filter_name, detached, templates, ids){
+    var res = new Array();
+    for(i = 0; i < templates.length; i++){
+      if($(ids[i]) == null){
+        if (this.environment == "development"){
+          message = 'WiceGrid: Error reading state of filter "' + filter_name + '". No DOM element with id "' + ids[i] + '" found.'
+          if (detached){
+            message += 'You have declared "' + filter_name + 
+              '" as a detached filter but have not output it anywhere in the template. Read documentation about detached filters.'
+          }
+          alert(message);
+        }
+        return '';
+      }
+      var val = $F(ids[i]);
+      if (val instanceof Array) {
+        for(j = 0; j < val.length; j++){
+          if (val[j] && val[j] != "")
+            res.push(templates[i] + encodeURIComponent(val[j]));
+        }
+      } else if (val && ! val.empty()){
+        res.push(templates[i]  + encodeURIComponent(val));
+      }
+    }
+    return res.join('&');
+  }
+
+};
+
+function toggle_multi_select(select_id, link_obj, expand_label, collapse_label) {
+  var select = $(select_id);
+  if (select.multiple == true) {
+    select.multiple = false;
+    link_obj.title = expand_label;
+  } else {
+    select.multiple = true;
+    link_obj.title = collapse_label;
+  }
+}
+
+WiceGridProcessor._version = '0.4.3';

data/generators/wice_grid_assets_prototype/templates/stylesheets/calendarview.css

@@ -0,0 +1,107 @@
+
+div.calendar
+{
+  font-size: smaller;
+  color: #000;
+  z-index: 5;
+}
+
+div.calendar.popup
+{
+  margin-left: -40px;
+  margin-top: -100px;
+}
+
+div.calendar table
+{
+  background-color: #eee;
+  border: 1px solid #aaa;
+  border-collapse: collapse;
+}
+
+div.calendar thead {
+  background-color: white;
+}
+
+div.calendar td,
+div.calendar th
+{
+  padding: 3px;
+  text-align: center;
+}
+
+div.calendar td.title
+{
+  font-weight: bold;
+}
+
+div.calendar th
+{
+  background: #ddd;
+  border-bottom: 1px solid #ccc;
+  border-top: 1px solid #ccc;
+  font-weight: bold;
+  color: #555;
+}
+
+div.calendar tr.days td {
+  width: 2em;
+  color: #555;
+  text-align: center;
+  cursor: pointer;
+}
+
+div.calendar tr.days td:hover,
+div.calendar td.cvbutton:hover
+{
+  background-color: #34ABFA;
+  cursor: pointer;
+}
+
+
+div.calendar tr td.closeButton:hover
+{
+  background-color: #34ABFA;
+  cursor: pointer;
+}
+
+
+div.calendar tr.days td:active
+div.calendar td.cvbutton:active
+{
+  background-color: #cde;
+}
+
+div.calendar tr.days td.selected
+{
+  font-weight: bold;
+  background-color: #fff;
+  color: #000;
+}
+
+div.calendar tr.days td.today
+{
+  font-weight: bold;
+  color: #D50000;
+}
+
+div.calendar tr.days td.otherDay
+{
+  color: #bbb;
+}
+
+div.calendar .draggableHandler{
+  cursor: move;
+}
+
+/*  styles for the date_picker Rails plugin */
+span.date_picker a.date_label{
+  margin-left: 5px;
+  margin-right: 5px;
+  text-decoration: none;
+}
+span.date_picker a.date_label:hover{text-decoration: line-through;}
+
+span.date_picker span.trigger:hover{
+  cursor: pointer;
+}

data/generators/wice_grid_assets_prototype/wice_grid_assets_prototype_generator.rb

@@ -0,0 +1,37 @@
+class WiceGridAssetsPrototypeGenerator < Rails::Generator::Base
+  def active_js_framework
+    'prototype'
+  end
+  def inactive_js_framework
+    'jquery'
+  end
+
+  def manifest
+    record do |m|
+      # wice_grid config
+      m.directory "config/initializers"
+      m.template "../../common_templates/initializers/wice_grid_config.rb",  "config/initializers/wice_grid_config.rb"
+
+      # wice_grid locales
+      m.directory "config/locales"
+      m.file "../../common_templates/locales/wice_grid.yml",  "config/locales/wice_grid.yml"
+
+      # wice_grid js & css
+      m.file "javascripts/wice_grid_prototype.js",  "public/javascripts/wice_grid.js"
+      m.file "../../common_templates/stylesheets/wice_grid.css",  "public/stylesheets/wice_grid.css"
+
+      # calendarview js & css
+      m.file "javascripts/calendarview.js",  "public/javascripts/calendarview.js"
+      m.file "stylesheets/calendarview.css",  "public/stylesheets/calendarview.css"
+
+      # images
+      m.directory "public/images/icons/grid"
+      
+      %w(arrow_down.gif calendar_view_month.png expand.png page_white_find.png table_refresh.png  
+        arrow_up.gif delete.png page_white_excel.png  table.png tick_all.png untick_all.png ).each do |f|
+          m.file "../../common_templates/icons/#{f}",  "public/images/icons/grid/#{f}"
+      end
+      
+    end
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require 'wice_grid.rb'

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/grid_output_buffer.rb

@@ -0,0 +1,52 @@
+# encoding: UTF-8
+module Wice
+
+  class GridOutputBuffer < String #:nodoc:
+
+    attr_reader :stubborn_output_mode
+    attr_accessor :return_empty_strings_for_nonexistent_filters
+
+    def stubborn_output_mode=(m)
+      RAILS_DEFAULT_LOGGER.debug("=== WiceGrid: detached filters are requested, postponing output till the second call of the view helper") if m
+      @stubborn_output_mode = m
+    end
+
+    def initialize(*attrs)
+      super(*attrs)
+      @filters = HashWithIndifferentAccess.new
+      @first_output = false
+      @stubborn_output_mode = false
+    end
+
+    def to_s
+      if @first_output || ! @stubborn_output_mode
+        super.html_safe_if_necessary
+      else
+        @first_output = true
+        ''
+      end
+    end
+
+    def add_filter(detach_with_id, filter_code)
+      raise  WiceGridException.new("Detached ID #{detach_with_id} is already used!") if @filters.has_key? detach_with_id
+      @filters[detach_with_id] = filter_code
+    end
+
+    def filter_for detach_with_id
+      unless @filters.has_key? detach_with_id
+        if @return_empty_strings_for_nonexistent_filters
+          return ''
+        else
+          raise  WiceGridException.new("No filter with Detached ID '#{detach_with_id}'!")
+        end
+      end
+      raise  WiceGridException.new("Filter with Detached ID '#{detach_with_id}' has already been requested once! There cannot be two instances of the same filter on one page") if @filters[detach_with_id] == false
+      res = @filters[detach_with_id]
+      @filters[detach_with_id] = false
+      return res
+    end
+
+    alias_method :[], :filter_for
+
+  end
+end

data/lib/grid_renderer.rb

@@ -0,0 +1,531 @@
+# encoding: UTF-8
+module Wice
+  class GridRenderer
+
+    include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::CaptureHelper
+    include ActionView::Helpers::TextHelper
+    include ActionView::Helpers::AssetTagHelper
+    include ActionView::Helpers::JavaScriptHelper
+    include ::WillPaginate::ViewHelpers
+
+    attr_reader :page_parameter_name
+    attr_reader :after_row_handler
+    attr_reader :before_row_handler
+    attr_reader :blank_slate_handler
+    attr_reader :grid
+    attr_accessor :erb_mode
+
+    attr_accessor :reset_button_present, :submit_button_present, :show_hide_button_present, :csv_export_icon_present
+
+    @@order_parameter_name = "order"
+    @@order_direction_parameter_name = "order_direction"
+    @@page_parameter_name = "page"
+
+    def initialize(grid, view)  #:nodoc:
+      @grid = grid
+      @grid.renderer = self
+      @columns = []
+      @columns_table = {}
+      @action_column_present = false
+      @view = view
+    end
+
+    def add_column(vc)  #:nodoc:
+      @columns_table[vc.fully_qualified_attribute_name] = vc if vc.attribute_name
+      @columns << vc
+    end
+
+    def [](k)  #:nodoc:
+      @columns_table[k]
+    end
+
+    def number_of_columns(filter = nil)  #:nodoc:
+      filter_columns(filter).size
+    end
+
+    def each_column_label(filter = nil)  #:nodoc:
+      filter_columns(filter).each{|col| yield col.column_name}
+    end
+
+    def column_labels(filter = nil)  #:nodoc:
+      filter_columns(filter).collect(&:column_name)
+    end
+
+    def each_column(filter = nil)  #:nodoc:
+      filter_columns(filter).each{|col| yield col}
+    end
+
+    def contains_a_text_input?  #:nodoc:
+      filter_columns(:in_html).detect(&:contains_a_text_input)
+    end
+
+    def each_column_aware_of_one_last_one(filter = nil)  #:nodoc:
+      cols = filter_columns(filter)
+      cols[0..-2].each{|col| yield col, false}
+      yield cols.last, true
+    end
+
+    def last_column_for_html  #:nodoc:
+      filter_columns(:in_html).last
+    end
+
+    def select_for(filter)  #:nodoc:
+      filter_columns(filter).select{|col| yield col}
+    end
+
+    def find_one_for(filter)  #:nodoc:
+      filter_columns(filter).find{|col| yield col}
+    end
+
+
+    def each_column_with_attribute  #:nodoc:
+      @columns.select(&:attribute_name).each{|col| yield col}
+    end
+
+    alias_method :each, :each_column
+    include Enumerable
+
+    def csv_export_icon #:nodoc:
+      tooltip = WiceGridNlMessageProvider.get_message(:CSV_EXPORT_TOOLTIP)
+      @csv_export_icon_present = true
+      image_tag(Defaults::CSV_EXPORT_ICON,
+        :title => tooltip,
+        :class => 'clickable export_to_csv_button',
+        :alt   => tooltip
+      )
+    end
+
+    def pagination_panel(no_rightmost_column, hide_csv_button)  #:nodoc:
+      panel = yield
+
+      render_csv_button = @grid.export_to_csv_enabled && ! hide_csv_button
+
+      number_of_columns = self.number_of_columns(:in_html)
+      number_of_columns -= 1 if no_rightmost_column
+
+      if panel.nil?
+        if render_csv_button
+          "<tr><td colspan=\"#{number_of_columns}\"></td><td>#{csv_export_icon}</td></tr>"
+        else
+          ''
+        end
+      else
+        if render_csv_button
+          "<tr><td colspan=\"#{number_of_columns}\">#{panel}</td><td>#{csv_export_icon}</td></tr>"
+        else
+          "<tr><td colspan=\"#{number_of_columns + 1}\">#{panel}</td></tr>"
+        end
+      end
+    end
+
+    def element_to_focus  #:nodoc:
+      grid.status['foc']
+    end
+
+
+    # Adds a column with checkboxes for each record. Useful for actions with multiple records, for example, deleting
+    # selected records. Please note that +action_column+ only creates the checkboxes and the 'Select All' and
+    # 'Deselect All' buttons, and the form itelf as well as processing the parameters should be taken care of
+    # by the application code.
+    #
+    # * <tt>:param_name</tt> - The name of the HTTP parameter.
+    #   The complete HTTP parameter is <tt>"#{grid_name}[#{param_name}][]"</tt>.
+    #   The default param_name is 'selected'.
+    # * <tt>:td_html_attrs</tt> - a hash of HTML attributes to be included into the <tt>td</tt> tag.
+    # * <tt>:select_all_buttons</tt> - show/hide buttons 'Select All' and 'Deselect All' in the column header.
+    #   The default is +true+.
+    # * <tt>:object_property</tt> - a method used to obtain the value for the HTTP parameter. The default is +id+.
+    def action_column(opts = {})
+
+      if @action_column_present
+        raise Wice::WiceGridException.new('There can be only one action column in a WiceGrid')
+      end
+
+      options = {
+        :param_name     => :selected,
+        :td_html_attrs  => {},
+        :select_all_buttons => true,
+        :object_property => :id
+      }
+
+      opts.assert_valid_keys(options.keys)
+      options.merge!(opts)
+      @action_column_present = true
+      @columns << ActionViewColumn.new(@grid, options[:td_html_attrs], options[:param_name],
+            options[:select_all_buttons], options[:object_property], @view)
+    end
+
+    # Defines everything related to a column in a grid - column name, filtering, rendering cells, etc.
+    #
+    # +column+ is only used inside the block of the +grid+ method. See documentation for the +grid+ method for more details.
+    #
+    # The only parameter is a hash of options. None of them is optional. If no options are supplied, the result will be a
+    # column with no name, no filtering and no sorting.
+    #
+    # * <tt>:column_name</tt> - Name of the column.
+    # * <tt>:td_html_attrs</tt> - a hash of HTML attributes to be included into the <tt>td</tt> tag.
+    # * <tt>:class</tt> - a shortcut for <tt>:td_html_attrs => {:class => 'css_class'}</tt>
+    # * <tt>:attribute_name</tt> - name of a database column (which normally correspond to a model attribute with the
+    #   same name). By default the field is assumed to belong to the default table (see documentation for the
+    #   +initialize_grid+ method). Parameter <tt>:model_class</tt> allows to specify another table. Presence of
+    #   this parameter
+    #   * adds sorting capabilities by this field
+    #   * automatically creates a filter based on the type of the field unless parameter <tt>:no_filter</tt> is set to true.
+    #     The following filters exist for the following types:
+    #     * <tt>string</tt> - a text field
+    #     * <tt>integer</tt> and <tt>float</tt>  - two text fields to specify the range. Both limits or only one
+    #       can be specified
+    #     * <tt>boolean</tt> - a dropdown list with 'yes', 'no', or '-'. These labels can be changed in
+    #       <tt>lib/wice_grid_config.rb</tt>.
+    #     * <tt>date</tt> - two sets of standard date dropdown lists so specify the time range.
+    #     * <tt>datetime</tt> - two sets of standard datetime dropdown lists so specify the time range. This filter
+    #       is far from being user-friendly due to the number of dropdown lists.
+    # * <tt>:no_filter</tt> - Turns off filters even if <tt>:attribute_name</tt> is specified.
+    #   This is needed if sorting is required while  filters are not.
+    # * <tt>:allow_ordering</tt> - Enable/disable ordering links in the column titles. The default is +true+
+    #   (i.e. if <tt>:attribute_name</tt> is defined, ordering is enabled)
+    # * <tt>:model_class</tt> - Name of the model class to which <tt>:attribute_name</tt> belongs to if this is not the main table.
+    # * <tt>:table_alias</tt> - In case there are two joined assocations both referring to the same table, ActiveRecord
+    #   constructs a query where the second join provides an alias for the joined table. Setting <tt>:table_alias</tt>
+    #   to this alias will enable WiceGrid to order and filter by columns belonging to different associatiations  but
+    #   originating from the same table without confusion. See README for an example.
+    # * <tt>:custom_filter</tt> - Allows to construct a custom dropdown filter. Depending on the value of
+    #   <tt>:custom_filter</tt> different modes are available:
+    #   * array of strings and/or numbers - this is a direct  definition of possible values of the dropdown.
+    #     Every item will be used both as the value of the select option and as its label.
+    #   * Array of two-element arrays - Every first item of the two-element array is used for the label of the select option
+    #     while the second element is the value of the select option
+    #   * Hash - The keys of the hash become the labels of the generated dropdown list,
+    #     while the values will be values of options of the dropdown list:
+    #   * <tt>:auto</tt> - a powerful option which populates the dropdown list with all unique values of the field specified by
+    #     <tt>:attribute_name</tt> and <tt>:model_class</tt>.
+    #     <tt>:attribute_name</tt> throughout all pages. In other words, this runs an SQL query without +offset+ and +limit+
+    #     clauses and  with <tt>distinct(table.field)</tt> instead of <tt>distinct(*)</tt>
+    #   * any other symbol name (method name) - The dropdown list is populated by all unique value returned by the
+    #     method with this name sent to <em>all</em> ActiveRecord objects throughout all pages. The main difference
+    #     from <tt>:auto</tt> is that this method does not have to be a field in the result set, it is just some
+    #     value computed in the method after the database call and ActiveRecord instantiation.
+    #
+    #     But here lies the major drawback - this mode requires additional query without +offset+ and +limit+
+    #     clauses to instantiate _all_ ActiveRecord objects, and performance-wise it brings all the advantages
+    #     of pagination to nothing. Thus, memory- and performance-wise this can be really bad for some queries
+    #     and tables and should be used with care.
+    #
+    #     If the method returns a atomic value like a string or an integer, it is used for both the value and the
+    #     label of the select option element. However, if the retuned value is a two element array, the first element
+    #     is used for the option label and the second - for the value.
+    #     Read more in README, section 'Custom dropdown filters'
+    #   * An array of symbols (method names) - similar to the mode with a single symbol name. The first method name
+    #     is sent to the ActiveRecord object if it responds to this method, the second method name is sent to the
+    #     returned value unless it is +nil+, and so on. In other words, a single symbol mode is a
+    #     case of an array of symbols where the array contains just one element. Thus the warning about the single method name
+    #     mode applies here as well.
+    #
+    #     If the last method returns a atomic value like a string or an integer, it is used for both the value and the
+    #     label of the select option element.
+    #     However, if the retuned value is a two element array, the first element is used for the option label and the
+    #     second - for the value.
+    #     Read more in README, section 'Custom dropdown filters'
+    # * <tt>:boolean_filter_true_label</tt> - overrides the default value for <tt>BOOLEAN_FILTER_TRUE_LABEL</tt>
+    #   ('+yes+') in the config.
+    #   Only has effect in a column with a boolean filter.
+    # * <tt>:boolean_filter_false_label</tt> - overrides the default value for <tt>BOOLEAN_FILTER_FALSE_LABEL</tt>
+    #   ('+no+') in the config.
+    #   Only has effect in a column with a boolean filter.
+    # * <tt>:allow_multiple_selection</tt> - enables or disables switching between single and multiple selection modes for
+    #   custom dropdown boxes. +true+ by default (see +ALLOW_MULTIPLE_SELECTION+ in the configuration file).
+    # * <tt>:filter_all_label</tt> - overrides the default value for <tt>BOOLEAN_FILTER_FALSE_LABEL</tt> ('<tt>--</tt>')
+    #   in the config. Has effect in a column with a boolean filter _or_ a custom filter.
+    # * <tt>:detach_with_id</tt> - allows to detach the filter and render it after or before the grid with the
+    #   +grid_filter+ helper. The value is an arbitrary unique identifier
+    #   of the filter. Read section 'Detached Filters' in README for details.
+    #   Has effect in a column with a boolean filter _or_ a custom filter.
+    # * <tt>:in_csv</tt> - When CSV export is enabled, all columns are included into the export. Setting <tt>:in_csv</tt>
+    #   to false will prohibit the column from inclusion into the export.
+    # * <tt>:in_html</tt> - When CSV export is enabled and it is needed to use a column for CSV export only and ignore it
+    #   in HTML, set this parameter to false.
+    # * <tt>:helper_style</tt> - Changes the flavor of Date and DateTime filters. The values are:
+    #   * <tt>:standard</tt> - the default Rails Date/DateTime helper
+    #   * <tt>:calendar</tt> - a Javascript popup calendar control
+    # * <tt>:negation_in_filter</tt> - turn on/off the negation checkbox in string filters
+    # * <tt>:auto_reload</tt> - a boolean value specifying if a change in a filter triggers reloading of the grid. Works with all
+    #   filter types including the JS calendar, the only exception is the standard Rails date/datetime filters. 
+    #   The default is false. (see +AUTO_RELOAD+ in the configuration file).
+    #
+    # The block parameter is an ActiveRecord instance. This block is called for every ActiveRecord shown, and the return
+    # value of the block is a string which becomes the contents of one table cell, or an array of two elements where
+    # the first element is the cell contents and the second is a hash of HTML attributes to be added for the <tt><td></tt>
+    # tag of the current cell.
+    #
+    # In case of an array output, please note that if you need to define HTML attributes for all <tt><td></tt>'s in a
+    # column, use +td_html_attrs+. Also note that if the method returns a hash with a <tt>:class</tt> or <tt>'class'</tt>
+    # element, it will not overwrite the class defined in +td_html_attrs+, or classes added by the grid itself
+    # (+active_filter+ and +sorted+), instead they will be all concatenated:
+    # <tt><td class="sorted user_class_for_columns user_class_for_this_specific_cell"></tt>
+    #
+    # It is up to the developer to make sure that what in rendered in column cells
+    # corresponds to sorting and filtering specified by parameters <tt>:attribute_name</tt> and <tt>:model_class</tt>.
+
+    def column(opts = {}, &block)
+      options = {
+        :allow_multiple_selection   => Defaults::ALLOW_MULTIPLE_SELECTION,
+        :allow_ordering             => true,
+        :attribute_name             => nil,
+        :auto_reload                => Defaults::AUTO_RELOAD,
+        :boolean_filter_false_label => WiceGridNlMessageProvider.get_message(:BOOLEAN_FILTER_FALSE_LABEL),
+        :boolean_filter_true_label  => WiceGridNlMessageProvider.get_message(:BOOLEAN_FILTER_TRUE_LABEL),
+        :class                      => nil,
+        :column_name                => '',
+        :custom_filter              => nil,
+        :custom_order               => nil,
+        :detach_with_id             => nil,
+        :filter_all_label           => Defaults::CUSTOM_FILTER_ALL_LABEL,
+        :helper_style               => Defaults::HELPER_STYLE,
+        :in_csv                     => true,
+        :in_html                    => true,
+        :model_class                => nil,
+        :negation_in_filter         => Defaults::NEGATION_IN_STRING_FILTERS,
+        :no_filter                  => false,
+        :table_alias                => nil,
+        :td_html_attrs              => {}
+      }
+
+      opts.assert_valid_keys(options.keys)
+      options.merge!(opts)
+
+      unless options[:model_class].nil?
+        options[:model_class] = options[:model_class].constantize if options[:model_class].is_a? String
+        raise WiceGridArgumentError.new("Option :model_class can be either a class or a string instance") unless options[:model_class].is_a? Class
+      end
+
+      if options[:attribute_name].nil? && options[:model_class]
+        raise WiceGridArgumentError.new("Option :model_class is only used together with :attribute_name")
+      end
+
+      if options[:attribute_name] && options[:attribute_name].index('.')
+        raise WiceGridArgumentError.new("Invalid attribute name #{options[:attribute_name]}. An attribute name must not contain a table name!")
+      end
+
+      if options[:class]
+        options[:td_html_attrs].add_or_append_class_value!(options[:class])
+        options.delete(:class)
+      end
+
+      if block.nil?
+        if ! options[:attribute_name].blank?
+          block = lambda{|obj| obj.send(options[:attribute_name])}
+        else
+          raise WiceGridArgumentError.new(
+            "Missing column block without attribute_name defined. You can only omit the block if attribute_name is present.")
+        end
+      end
+
+      klass = ViewColumn
+      if options[:attribute_name] &&
+          col_type_and_table_name = @grid.declare_column(options[:attribute_name], options[:model_class],
+            options[:custom_filter],  options[:table_alias])
+
+        db_column, table_name, main_table = col_type_and_table_name
+        col_type = db_column.type
+
+        if options[:custom_filter]
+
+          custom_filter = if options[:custom_filter] == :auto
+            lambda{ @grid.distinct_values_for_column(db_column) } # Thank God Ruby has higher order functions!!!
+
+          elsif options[:custom_filter].class == Symbol
+            lambda{ @grid.distinct_values_for_column_in_resultset([options[:custom_filter]])}
+
+          elsif options[:custom_filter].class == Hash
+            options[:custom_filter].keys
+
+            options[:custom_filter].to_a
+
+          elsif options[:custom_filter].class == Array
+            if options[:custom_filter].empty?
+              []
+            elsif options[:custom_filter].all_items_are_of_class(Symbol)
+              lambda{ @grid.distinct_values_for_column_in_resultset(options[:custom_filter]) }
+
+            elsif options[:custom_filter].all_items_are_of_class(String) || options[:custom_filter].all_items_are_of_class(Numeric)
+              options[:custom_filter].map{|i| [i,i]}
+
+            elsif options[:custom_filter].all_items_are_of_class(Array)
+              options[:custom_filter]
+            else
+              raise WiceGridArgumentError.new(
+                ':custom_filter can equal :auto, an array of string and/or numbers (direct values for the dropdown), ' +
+                'a homogeneous array of symbols (a sequence of methods to send to AR objects in the result set to ' +
+                'retrieve unique values for the dropdown), a Symbol (a shortcut for a one member array of symbols), ' +
+                'a hash where keys are labels and values are values for the dropdown option, or an array of two-item arrays, ' +
+                'each of which contains the label (first element) and the value (second element) for a dropdown option'
+                )
+            end
+          end
+
+          klass = ViewColumnCustomDropdown
+        else
+          klass = ViewColumn.handled_type[col_type] || ViewColumn
+        end # custom_filter
+      end # attribute_name
+
+      vc = klass.new(block, options, @grid, table_name, main_table, custom_filter, @view)
+
+      vc.negation    = options[:negation_in_filter] if vc.respond_to? :negation=
+
+      vc.filter_all_label = options[:filter_all_label] if vc.kind_of?(ViewColumnCustomDropdown)
+      if vc.kind_of?(ViewColumnBoolean)
+        vc.boolean_filter_true_label = options[:boolean_filter_true_label]
+        vc.boolean_filter_false_label = options[:boolean_filter_false_label]
+      end
+      add_column(vc)
+    end
+
+    # Optional method inside the +grid+ block, to which every ActiveRecord instance is injected, just like +column+.
+    # Unlike +column+, it returns a hash which will be used as HTML attributes for the row with the given ActiveRecord instance.
+    #
+    # Note that if the method returns a hash with a <tt>:class</tt> or <tt>'class'</tt> element, it will not overwrite
+    # classes +even+ and +odd+, instead they will be concatenated: <tt><tr class="even highlighted_row_class_name"></tt>
+    def row_attributes(&block)
+      @row_attributes_handler = block
+    end
+
+    # Can be used to add HTML code (another row, for example) right after each grid row.
+    # Nothing is added if the block return +false+ or +nil+.
+    def after_row(&block)
+      @after_row_handler = block
+    end
+
+    # Can be used to add HTML code (another row, for example) right before each grid row.
+    # Nothing is added if the block return +false+ or +nil+.
+    def before_row(&block)
+      @before_row_handler = block
+    end
+
+    # The output of the block submitted to +blank_slate+ is rendered instead of the whole grid if no filters are active
+    # and there are no records to render.
+    # In addition to the block style two other variants are accepted:
+    # *   <tt>g.blank_slate "some text to be rendered"</tt>
+    # *   <tt>g.blank_slate :partial => "partial_name"</tt>
+    def blank_slate(opts = nil, &block)
+      if (opts.is_a?(Hash) && opts.has_key?(:partial) && block.nil?) || (opts.is_a?(String) && block.nil?)
+        @blank_slate_handler = opts
+      elsif opts.nil? && block
+        @blank_slate_handler = block
+      else
+        raise WiceGridArgumentError.new("blank_slate accepts only a string, a block, or :template => 'path_to_template' ")
+      end
+    end
+
+
+    def get_row_attributes(ar_object) #:nodoc:
+      if @row_attributes_handler
+        row_attributes = @row_attributes_handler.call(ar_object)
+        row_attributes = {} if row_attributes.blank?
+        unless row_attributes.is_a?(Hash)
+          raise WiceGridArgumentError.new("row_attributes block must return a hash containing HTML attributes. The returned value is #{row_attributes.inspect}")
+        end
+        row_attributes
+      else
+        {}
+      end
+    end
+
+
+    def no_filter_needed?   #:nodoc:
+      not @columns.inject(false){|a,b| a || b.filter_shown? }
+    end
+
+    def no_filter_needed_in_main_table?   #:nodoc:
+      not @columns.inject(false){|a,b| a || b.filter_shown_in_main_table? }
+    end
+
+    def base_link_for_filter(controller, extra_parameters = {})   #:nodoc:
+      new_params = controller.params.deep_clone_yl
+      new_params.merge!(extra_parameters)
+
+      if new_params[@grid.name]
+        new_params[@grid.name].delete(:page) # we reset paging here
+        new_params[@grid.name].delete(:f)    # no filter for the base url
+        new_params[@grid.name].delete(:foc)  # nullify the focus
+        new_params[@grid.name].delete(:q)    # and no request for the saved query
+      end
+
+      new_params[:only_path] = false
+      base_link_with_pp_info = controller.url_for(new_params).gsub(/\?+$/,'')
+
+      if new_params[@grid.name]
+        new_params[@grid.name].delete(:pp)    # and reset back to pagination if show all mode is on
+      end
+      [base_link_with_pp_info, controller.url_for(new_params).gsub(/\?+$/,'')]
+    end
+
+
+
+    def link_for_export(controller, format, extra_parameters = {})   #:nodoc:
+      new_params = controller.params.deep_clone_yl
+      new_params.merge!(extra_parameters)
+
+      new_params[@grid.name] = {} unless new_params[@grid.name]
+      new_params[@grid.name][:export] = format
+
+      new_params[:only_path] = false
+      controller.url_for(new_params)
+    end
+
+
+    def column_link(column, direction, params, extra_parameters = {})   #:nodoc:
+
+      column_attribute_name = if column.attribute_name.index('.') or column.main_table
+        column.attribute_name
+      else
+        column.table_alias_or_table_name + '.' + column.attribute_name
+      end
+
+      query_params = {@grid.name => {
+        @@order_parameter_name => column_attribute_name,
+        @@order_direction_parameter_name => direction
+      }}
+
+      cleaned_params =  params.deep_clone_yl
+      cleaned_params.merge!(extra_parameters)
+
+      cleaned_params.delete(:controller)
+      cleaned_params.delete(:action)
+
+
+      query_params = cleaned_params.rec_merge(query_params)
+
+      '?' + query_params.to_query
+    end
+
+    def contains_auto_reloading_inputs #:nodoc:
+      contains_auto_reloading_elements(:has_auto_reloading_input?)
+    end
+
+    def contains_auto_reloading_inputs_with_negation_checkboxes #:nodoc:
+      contains_auto_reloading_elements(:auto_reloading_input_with_negation_checkbox?)
+    end
+
+    def contains_auto_reloading_selects #:nodoc:
+      contains_auto_reloading_elements(:has_auto_reloading_select?)
+    end
+
+    def contains_auto_reloading_calendars #:nodoc:
+      contains_auto_reloading_elements(:has_auto_reloading_calendar?)
+    end
+
+    protected
+
+    def contains_auto_reloading_elements(what) #:nodoc:
+      filter_columns(:in_html).detect{|column| column.filter_shown? && column.send(what)}
+    end
+
+
+    def filter_columns(method_name = nil) #:nodoc:
+      method_name ? @columns.select(&method_name) : @columns
+    end
+
+  end
+end