mongoid_wice_grid 4.0.0

data/lib/helpers/js_calendar_helpers.rb

@@ -0,0 +1,183 @@
+module Wice
+  module JsCalendarHelpers
+
+    # Jquery
+
+    def date_calendar_jquery(initial_date, view, opts = {}, html_opts = {})  #:nodoc:
+      date_format = Wice::Defaults::DATE_FORMAT
+
+      options, name, date_string, dom_id, datepicker_placeholder_id, date_span_id =
+        prepare_data_for_calendar(opts, date_format, initial_date)
+
+      remove_date_function = %! $('##{date_span_id}').html(''); $('##{dom_id}')[0].value = ''; !
+
+      date_picker =
+
+        hidden_field_tag(name, date_string, :id => dom_id) + ' ' +
+
+        link_to_function(
+          content_tag(:span, date_string, :id => date_span_id),
+          remove_date_function,
+          :class => 'date_label',
+          :title => ::Wice::WiceGridNlMessageProvider.get_message(:DATE_STRING_TOOLTIP))
+
+      html = "<span id=\"#{datepicker_placeholder_id}\">#{date_picker}</span>"
+
+      javascript = calendar_constructor_jquery(dom_id, view, Wice::Defaults::DATE_FORMAT_JQUERY,
+        date_span_id, opts[:fire_event], html_opts[:title], datepicker_placeholder_id)
+
+      [html, javascript]
+    end
+
+    # Prototype
+    def date_calendar_prototype(initial_date, view, opts = {}, html_opts = {})  #:nodoc:
+      select_date_datetime_common_prototype(initial_date, view, opts, html_opts, false, Wice::Defaults::DATE_FORMAT)
+    end
+
+    def datetime_calendar_prototype(initial_date, view, opts = {}, html_opts = {})  #:nodoc:
+      select_date_datetime_common_prototype(initial_date, view, opts, html_opts, true, Wice::Defaults::DATETIME_FORMAT)
+    end
+
+    protected
+
+    # common
+
+    def prepare_data_for_calendar(opts, date_format, initial_date)  #:nodoc:
+      options = {:prefix => 'date'}
+      options.merge!(opts)
+      name = options[:prefix]
+      date_string = initial_date.nil? ? '' : initial_date.strftime(date_format)
+      dom_id = options[:id] || name.gsub(/([\[\(])|(\]\[)/, '_').gsub(/[\]\)]/, '').gsub(/\./, '_').gsub(/_+/, '_')
+      datepicker_placeholder_id = dom_id + '_date_placeholder'
+      date_span_id = dom_id + '_date_view'
+
+      return options, name, date_string, dom_id, datepicker_placeholder_id, date_span_id
+    end
+
+    # jquery
+
+    def calendar_constructor_jquery(dom_id, view, date_format, date_span_id, fireEvent, title, datepicker_placeholder_id)
+
+      javascript  =  %| $( "##{dom_id}" ).datepicker({\n|
+      javascript <<  %|   firstDay: 1,\n|
+      javascript <<  %|   showOn: "button",\n|
+      javascript <<  %|   dateFormat: "#{date_format}",\n|
+      javascript <<  %|   buttonImage: "#{::Wice::Defaults::CALENDAR_ICON}",\n|
+      javascript <<  %|   buttonImageOnly: true,\n|
+      javascript <<  %|   buttonText: "#{title}",\n|
+      javascript <<  %|   changeMonth: true,\n|
+      javascript <<  %|   changeYear: true,\n|
+      javascript <<  %|   onSelect: function(dateText, inst) {\n|
+      javascript <<  %|     $("##{date_span_id}").html(dateText);\n|
+      if fireEvent
+        javascript <<  %|     $("##{dom_id}").trigger('wg:calendarChanged');\n|
+      end
+      javascript <<  %|   }\n|
+      javascript <<  %| });\n|
+
+      lang = Object.const_defined?(:I18n) ? I18n.locale : nil
+
+      if Rails.env == 'development'
+        unless view.respond_to? :datepicker_check_done
+
+          javascript <<  %| if (! $.datepicker ){\n|
+          javascript <<  %|    alert("Seems like you do not have jQuery datepicker (http://jqueryui.com/demos/datepicker/)|
+          javascript <<  %| installed. Either install it or set Wice::Defaults::HELPER_STYLE to :standard in |
+          javascript <<  %| wice_grid_config.rb in order to use standard Rails date helpers")\n|
+          javascript <<  %| }\n|
+
+          def view.datepicker_check_done
+          end
+        end
+      end
+
+      if lang
+        unless view.respond_to? :wg_calendar_lang_set
+
+          javascript <<  %| wgCalendarLangRegionalOptions = $.datepicker.regional['#{lang}'];\n|
+          javascript <<  %| if (wgCalendarLangRegionalOptions){\n|
+          javascript <<  %|   delete wgCalendarLangRegionalOptions.dateFormat ;\n|
+          javascript <<  %|   delete wgCalendarLangRegionalOptions.firstDate ;\n|
+          javascript <<  %| }\n|
+
+          def view.wg_calendar_lang_set
+          end
+        end
+        javascript <<  %| if (wgCalendarLangRegionalOptions){\n|
+        javascript <<  %|   $( "##{dom_id}" ).datepicker("option", wgCalendarLangRegionalOptions);\n|
+        javascript <<  %| }\n|
+      end
+
+      javascript += %| $('##{datepicker_placeholder_id} .ui-datepicker-trigger').addClass('clickable');\n|
+
+      javascript
+    end
+
+    # prortotype
+
+    def calendar_constructor_prototype(popup_trigger_icon_id, view, dom_id, date_format, 
+                                      date_span_id, with_time, fireEvent)
+      javascript = ''
+
+      unless view.respond_to? :wg_calendar_lang_set
+        lang = Object.const_defined?(:I18n) ? I18n.locale : nil
+        javascript << %|    Calendar.language = '#{lang}';\n| unless lang.blank?
+
+        def view.wg_calendar_lang_set
+        end
+      end
+
+
+      javascript <<  %|    new Calendar({\n |
+      javascript << %|      popupTriggerElement : "#{popup_trigger_icon_id}",\n |
+      javascript << %|      initialDate : $('#{dom_id}').value,\n |
+      if fireEvent
+        javascript << %|      onHideCallback : function(){Event.fire($(#{dom_id}), 'wg:calendarChanged')},\n |
+      end
+      javascript << %|      dateFormat : "#{date_format}",\n|
+      unless Wice::Defaults::POPUP_PLACEMENT_STRATEGY == :trigger
+        javascript << %|      popupPositioningStrategy : "#{Wice::Defaults::POPUP_PLACEMENT_STRATEGY}",\n|
+      end
+      if with_time
+        javascript << %|        withTime : true,\n|
+      end
+      javascript << %|      outputFields : $A(['#{date_span_id}', '#{dom_id}'])\n |
+      javascript << %|    });\n|
+
+      javascript
+    end
+
+    def select_date_datetime_common_prototype(initial_date, view, opts, html_opts, with_time, date_format)  #:nodoc:
+
+      options, name, date_string, dom_id, datepicker_placeholder_id, date_span_id =
+        prepare_data_for_calendar(opts, date_format, initial_date)
+
+      popup_trigger_icon_id = dom_id + '_trigger'
+
+      function = %! $('#{date_span_id}').innerHTML = ''; $('#{dom_id}').value = ''; !
+      if opts[:fire_event]
+        function += "Event.fire($(#{dom_id}), 'wg:calendarChanged')"
+      end
+
+      date_picker = image_tag(Defaults::CALENDAR_ICON,
+        :id => popup_trigger_icon_id,
+        :class => 'clickable',
+        :title => html_opts[:title]) +
+
+      link_to_function(
+        content_tag(:span, date_string, :id => date_span_id),
+        function,
+        :class => 'date_label',
+        :title => WiceGridNlMessageProvider.get_message(:DATE_STRING_TOOLTIP)) + ' ' +
+
+        hidden_field_tag(name, date_string, :class => 'text-input', :id => dom_id)
+
+      html = "<span id=\"#{datepicker_placeholder_id}\">#{date_picker}</span>"
+
+      javascript = calendar_constructor_prototype(popup_trigger_icon_id, view, dom_id, date_format, date_span_id, with_time, opts[:fire_event])
+
+      [html, javascript]
+    end
+
+  end
+end

data/lib/helpers/wice_grid_misc_view_helpers.rb

@@ -0,0 +1,113 @@
+# encoding: UTF-8
+module Wice
+  module GridViewHelper
+
+
+    # This method dumps all HTTP parameters related to filtering and ordering of a certain grid as hidden form fields.
+    # This might be required if you want to keep the state of a grid while reloading the page using other forms.
+    #
+    # The only parameter is a grid object returned by +initialize_grid+ in the controller.
+    def dump_filter_parameters_as_hidden_fields(grid)
+      unless grid.kind_of? WiceGrid
+        raise WiceGridArgumentError.new("dump_filter_parameters_as_hidden_fields: the parameter must be a WiceGrid instance.")
+      end
+
+      grid.get_state_as_parameter_value_pairs(true).collect{|param_name, value|
+        hidden_field_tag(param_name, value)
+      }.join("\n").html_safe_if_necessary
+    end
+
+    def dump_state(grid)  #:nodoc:
+      debug(grid.get_state_as_parameter_value_pairs)
+    end
+
+
+    # secret but stupid weapon - takes an ActiveRecord and using reflection tries to build all the column clauses by itself.
+    # WiceGrid is not a scaffolding solution, I hate scaffolding and how certain idiots associate scaffolding with Rails,
+    # so I do not document this method to avoid contributing to this misunderstanding.
+    def scaffolded_grid(grid_obj, opts = {}) #:nodoc:
+      unless grid_obj.kind_of? WiceGrid
+        raise WiceGridArgumentError.new("scaffolded_grid: the parameter must be a WiceGrid instance.")
+      end
+
+      # debug grid.klass.column_names
+      columns = grid_obj.klass.column_names
+      if opts[:reject_attributes].is_a? Proc
+        columns = columns.reject{|c| opts[:reject_attributes].call(c)}
+        opts.delete(:reject_attributes)
+      elsif
+        columns = columns.reject{|c| c =~ opts[:reject_attributes]}
+        opts.delete(:reject_attributes)
+      end
+      grid(grid_obj, opts) do |g|
+        columns.each do |column_name|
+          g.column :column_name => column_name.humanize, :attribute_name => column_name  do |ar|
+            ar.send(column_name)
+          end
+        end
+      end
+    end
+
+    # View helper to include all stylesheets and javascript files needed for WiceGrid to function. Add it to template/layout in the
+    # page header section.
+    #
+    # By default the helper returns WiceGrid javascripts and stylesheets include statements only on demand, that is, only if at least one initialize_grid has been
+    # called in the controller. Otherwise the helper returns an empty string. However, you can force the old unconditioned behavior if you need by submitting
+    # parameter <tt>:load_on_demand</tt> set to +false+:
+    #     <%= include_wice_grid_assets(:load_on_demand => false) %>
+    #
+    # By default +include_wice_grid_assets+ adds include statements for the javascript calendar widget used for date/datetime filters,
+    # but it's possible not to include them setting parameter +include_calendar+ to false:
+    #     <%= include_wice_grid_assets(:include_calendar => false) %>
+    def include_wice_grid_assets(options = {})
+      opts = {:include_calendar => true, :load_on_demand => true}
+      options.assert_valid_keys(opts.keys)
+      opts.merge!(options)
+
+      if @__wice_grid_on_page || ! opts[:load_on_demand]
+        javascript_include_tag('wice_grid') +
+        stylesheet_link_tag('wice_grid') +
+        if opts[:include_calendar]
+          JsAdaptor.js_framework_specific_calendar_assets(self)
+        else
+          ''
+        end
+      end
+    end
+
+    #  Returns a list of names of javascript files for WiceGrid thus providing compatibility with Rails asset caching.
+    #  Mind the parameters, and the fact that Prototype has to be loaded before WiceGrid javascripts:
+    #
+    #    <%= javascript_include_tag *([:defaults] + names_of_wice_grid_javascripts + [ 'ui', 'swfobject', {:cache => true}]) %>
+    #
+    #  By default +names_of_wice_grid_javascripts+ returns all javascripts, but it's possible not to include calendar widget javascripts by
+    #  setting parameter <tt>:include_calendar</tt>  to +false+.
+    def names_of_wice_grid_javascripts(options = {})
+      opts = {:include_calendar => true}
+      options.assert_valid_keys(opts.keys)
+      opts.merge!(options)
+      res = ['wice_grid']
+      n = js_framework_specific_calendar_js_name
+      res <<  n if n && opts[:include_calendar]
+      res
+    end
+
+    #  Returns a list of names of stylesheet files for WiceGrid thus providing compatibility with Rails asset caching.
+    #  Mind the parameters, for example:
+    #
+    #    <%= stylesheet_link_tag *(['core',  'modalbox'] + names_of_wice_grid_stylesheets + [ {:cache => true}]) %>
+    #
+    #  By default +names_of_wice_grid_stylesheets+ returns all javascripts, but it's possible not to include calendar widget javascripts by
+    #  setting parameter <tt>:include_calendar</tt>  to +false+.
+    def names_of_wice_grid_stylesheets(options = {})
+      opts = {:include_calendar => true}
+      options.assert_valid_keys(opts.keys)
+      opts.merge!(options)
+      res = ['wice_grid']
+      n = js_framework_specific_calendar_css_name
+      res << n if n && opts[:include_calendar]
+      res
+    end
+
+  end
+end

data/lib/helpers/wice_grid_serialized_queries_view_helpers.rb

@@ -0,0 +1,82 @@
+# encoding: UTF-8
+module Wice
+  module GridViewHelper
+
+    # View helper to render the list of saved queries and the form to create a new query.
+    # Parameters:
+    # * <tt>:extra_parameters</tt> -  a hash of additional parameters to use when creating a new query object.
+    # Read section "Adding Application Specific Logic to Saving/Restoring Queries" in README for more details.
+    def saved_queries_panel(grid, opts = {})
+      unless grid.kind_of? WiceGrid
+        raise WiceGridArgumentError.new("saved_queries_panel: the parameter must be a WiceGrid instance.")
+      end
+
+      options = {:extra_parameters => {}}
+      opts.assert_valid_keys(options.keys)
+      options.merge!(opts)
+
+      grid_name = grid.name
+      id_and_name = "#{grid_name}_saved_query_name"
+      base_path_to_query_controller = create_serialized_query_url(:grid_name => grid_name)
+
+      parameters = grid.get_state_as_parameter_value_pairs
+
+      options[:extra_parameters].each do |k, v|
+        parameters << [ CGI.unescape({:extra => {k => ''}}.to_query.sub(/=$/,'')) , v.to_s ]
+      end
+      parameters <<  ['authenticity_token', form_authenticity_token]
+
+      (%! <div class="wice_grid_query_panel"><h3>#{WiceGridNlMessageProvider.get_message(:SAVED_QUERY_PANEL_TITLE)}</h3>! +
+        saved_queries_list(grid_name, grid.saved_query, options[:extra_parameters]) +
+        %!<div id="#{grid_name}_notification_messages"  onmouseover="#{Wice::JsAdaptor.fade_this}"></div>! +
+        if block_given?
+          view, ids = yield
+          view
+        else
+          ''
+        end +
+        text_field_tag(id_and_name,  '', :size => 20, :onkeydown=>'', :id => id_and_name) +
+        button_to_function(WiceGridNlMessageProvider.get_message(:SAVE_QUERY_BUTTON_LABEL),  "#{grid_name}_save_query()" ) +  
+        '</div>' +
+        javascript_tag do
+          JsAdaptor.call_to_save_query_and_key_event_initialization_for_saving_queries(
+            id_and_name, grid_name, base_path_to_query_controller, parameters.to_json, ids.to_json
+          )
+        end
+        ).html_safe
+    end
+
+    def saved_queries_list(grid_name, saved_query = nil, extra_parameters = nil)  #:nodoc:
+      
+      link_title            = WiceGridNlMessageProvider.get_message(:SAVED_QUERY_LINK_TITLE)
+      deletion_confirmation = WiceGridNlMessageProvider.get_message(:SAVED_QUERY_DELETION_CONFIRMATION)
+      deletion_link_title   = WiceGridNlMessageProvider.get_message(:SAVED_QUERY_DELETION_LINK_TITLE)
+      
+      query_store_model = ::Wice::get_query_store_model
+      currently_loaded_query_id = saved_query ? saved_query.id : nil
+      with = extra_parameters.nil? ? nil : "'"  + {:extra => extra_parameters}.to_query + "'"
+
+      %!<ul id="#{grid_name}_query_list" class="query_list"> ! +
+      query_store_model.list(grid_name, controller).collect do |sq|
+        link_opts = {:class => 'query_load_link', :title => "#{link_title} #{sq.name}"}
+        link_opts[:class] += ' current' if saved_query == sq
+        "<li>"+
+        link_to_remote(image_tag(Defaults::DELETE_QUERY_ICON),
+          {:url => delete_serialized_query_path(:grid_name => grid_name, :id => sq.id, :current => currently_loaded_query_id ),
+            :confirm => deletion_confirmation, :with => with},
+          {:title => "#{deletion_link_title} #{sq.name}"} )  + ' &nbsp; ' +
+        link_to_function(h(sq.name),
+          %/ if (typeof(#{grid_name}) != "undefined") #{grid_name}.load_query(#{sq.id}) /,
+          link_opts) +
+        if sq.respond_to? :description
+          desc = sq.description
+          desc.blank? ? '' : " <i>#{desc}</i>"
+        else
+          ''
+        end +
+        '</li>'
+      end.join('') + '</ul>'
+    end
+
+  end
+end

data/lib/helpers/wice_grid_view_helpers.rb

@@ -0,0 +1,761 @@
+# encoding: UTF-8
+module Wice
+  module GridViewHelper
+
+    # View helper for rendering the grid.
+    #
+    # The first parameter is a grid object returned by +initialize_grid+ in the controller.
+    #
+    # The second parameter is a hash of options:
+    # * <tt>:table_html_attrs</tt> - a hash of HTML attributes to be included into the <tt>table</tt> tag.
+    # * <tt>:class</tt> - a shortcut for <tt>:table_html_attrs => {:class => 'css_class'}</tt>
+    # * <tt>:header_tr_html_attrs</tt> - a hash of HTML attributes to be included into the first <tt>tr</tt> tag
+    #   (or two first <tt>tr</tt>'s if the filter row is present).
+    # * <tt>:show_filters</tt> - defines when the filter is shown. Possible values are:
+    #   * <tt>:when_filtered</tt> - the filter is shown when the current table is the result of filtering
+    #   * <tt>:always</tt> or <tt>true</tt>  - show the filter always
+    #   * <tt>:no</tt> or <tt>false</tt>     - never show the filter
+    # * <tt>:upper_pagination_panel</tt> - a boolean value which defines whether there is an additional pagination
+    #   panel on top of the table. By default it is false.
+    # * <tt>:extra_request_parameters</tt> - a hash which will be added as additional HTTP request parameters to all
+    #   links generated by the grid, be it sorting links, filters, or the 'Reset Filter' icon.
+    #   Please note that WiceGrid respects and retains all request parameters already present in the URL which
+    #   formed the page, so there is no need to enumerate them in <tt>:extra_request_parameters</tt>. A typical
+    #   usage of <tt>:extra_request_parameters</tt> is a page with javascript tabs - changing the active tab
+    #   does not reload the page, but if one such tab contains a WiceGrid, it could be required that if the user
+    #   orders or filters the grid, the result page should have the tab with the grid activated. For this we
+    #   need to send an additional parameter specifying from which tab the request was generated.
+    # * <tt>:sorting_dependant_row_cycling</tt> - When set to true (by default it is false) the row styles +odd+
+    #   and +even+ will be changed only when the content of the cell belonging to the sorted column changes.
+    #   In other words, rows with identical values in the ordered column will have the same style (color).
+    # * <tt>:erb_mode</tt> - can be <tt>true</tt> or <tt>false</tt>. Defines the style of the helper method
+    #   in the view. The default is <tt>false</tt>.
+    # * <tt>:allow_showing_all_records</tt> - allow or prohibit the "All Records" mode.
+    # * <tt>:hide_reset_button</tt> - Do not show the default Filter Reset button.
+    #   Useful when using a custom reset button (helper +reset_grid_javascript+).
+    #   By default it is false.
+    # * <tt>:hide_submit_button</tt> - Do not show the default Filter Submit button.
+    #   Useful when using a custom submit button (helper +submit_grid_javascript+).
+    #   By default it is false.
+    # * <tt>:hide_csv_button</tt> - a boolean value which defines whether the default Export To CSV button
+    #   should be rendered. Useful when using a custom Export To CSV button (helper +export_to_csv_javascript+).
+    #   By default it is false.
+    #   Please read README for more insights.
+    #
+    # The block contains definitions of grid columns using the +column+ method sent to the object yielded into
+    # the block. In other words, the value returned by each of the blocks defines the content of a cell, the
+    # first block is called for cells of the first column for each row (each ActiveRecord instance), the
+    # second block is called for cells of the second column, and so on. See the example:
+    #
+    #   <%= grid(@accounts_grid, :table_html_attrs => {:class => 'grid_style', :id => 'accounts_grid'}, :header_tr_html_attrs => {:class => 'grid_headers'}) do |g|
+    #
+    #     g.column :column_name => 'Username', :attribute_name => 'username' do |account|
+    #       account.username
+    #     end
+    #
+    #     g.column :column_name => 'application_account.field.identity_id'._, :attribute_name => 'firstname', :model_class =>  Person do |account|
+    #       link_to(account.identity.name, identity_path(account.identity))
+    #     end
+    #
+    #     g.column do |account|
+    #       link_to('Edit', edit_account_path(account))
+    #     end
+    #
+    #   end -%>
+    #
+    # The helper may have two styles defined by the +erb_mode+ parameter to the +initialize_grid+ in the contoller.
+    # By default (<tt>erb_mode = false</tt>) this is a simple helper surrounded by <tt><%=</tt> and <tt>%></tt>:
+    #
+    #     <%= grid(@countries_grid) do |g|
+    #
+    #       g.column :column_name => 'Name', :attribute_name => 'name' do |country|
+    #         link_to(country.name, country_path(country))
+    #       end
+    #
+    #       g.column :column_name => 'Numeric Code', :attribute_name => 'numeric_code' do |country|
+    #         country.numeric_code
+    #       end
+    #
+    #     end -%>
+    #
+    #
+    #
+    # The second style (<tt>erb_mode = true</tt>) is called <em>ERB mode</em> and it allows to embed any ERB content inside blocks,
+    # which is basically the style of the
+    # <tt>form_for</tt> helper, only <tt>form_for</tt> takes one block, while inside the <tt>grid</tt> block there are other method calls taking
+    # blocks as parameters:
+    #
+    #     <% grid(@countries_grid) do |g|
+    #
+    #       <% g.column :column_name => 'Name', :attribute_name => 'name' do |country| %>
+    #         <b>Name: <%= link_to(country.name, country_path(country)) %></b>
+    #       <% end %>
+    #
+    #       <% g.column :column_name => 'Numeric Code', :attribute_name => 'numeric_code' do |country| %>
+    #         <i>Numeric Code: <%= country.numeric_code %></i>
+    #       <% end %>
+    #
+    #     <% end -%>
+    #
+    # This mode can be usable if you like to have much HTML code inside cells.
+    #
+    # Please remember that in this mode the helper opens with <tt><%</tt> instead of <tt><%=</tt>, similar to <tt>form_for</tt>.
+    #
+    # Defaults for parameters <tt>:show_filters</tt> and <tt>:upper_pagination_panel</tt>
+    # can be changed in <tt>lib/wice_grid_config.rb</tt> using constants <tt>Wice::Defaults::SHOW_FILTER</tt> and
+    # <tt>WiceGrid::Defaults::SHOW_UPPER_PAGINATION_PANEL</tt>, this is convenient if you want to set a project wide setting
+    # without having to repeat it for every grid instance.
+    #
+    # Pease read documentation about the +column+ method to achieve the enlightenment.
+
+    def grid(grid, opts = {}, &block)
+      unless grid.class == WiceGrid
+        raise WiceGridArgumentError.new("The first argument for the grid helper must be an instance of the WiceGrid class")
+      end
+
+      if grid.output_buffer
+        if grid.output_buffer == true
+          raise  WiceGridException.new("Second occurence of grid helper with the same grid object. " +
+                                       "Did you intend to use detached filters and forget to define them?")
+        else
+          return grid.output_buffer
+        end
+      end
+
+      options = {
+        :allow_showing_all_records     => Defaults::ALLOW_SHOWING_ALL_QUERIES,
+        :class                         => nil,
+        :erb_mode                      => Defaults::ERB_MODE,
+        :extra_request_parameters      => {},
+        :header_tr_html_attrs          => {},
+        :hide_reset_button             => false,
+        :hide_submit_button            => false,
+        :hide_csv_button               => false,
+        :show_filters                  => Defaults::SHOW_FILTER,
+        :sorting_dependant_row_cycling => false,
+        :table_html_attrs              => {},
+        :upper_pagination_panel        => Defaults::SHOW_UPPER_PAGINATION_PANEL
+      }
+
+      opts.assert_valid_keys(options.keys)
+
+      options.merge!(opts)
+
+      options[:show_filters] = :no     if options[:show_filters] == false
+      options[:show_filters] = :always if options[:show_filters] == true
+
+      options[:table_html_attrs].add_or_append_class_value!('wice_grid', true)
+
+      if options[:class]
+        options[:table_html_attrs].add_or_append_class_value!(options[:class])
+        options.delete(:class)
+      end
+
+      rendering = GridRenderer.new(grid, self)
+      rendering.erb_mode = options[:erb_mode]
+
+      block.call(rendering) # calling block containing column() calls
+
+      reuse_last_column_for_filter_buttons =
+        Defaults::REUSE_LAST_COLUMN_FOR_FILTER_ICONS && rendering.last_column_for_html.capable_of_hosting_filter_related_icons?
+
+      if grid.output_csv?
+        content = grid_csv(grid, rendering)
+      else
+        # If blank_slate is defined we don't show any grid at all
+        if rendering.blank_slate_handler &&  grid.resultset.size == 0 && ! grid.filtering_on?
+          content = generate_blank_slate(grid, rendering)
+          return prepare_result(rendering, grid, content, block)
+        end
+
+        content = grid_html(grid, options, rendering, reuse_last_column_for_filter_buttons)
+      end
+
+      grid.view_helper_finished = true
+      prepare_result(rendering, grid, content, block)
+    end
+
+    def prepare_result(rendering, grid, content, block) #:nodoc:
+      if rendering.erb_mode
+        # true in this case is a sign that grid_html has run in a normal mode, i.e. without detached filters
+        if grid.output_buffer.nil? || grid.output_buffer == true
+          content = content.to_s
+          if Rails.respond_to?(:version) && Rails.version.to_f >= 2.2
+            return concat(content)
+          else
+            return concat(content, block.binding)
+          end
+        else
+          # this way we're sending an empty string and setting flag stubborn_output_mode of GridOutputBuffer to false
+          return grid.output_buffer.to_s
+        end
+      else
+        return content
+      end
+    end
+
+
+    def generate_blank_slate(grid, rendering) #:nodoc:
+      buff = GridOutputBuffer.new
+
+      buff <<  if rendering.blank_slate_handler.is_a?(Proc)
+                 call_block_as_erb_or_ruby(rendering, rendering.blank_slate_handler, nil)
+               elsif rendering.blank_slate_handler.is_a?(Hash)
+                 render(rendering.blank_slate_handler)
+               else
+                 rendering.blank_slate_handler
+               end
+
+      if rendering.find_one_for(:in_html){|column| column.detach_with_id}
+        buff.stubborn_output_mode = true
+        buff.return_empty_strings_for_nonexistent_filters = true
+        grid.output_buffer   = buff
+      end
+      buff
+    end
+
+    def call_block_as_erb_or_ruby(rendering, block, ar)  #:nodoc:
+      if rendering.erb_mode
+        capture(ar, &block)
+      else
+        block.call(ar)
+      end
+    end
+
+    # the longest method? :(
+    def grid_html(grid, options, rendering, reuse_last_column_for_filter_buttons) #:nodoc:
+
+      table_html_attrs, header_tr_html_attrs = options[:table_html_attrs], options[:header_tr_html_attrs]
+
+      cycle_class = nil
+      sorting_dependant_row_cycling = options[:sorting_dependant_row_cycling]
+
+      content = GridOutputBuffer.new
+      # Ruby 1.9.1
+      content.force_encoding('UTF-8') if content.respond_to?(:force_encoding)
+
+      content << %!<div class="wice_grid_container" id="#{grid.name}"><div id="#{grid.name}_title">!
+      content << content_tag(:h3, grid.saved_query.name) if grid.saved_query
+      content << "</div><table #{tag_options(table_html_attrs, true)}>"
+      content << "<thead>"
+
+      no_filters_at_all = (options[:show_filters] == :no || rendering.no_filter_needed?) ? true: false
+
+      if no_filters_at_all
+        no_rightmost_column = no_filter_row = no_filters_at_all
+      else
+        no_rightmost_column = no_filter_row = (options[:show_filters] == :no || rendering.no_filter_needed_in_main_table?) ? true: false
+      end
+
+      no_rightmost_column = true if reuse_last_column_for_filter_buttons
+
+      pagination_panel_content_html, pagination_panel_content_js = nil, nil
+      if options[:upper_pagination_panel]
+        content << rendering.pagination_panel(no_rightmost_column, options[:hide_csv_button]) do
+          pagination_panel_content_html, pagination_panel_content_js =
+            pagination_panel_content(grid, options[:extra_request_parameters], options[:allow_showing_all_records])
+          pagination_panel_content_html
+        end
+      end
+
+      title_row_attrs = header_tr_html_attrs.clone
+      title_row_attrs.add_or_append_class_value!('wice_grid_title_row', true)
+
+      content << %!<tr #{tag_options(title_row_attrs, true)}>!
+
+      filter_row_id = grid.name + '_filter_row'
+
+      # first row of column labels with sorting links
+
+      filter_shown = if options[:show_filters] == :when_filtered
+                       grid.filtering_on?
+                     elsif options[:show_filters] == :always
+                       true
+                     end
+
+      cached_javascript = []
+
+      rendering.each_column_aware_of_one_last_one(:in_html) do |column, last|
+
+        column_name = column.column_name
+        if column_name.is_a? Array
+          column_name, js = column_name
+          cached_javascript << js
+        end
+
+        if column.attribute_name && column.allow_ordering
+
+          css_class = grid.filtered_by?(column) ? 'active_filter' : nil
+
+          direction = 'asc'
+          link_style = nil
+          if grid.ordered_by?(column)
+            css_class = css_class.nil? ? 'sorted' : css_class + ' sorted'
+            link_style = grid.order_direction
+            direction = 'desc' if grid.order_direction == 'asc'
+          end
+
+          col_link = link_to(column_name,
+                             rendering.column_link(column, direction, params, options[:extra_request_parameters]),
+                             :class => link_style)
+          content << content_tag(:th, col_link, Hash.make_hash(:class, css_class))
+          column.css_class = css_class
+        else
+          if reuse_last_column_for_filter_buttons && last
+            content << content_tag(:th,
+                                   hide_show_icon(filter_row_id, grid, filter_shown, no_filter_row, options[:show_filters], rendering),
+                                   :class => 'hide_show_icon'
+                                   )
+          else
+            content << content_tag(:th, (column.icon ? image_tag("/images/icons/grid/#{column.icon}", :alt => column_name, :border => 0) : column_name))
+          end
+        end
+      end
+
+      content << content_tag(:th,
+                             hide_show_icon(filter_row_id, grid, filter_shown, no_filter_row, options[:show_filters], rendering),
+                             :class => 'hide_show_icon'
+                             ) unless no_rightmost_column
+
+      content << '</tr>'
+      # rendering first row end
+
+
+      unless no_filters_at_all # there are filters, we don't know where, in the table or detached
+        if no_filter_row # they are all detached
+          content.stubborn_output_mode = true
+          rendering.each_column(:in_html) do |column|
+            if column.filter_shown?
+              filter_html_code, filter_js_code = column.render_filter
+              filter_html_code = filter_html_code.html_safe_if_necessary
+              cached_javascript << filter_js_code
+              content.add_filter(column.detach_with_id, filter_html_code)
+            end
+          end
+
+        else # some filters are present in the table
+
+          filter_row_attrs = header_tr_html_attrs.clone
+          filter_row_attrs.add_or_append_class_value!('wice_grid_filter_row', true)
+          filter_row_attrs['id'] = filter_row_id
+
+          content << %!<tr #{tag_options(filter_row_attrs, true)} !
+          content << 'style="display:none"' unless filter_shown
+          content << '>'
+
+          rendering.each_column_aware_of_one_last_one(:in_html) do |column, last|
+            if column.filter_shown?
+              filter_html_code, filter_js_code = column.render_filter
+              filter_html_code = filter_html_code.html_safe_if_necessary
+              cached_javascript << filter_js_code
+              if column.detach_with_id
+                content.stubborn_output_mode = true
+                content << content_tag(:th, '', Hash.make_hash(:class, column.css_class))
+                content.add_filter(column.detach_with_id, filter_html_code)
+              else
+                content << content_tag(:th, filter_html_code, Hash.make_hash(:class, column.css_class))
+              end
+            else
+              if reuse_last_column_for_filter_buttons && last
+                content << content_tag(:th,
+                                       reset_submit_buttons(options, grid, rendering),
+                                       Hash.make_hash(:class, column.css_class).add_or_append_class_value!('filter_icons')
+                                       )
+              else
+                content << content_tag(:th, '', Hash.make_hash(:class, column.css_class))
+              end
+            end
+          end
+          unless no_rightmost_column
+            content << content_tag(:th, reset_submit_buttons(options, grid, rendering), :class => 'filter_icons' )
+          end
+          content << '</tr>'
+        end
+      end
+
+      rendering.each_column(:in_html) do |column|
+        unless column.css_class.blank?
+          column.td_html_attrs.add_or_append_class_value!(column.css_class)
+        end
+      end
+
+      content << '</thead><tfoot>'
+
+      content << rendering.pagination_panel(no_rightmost_column, options[:hide_csv_button]) do
+        if pagination_panel_content_html
+          pagination_panel_content_html
+        else
+          pagination_panel_content_html, pagination_panel_content_js =
+            pagination_panel_content(grid, options[:extra_request_parameters], options[:allow_showing_all_records])
+          pagination_panel_content_html
+        end
+      end
+
+      content << '</tfoot><tbody>'
+      cached_javascript << pagination_panel_content_js
+
+      # rendering  rows
+      cell_value_of_the_ordered_column = nil
+      previous_cell_value_of_the_ordered_column = nil
+
+      grid.each do |ar| # rows
+
+        before_row_output = if rendering.before_row_handler
+                              call_block_as_erb_or_ruby(rendering, rendering.before_row_handler, ar)
+                            else
+                              nil
+                            end
+
+        after_row_output = if rendering.after_row_handler
+                             call_block_as_erb_or_ruby(rendering, rendering.after_row_handler, ar)
+                           else
+                             nil
+                           end
+
+        row_content = ''
+        rendering.each_column(:in_html) do |column|
+          cell_block = column.cell_rendering_block
+
+          opts = column.td_html_attrs.clone
+
+          column_block_output = if column.class == Wice::ActionViewColumn
+                                  cell_block.call(ar, params)
+                                else
+                                  call_block_as_erb_or_ruby(rendering, cell_block, ar)
+                                end
+
+          if column_block_output.kind_of?(Array)
+
+            unless column_block_output.size == 2
+              raise WiceGridArgumentError.new('When WiceGrid column block returns an array it is expected to contain 2 elements only - '+
+                                              'the first is the contents of the table cell and the second is a hash containing HTML attributes for the <td> tag.')
+            end
+
+            column_block_output, additional_opts = column_block_output
+
+            unless additional_opts.is_a?(Hash)
+              raise WiceGridArgumentError.new('When WiceGrid column block returns an array its second element is expected to be a ' +
+                                              "hash containing HTML attributes for the <td> tag. The returned value is #{additional_opts.inspect}. Read documentation.")
+            end
+
+            additional_css_class = nil
+            if additional_opts.has_key?(:class)
+              additional_css_class = additional_opts[:class]
+              additional_opts.delete(:class)
+            elsif additional_opts.has_key?('class')
+              additional_css_class = additional_opts['class']
+              additional_opts.delete('class')
+            end
+            opts.merge!(additional_opts)
+            opts.add_or_append_class_value!(additional_css_class) unless additional_css_class.blank?
+          end
+
+          if sorting_dependant_row_cycling && column.attribute_name && grid.ordered_by?(column)
+            cell_value_of_the_ordered_column = column_block_output
+          end
+          row_content += content_tag(:td, column_block_output, opts)
+        end
+
+        row_attributes = rendering.get_row_attributes(ar)
+
+        if sorting_dependant_row_cycling
+          cycle_class = cycle('odd', 'even', :name => grid.name) if cell_value_of_the_ordered_column != previous_cell_value_of_the_ordered_column
+          previous_cell_value_of_the_ordered_column = cell_value_of_the_ordered_column
+        else
+          cycle_class = cycle('odd', 'even', :name => grid.name)
+        end
+
+        row_attributes.add_or_append_class_value!(cycle_class)
+
+        content << before_row_output if before_row_output
+        content << "<tr #{tag_options(row_attributes)}>#{row_content}"
+        content << content_tag(:td, '') unless no_rightmost_column
+        content << '</tr>'
+        content << after_row_output if after_row_output
+      end
+
+      content << '</tbody></table></div>'
+      
+      content << link_to( "More &#x25BC;".html_safe, rendering.more_link(controller, options[:extra_request_parameters]), :id => 'more') if grid.has_more_to_show?
+
+      base_link_for_filter, base_link_for_show_all_records = rendering.base_link_for_filter(controller, options[:extra_request_parameters])
+
+      link_for_export      = rendering.link_for_export(controller, 'csv', options[:extra_request_parameters])
+
+      parameter_name_for_query_loading = {grid.name => {:q => ''}}.to_query
+      parameter_name_for_focus = {grid.name => {:foc => ''}}.to_query
+
+      prototype_and_js_version_check = if ENV['RAILS_ENV'] == 'development'
+                                         %$ if (typeof(WiceGridProcessor) == "undefined"){\n$ +
+                                           %$   alert('wice_grid.js not loaded, WiceGrid cannot proceed! ' +\n$ +
+                                           %$     'Please make sure that you include WiceGrid javascript in your page. ' +\n$ +
+                                           %$     'Use <%= include_wice_grid_assets %> or <%= include_wice_grid_assets(:include_calendar => true) %> ' +\n$ +
+                                           %$     'for WiceGrid javascripts and assets.')\n$ +
+                                           %$ } else if ((typeof(WiceGridProcessor._version) == "undefined") || ( WiceGridProcessor._version != "0.4.3")) {\n$ +
+                                           %$    alert("wice_grid.js in your /public is outdated, please run\\n ./script/generate wice_grid_assets_jquery\\n$ +
+                                           %$ or\\n ./script/generate wice_grid_assets_prototype\\nto update it.");\n$ +
+                                           %$ }\n$
+                                       else
+                                         ''
+                                       end
+
+      if rendering.show_hide_button_present
+        cached_javascript << JsAdaptor.show_hide_button_initialization(grid.name, filter_row_id)
+      end
+
+      if rendering.reset_button_present
+        cached_javascript << JsAdaptor.reset_button_initialization(grid.name, reset_grid_javascript(grid))
+      end
+
+      if rendering.submit_button_present
+        cached_javascript << JsAdaptor.submit_button_initialization(grid.name, submit_grid_javascript(grid))
+      end
+
+      if rendering.contains_a_text_input?
+        cached_javascript << JsAdaptor.enter_key_event_registration(grid.name)
+      end
+
+      if rendering.csv_export_icon_present
+        cached_javascript << JsAdaptor.csv_export_icon_initialization(grid.name)
+      end
+
+      if rendering.contains_auto_reloading_selects
+        cached_javascript << JsAdaptor.auto_reloading_selects_event_initialization(grid.name)
+      end
+
+      if rendering.contains_auto_reloading_inputs
+        cached_javascript << JsAdaptor.auto_reloading_inputs_event_initialization(grid.name)
+      end
+
+      if rendering.contains_auto_reloading_inputs_with_negation_checkboxes
+        cached_javascript << JsAdaptor.auto_reloading_inputs_with_negation_checkboxes_event_initialization(grid.name)
+      end
+
+      if rendering.contains_auto_reloading_calendars
+        cached_javascript << JsAdaptor.auto_reloading_calendar_event_initialization(grid.name)
+      end
+
+      if rendering.element_to_focus
+        cached_javascript << JsAdaptor.focus_element(rendering.element_to_focus)
+      end
+
+      content << javascript_tag(
+                                JsAdaptor.dom_loaded +
+                                %/ #{prototype_and_js_version_check}\n/ +
+                                %/ window['#{grid.name}'] = new WiceGridProcessor('#{grid.name}', '#{base_link_for_filter}',\n/ +
+                                %/  '#{base_link_for_show_all_records}', '#{link_for_export}', '#{parameter_name_for_query_loading}',\n/ +
+                                %/ '#{parameter_name_for_focus}', '#{ENV['RAILS_ENV']}');\n/ +
+                                if no_filters_at_all
+                                  ''
+                                else
+                                  rendering.select_for(:in_html) do |vc|
+                                    vc.attribute_name and not vc.no_filter
+                                  end.collect{|column| column.yield_javascript}.join("\n")
+                                end +
+                                "\n" + cached_javascript.compact.join('') +
+                                '})'
+                                )
+
+      if content.stubborn_output_mode
+        grid.output_buffer = content
+      else
+        # this will serve as a flag that the grid helper has already processed the grid but in a normal mode,
+        # not in the mode with detached filters.
+        grid.output_buffer = true
+      end
+      return content
+    end
+
+    def hide_show_icon(filter_row_id, grid, filter_shown, no_filter_row, show_filters, rendering)  #:nodoc:
+      grid_name = grid.name
+      no_filter_opening_closing_icon = (show_filters == :always) || no_filter_row
+
+      styles = ["display: block;", "display: none;"]
+      styles.reverse! unless filter_shown
+
+
+      if no_filter_opening_closing_icon
+        hide_icon = show_icon = ''
+      else
+
+
+        rendering.show_hide_button_present = true
+        filter_tooltip = WiceGridNlMessageProvider.get_message(:HIDE_FILTER_TOOLTIP)
+
+        hide_icon = content_tag(:span,
+                                image_tag(Defaults::SHOW_HIDE_FILTER_ICON,
+                                          :title => filter_tooltip,
+                                          :alt   => filter_tooltip),
+                                :id => grid_name + '_hide_icon',
+                                :style => styles[0],
+                                :class => 'clickable'
+                                )
+
+
+        filter_tooltip = WiceGridNlMessageProvider.get_message(:SHOW_FILTER_TOOLTIP)
+
+        show_icon = content_tag(:span,
+                                image_tag(Defaults::SHOW_HIDE_FILTER_ICON,
+                                          :title => filter_tooltip,
+                                          :alt   => filter_tooltip),
+                                :id => grid_name + '_show_icon',
+                                :style => styles[1],
+                                :class => 'clickable'
+                                )
+
+        hide_icon + show_icon
+      end
+    end
+
+    def reset_submit_buttons(options, grid, rendering)  #:nodoc:
+      (if options[:hide_submit_button]
+         ''
+       else
+         rendering.submit_button_present = true
+         filter_tooltip = WiceGridNlMessageProvider.get_message(:FILTER_TOOLTIP)
+         image_tag(Defaults::FILTER_ICON, :title => filter_tooltip, :alt => filter_tooltip, :class => 'submit clickable')
+       end + ' ' +
+       if options[:hide_reset_button]
+         ''
+       else
+         rendering.reset_button_present = true
+         filter_tooltip = WiceGridNlMessageProvider.get_message(:RESET_FILTER_TOOLTIP)
+         image_tag(Defaults::RESET_ICON, :title => filter_tooltip, :alt => filter_tooltip, :class => 'reset clickable')
+       end).html_safe_if_necessary
+    end
+
+    # Renders a detached filter. The parameters are:
+    # * +grid+ the WiceGrid object
+    # * +filter_key+ an identifier of the filter specified in the column declaration by parameter +:detach_with_id+
+    def grid_filter(grid, filter_key)
+      unless grid.kind_of? WiceGrid
+        raise WiceGridArgumentError.new("submit_grid_javascript: the parameter must be a WiceGrid instance.")
+      end
+      if grid.output_buffer.nil?
+        raise WiceGridArgumentError.new("grid_filter: You have attempted to run 'grid_filter' before 'grid'. Read about detached filters in the documentation.")
+      end
+      if grid.output_buffer == true
+        raise WiceGridArgumentError.new("grid_filter: You have defined no detached filters, or you try use detached filters with" +
+                                        ":show_filters => :no (set :show_filters to :always in this case). Read about detached filters in the documentation.")
+      end
+
+      content_tag :span, grid.output_buffer.filter_for(filter_key), :class => "#{grid.name}_detached_filter"
+    end
+
+    # Returns javascript which applies current filters. The parameter is a WiceGrid instance. Use it with +button_to_function+ to create
+    # your Submit button.
+    def submit_grid_javascript(grid)
+      unless grid.kind_of? WiceGrid
+        raise WiceGridArgumentError.new("submit_grid_javascript: the parameter must be a WiceGrid instance.")
+      end
+      "#{grid.name}.process()"
+    end
+
+    # Returns javascript which resets the grid, clearing the state of filters.
+    # The parameter is a WiceGrid instance. Use it with +button_to_function+ to create
+    # your Reset button.
+    def reset_grid_javascript(grid)
+      unless grid.kind_of? WiceGrid
+        raise WiceGridArgumentError.new("reset_grid_javascript: the parameter must be a WiceGrid instance.")
+      end
+      "#{grid.name}.reset()"
+    end
+
+    # Returns javascript which triggers export to CSV.
+    # The parameter is a WiceGrid instance. Use it with +button_to_function+ to create
+    # your own Export To CSV button.
+    def export_to_csv_javascript(grid)
+      unless grid.kind_of? WiceGrid
+        raise WiceGridArgumentError.new("export_csv_javascript: the parameter must be a WiceGrid instance.")
+      end
+      "#{grid.name}.export_to_csv()"
+    end
+
+
+    def grid_csv(grid, rendering) #:nodoc:
+      field_separator = (grid.export_to_csv_enabled && grid.export_to_csv_enabled.is_a?(String)) ? grid.export_to_csv_enabled : ','
+      spreadsheet = ::Wice::Spreadsheet.new(grid.name, field_separator)
+
+      # columns
+      spreadsheet << rendering.column_labels(:in_csv)
+
+      # rendering  rows
+      grid.each do |ar| # rows
+        row = []
+
+        rendering.each_column(:in_csv) do |column|
+          cell_block = column.cell_rendering_block
+
+          column_block_output = call_block_as_erb_or_ruby(rendering, cell_block, ar)
+
+          if column_block_output.kind_of?(Array)
+            column_block_output, additional_opts = column_block_output
+          end
+
+          row << column_block_output
+        end
+        spreadsheet << row
+      end
+      grid.csv_tempfile = spreadsheet.tempfile
+      return grid.csv_tempfile.path
+    end
+
+    def pagination_panel_content(grid, extra_request_parameters, allow_showing_all_records) #:nodoc:
+      extra_request_parameters = extra_request_parameters.clone
+      if grid.saved_query
+        extra_request_parameters["#{grid.name}[q]"] = grid.saved_query.id
+      end
+
+      html, js = pagination_info(grid, allow_showing_all_records)
+      '<div class="pagination_status">' + html + '</div>'
+
+      #       [will_paginate(grid.resultset,
+      #         :previous_label => WiceGridNlMessageProvider.get_message(:PREVIOUS_LABEL),
+      #         :next_label     => WiceGridNlMessageProvider.get_message(:NEXT_LABEL),
+      #         :param_name     => "#{grid.name}[page]",
+      #         :params         => extra_request_parameters).to_s +
+      #         (' <div class="pagination_status">' + html + '</div>').html_safe_if_necessary, js]
+    end
+
+
+    def show_all_link(collection_total_entries, parameters, grid_name) #:nodoc:
+
+      message = WiceGridNlMessageProvider.get_message(:ALL_QUERIES_WARNING)
+      confirmation = collection_total_entries > Defaults::START_SHOWING_WARNING_FROM ? "if (confirm('#{message}'))" : ''
+
+      js =  JsAdaptor.show_all_link_initialization(grid_name, confirmation, parameters.to_json)
+
+      tooltip = WiceGridNlMessageProvider.get_message(:SHOW_ALL_RECORDS_TOOLTIP)
+      html = %/<span class="show_all_link"><a href="#" title="#{tooltip}">/ +
+        WiceGridNlMessageProvider.get_message(:SHOW_ALL_RECORDS_LABEL) +
+        '</a></span>'
+
+      [html, js]
+    end
+
+    def back_to_pagination_link(parameters, grid_name) #:nodoc:
+      pagination_override_parameter_name = "#{grid_name}[pp]"
+      parameters = parameters.reject{|k, v| k == pagination_override_parameter_name}
+
+      js =  JsAdaptor.back_to_pagination_link_initialization(grid_name, parameters.to_json)
+
+      tooltip = WiceGridNlMessageProvider.get_message(:SWITCH_BACK_TO_PAGINATED_MODE_TOOLTIP)
+      html = %/ <span class="show_all_link"><a href="#" title="#{tooltip}">/ +
+        WiceGridNlMessageProvider.get_message(:SWITCH_BACK_TO_PAGINATED_MODE_LABEL) +
+        '</a></span>'
+      [html, js]
+    end
+
+    def pagination_info(grid, allow_showing_all_records)  #:nodoc:
+      found = grid.resultset.count
+      total = grid.klass.count
+      shown = [found, grid.status[:per_page].to_i].min
+      summary = ""
+      summary << "Shown: #{shown}"
+      summary << ", Found: #{found}" if grid.has_any_filter_criteria?
+      summary << ", Total: #{total}"
+      [summary, ""]
+    end
+
+  end
+end