netzke-basepack 0.7.7 → 0.8.0

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

@@ -1,400 +0,0 @@
-module Netzke
-  module Basepack
-    class GridPanel < Netzke::Base
-      module Columns
-        extend ActiveSupport::Concern
-        extend ActiveSupport::Memoizable
-
-        # module ClassMethods
-        #   # Columns to be displayed by the FieldConfigurator, "meta-columns". Each corresponds to a configuration
-        #   # option for each column in the grid.
-        #   def meta_columns
-        #     [
-        #       # Whether the column will be present in the grid, also in :hidden or :meta state. The value for this column will
-        #       # always be sent to/from the JS grid to the server
-        #       {:name => "included",      :attr_type => :boolean, :width => 40, :header => "Incl", :default_value => true},
-        #
-        #       # The name of the column. May be any accessible method or attribute of the data_class.
-        #       {:name => "name",          :attr_type => :string, :width => 200},
-        #
-        #       # The header for the column.
-        #       {:name => "label",         :attr_type => :string, :width => 200, :header => "Header"},
-        #
-        #       # The default value of this column. Is used when a new row in the grid gets created.
-        #       {:name => "default_value", :attr_type => :string, :width => 200},
-        #
-        #       # Options for drop-downs
-        #       {:name => "combobox_options",       :attr_type => :string, :editor => :textarea, :width => 200},
-        #
-        #       # Whether the column is editable in the grid.
-        #       {:name => "read_only",     :attr_type => :boolean, :header => "R/O", :tooltip => "Read-only"},
-        #
-        #       # Whether the column will be in the hidden state (hide/show columns from the column menu, if it's enabled).
-        #       {:name => "hidden",        :attr_type => :boolean},
-        #
-        #       # Whether the column should have "grid filters" enabled
-        #       # (see here: http://www.extjs.com/deploy/dev/examples/grid-filtering/grid-filter-local.html)
-        #       {:name => "with_filters",  :attr_type => :boolean, :default_value => true, :header => "Filters"},
-        #
-        #       #
-        #       # Below some rarely used parameters, hidden by default (you can always un-hide them from the column menu).
-        #       #
-        #
-        #       # The column's width
-        #       {:name => "width",         :attr_type => :integer, :hidden => true},
-        #
-        #       # Whether the column should be hideable
-        #       {:name => "hideable",      :attr_type => :boolean, :default_value => true, :hidden => true},
-        #
-        #       # Whether the column should be sortable (why change it? normally it's hardcoded)
-        #       {:name => "sortable",      :attr_type => :boolean, :default_value => true, :hidden => true},
-        #     ]
-        #   end
-        #
-        # end
-
-        # Normalized columns for the grid, e.g.:
-        # [{:name => :id, :hidden => true, ...}, {:name => :name, :editable => false, ...}, ...]
-        # Possible options:
-        # * +with_excluded+ - when set to true, also excluded columns will be returned (handy for dynamic column configuration)
-        # * +with_meta+ - when set to true, the meta column will be included as the last column
-        def columns(options = {})
-          [].tap do |cols|
-            if loaded_columns = load_columns
-              filter_out_excluded_columns(loaded_columns) unless options[:with_excluded]
-              cols.concat(reverse_merge_equally_named_columns(loaded_columns, initial_columns(options[:with_excluded])))
-            else
-              cols.concat(initial_columns(options[:with_excluded]))
-            end
-
-            append_meta_column(cols) if options[:with_meta]
-          end
-        end
-
-        memoize :columns
-
-        def append_meta_column(cols)
-          cols << {}.tap do |c|
-            c.merge!(
-              :name => "meta",
-              :meta => true,
-              :getter => lambda do |r|
-                meta_data(r)
-              end
-            )
-            c[:default_value] = meta_default_data if meta_default_data.present?
-          end
-        end
-
-        # default_value for the meta column; used when a new record is being created in the grid
-        def meta_default_data
-          get_default_association_values.present? ? { :association_values => get_default_association_values.literalize_keys } : {}
-        end
-
-        # Override it when you need extra meta data to be passed through the meta column
-        def meta_data(r)
-          { :association_values => get_association_values(r).literalize_keys }
-        end
-
-        # Columns as a hash, for easier access to a specific column
-        def columns_hash
-          @columns_hash ||= columns.inject({}){|r,c| r.merge(c[:name].to_sym => c)}
-        end
-
-        # Columns that we fall back to when neither persistent columns, nor configured columns are present.
-        # If there's a model-level field configuration, it's being used.
-        # Otherwise the defaults straight from the ActiveRecord model ("netzke_attributes").
-        # Override this method if you want to provide a fix set of columns in your subclass.
-        def default_columns
-          @default_columns ||= load_model_level_attrs || data_class.netzke_attributes
-        end
-
-        def set_default_attr_type(c)
-          c[:attr_type] ||= association_attr?(c) ? :integer : data_adapter.attr_type(c.name)
-        end
-
-        # Columns that were overridden with :override_columns config option.
-        def overridden_default_columns
-          if config[:override_columns].present?
-            result = []
-            default_columns.each do |col|
-              result << col.merge(config[:override_columns][col[:name].to_sym] || {})
-            end
-            result
-          else
-            default_columns
-          end
-        end
-
-        # Columns that represent a smart merge of default_columns and columns passed during the configuration.
-        def initial_columns(with_excluded = false)
-          # Normalize here, as from the config we can get symbols (names) instead of hashes
-          columns_from_config = config[:columns] && normalize_attrs(config[:columns])
-
-          if columns_from_config
-            # automatically add a column that reflects the primary key (unless specified in the config)
-            columns_from_config.insert(0, {:name => data_class.primary_key.to_s}) unless columns_from_config.any?{ |c| c[:name] == data_class.primary_key }
-
-            # reverse-merge each column hash from config with each column hash from exposed_attributes
-            # (columns from config have higher priority)
-            for c in columns_from_config
-              corresponding_default_column = overridden_default_columns.find{ |k| k[:name] == c[:name] }
-              c.reverse_merge!(corresponding_default_column) if corresponding_default_column
-            end
-            columns_for_create = columns_from_config
-          else
-            # we didn't have columns configured in component's config, so, use the columns from the data class
-            columns_for_create = overridden_default_columns
-          end
-
-          filter_out_excluded_columns(columns_for_create) unless with_excluded
-
-          # Make the column config complete with the defaults.
-          # Note: dup is needed to avoid modifying original hashes.
-          columns_for_create.map { |c| c.dup.tap { |c| augment_column_config c } }
-        end
-
-        memoize :initial_columns
-
-        private
-
-          # Based on initial column config, e.g.:
-          #
-          #   {:name=>"author__name", :attr_type=>:string}
-          #
-          # augment it with additional configuration params, e.g.:
-          #
-          #   {:name=>"author__name", :attr_type=>:string, :editor=>{:xtype=>:netzkeremotecombo}, :assoc=>true, :virtual=>true, :header=>"Author  name", :editable=>true, :sortable=>false, :filterable=>false}
-          #
-          # It may be handy to override it.
-          def augment_column_config(c)
-            # note: the order of these calls is important, as consequent calls may depend on the result of previous ones
-            set_default_xtype(c)
-            set_default_virtual(c)
-            set_default_text(c)
-            set_default_editable(c)
-            set_default_editor(c)
-            set_default_width(c)
-            set_default_hidden(c)
-            set_default_sortable(c)
-            set_default_filterable(c)
-            c[:assoc] = association_attr?(c)
-          end
-
-          def set_default_xtype(c)
-            return if c[:renderer] || c[:editor] # if user set those manually, we don't mess with column xtype
-            c[:xtype] ||= attr_type_to_xtype_map[c[:attr_type]]
-          end
-
-          def set_default_text(c)
-            c[:text] ||= c[:label] || data_class.human_attribute_name(c[:name])
-          end
-
-          def set_default_editor(c)
-            # if shouldn't be editable, don't set any default editor; also, specifying xtype takes care of the editor
-            return if c[:read_only] || c[:editable] == false
-
-            if association_attr?(c)
-              set_default_association_editor(c)
-            else
-              c[:editor] ||= editor_for_attr_type(c[:attr_type])
-            end
-
-          end
-
-          def set_default_width(c)
-            c[:width] ||= 50 if c[:attr_type] == :boolean
-            c[:width] ||= 150 if c[:attr_type] == :datetime
-          end
-
-          def set_default_hidden(c)
-            c[:hidden] = true if primary_key_attr?(c) && c[:hidden].nil?
-          end
-
-          def set_default_editable(c)
-            if c[:editable].nil?
-              c[:editable] = is_editable_column?(c)
-            end
-          end
-
-          def set_default_sortable(c)
-            # this *has* to be set to false if we don't want the column to be sortable (it's sortable by default in Ext)
-            c[:sortable] = !(c[:virtual] && !c[:sorting_scope]) if c[:sortable].nil?
-          end
-
-          def set_default_filterable(c)
-            c[:filterable] = !c[:virtual] if c[:filterable].nil?
-          end
-
-
-          # Detects an association column and sets up the proper editor.
-          def set_default_association_editor(c)
-            assoc, assoc_method =  c[:name].split('__')
-            return unless assoc
-
-            assoc_method_type = data_adapter.get_assoc_property_type assoc, assoc_method
-
-            # if association column is boolean, display a checkbox (or alike), otherwise - a combobox (or alike)
-            if c[:nested_attribute]
-              c[:editor] ||= editor_for_attr_type(assoc_method_type)
-            else
-              c[:editor] ||= assoc_method_type == :boolean ? editor_for_attr_type(:boolean) : editor_for_association
-            end
-          end
-
-          # If the column should be editable
-          def is_editable_column?(c)
-            not_editable_if = primary_key_attr?(c)
-            not_editable_if ||= c[:virtual] && !association_attr?(c[:name])
-            not_editable_if ||= c[:read_only]
-
-            editable_if = data_class.column_names.include?(c[:name])
-            editable_if ||= data_class.instance_methods.map(&:to_s).include?("#{c[:name]}=")
-            editable_if ||= association_attr?(c[:name])
-
-            editable_if && !not_editable_if
-          end
-
-          def initial_columns_order
-            columns.map do |c|
-              {
-                :name => c[:name],
-                :width => c[:width],
-                :hidden => c[:hidden]
-              }
-            end
-          end
-
-          def columns_order
-            if config[:persistence]
-              update_state(:columns_order, initial_columns_order) if columns_have_changed?
-              state[:columns_order] || initial_columns_order
-            else
-              initial_columns_order
-            end
-          end
-
-          def columns_have_changed?
-            init_column_names = initial_columns_order.map{ |c| c[:name].to_s }.sort
-            stored_column_names = (state[:columns_order] || initial_columns_order).map{ |c| c[:name].to_s }.sort
-            init_column_names != stored_column_names
-          end
-
-          def filter_out_excluded_columns(cols)
-            cols.reject!{ |c| c[:included] == false }
-          end
-
-          # Stores modified columns in persistent storage
-          def save_columns!
-            # NetzkeFieldList.update_list_for_current_authority(global_id, columns(false), original_data_class.name) if persistent_config_enabled?
-          end
-
-          def load_columns
-            # NetzkeFieldList.read_list(global_id) if persistent_config_enabled?
-          end
-
-          def load_model_level_attrs
-            # NetzkeModelAttrList.read_list(data_class.name) if persistent_config_enabled?
-          end
-
-          # Column editor config for attribute type.
-          def editor_for_attr_type(type)
-            {:xtype => attr_type_to_editor_xtype_map[type] || :textfield}
-          end
-
-          # Column editor config for one-to-many association
-          def editor_for_association
-            {:xtype => :netzkeremotecombo}
-          end
-
-          # Hash that maps a column type to the editor xtype. Override if you want different editors.
-          def attr_type_to_editor_xtype_map
-            {
-              :integer => :numberfield,
-              :boolean => :checkbox,
-              :date => :datefield,
-              :datetime => :xdatetime,
-              :text => :textarea,
-              :string => :textfield
-            }
-          end
-
-          def attr_type_to_xtype_map
-            {
-              # :integer  => :numbercolumn, # don't like the default formatter
-              :boolean  => :checkcolumn,
-              :date     => :datecolumn,
-              #:datetime => :datecolumn # TODO: replace with datetimepicker
-            }
-          end
-
-          # Default fields that will be displayed in the Add/Edit/Search forms
-          # When overriding this method, keep in mind that the fields inside the layout must be expanded (each field represented by a hash, not just a symbol)
-          def default_fields_for_forms
-            selected_columns = columns.select do |c|
-              data_class.column_names.include?(c[:name]) ||
-              data_class.instance_methods.include?("#{c[:name]}=") ||
-              association_attr?(c[:name])
-            end
-
-            selected_columns.map do |c|
-              field_config = {
-                :name => c[:name],
-                :field_label => c[:text] || c[:header],
-                :read_only => c[:read_only],
-                :editable => c[:editable]
-              }
-
-              # scopes for combobox options
-              field_config[:scopes] = c[:editor][:scopes] if c[:editor].is_a?(Hash)
-
-              field_config.merge!(c[:editor] || {})
-
-              field_config
-            end
-          end
-
-          # default_fields_for_forms extended with default values (for new-record form)
-          # def default_fields_for_forms_with_default_values
-          #   res = default_fields_for_forms.dup
-          #   each_attr_in(res) do |a|
-          #     attr_name = a[:name].to_sym
-          #     a[:value] = a[:default_value] || columns_hash[attr_name].try(:fetch, :default_value, nil) || data_class.netzke_attribute_hash[attr_name].try(:fetch, :default_value, nil)
-          #   end
-          #   res
-          # end
-
-          def columns_default_values
-            columns.inject({}) do |r,c|
-              assoc_name, assoc_method = c[:name].split '__'
-              if c[:default_value].nil?
-                r
-              else
-                if assoc_method
-                  r.merge(data_adapter.foreign_key_for(assoc_name) || data_adapter.foreign_key_for(assoc_name) => c[:default_value])
-                else
-                  r.merge(c[:name] => c[:default_value])
-                end
-              end
-            end
-          end
-
-          # Recursively traversess items (an array) and yields each found field (a hash with :name set)
-          def each_attr_in(items)
-            items.each do |item|
-              if item.is_a?(Hash)
-                each_attr_in(item[:items]) if item[:items].is_a?(Array)
-                yield(item) if item[:name]
-              end
-            end
-          end
-
-          # Receives 2 arrays of columns. Merges the missing config from the +source+ into +dest+, matching columns by name
-          def reverse_merge_equally_named_columns(dest, source)
-            dest.each{ |dc| dc.reverse_merge!(source.detect{ |sc| sc[:name] == dc[:name] } || {}) }
-          end
-
-      end
-    end
-  end
-end

data/lib/netzke/basepack/grid_panel/javascripts/rows-dd.js

@@ -1,281 +0,0 @@
-Ext.namespace('Ext.ux.dd');
-
-Ext.ux.dd.GridDragDropRowOrder = Ext.extend(Ext.util.Observable,
-{
-    copy: false,
-
-    scrollable: false,
-
-    constructor : function(config)
-    {
-        Ext.ux.dd.GridDragDropRowOrder.superclass.constructor.call(this);
-        if (config)
-            Ext.apply(this, config);
-
-        this.addEvents(
-        {
-            beforerowmove: true,
-            afterrowmove: true,
-            beforerowcopy: true,
-            afterrowcopy: true
-        });
-    },
-
-    init : function (grid)
-    {
-        this.grid = grid;
-        grid.enableDragDrop = true;
-
-        grid.on({
-            render: { fn: this.onGridRender, scope: this, single: true }
-        });
-    },
-
-    onGridRender : function (grid)
-    {
-        var self = this;
-
-        this.target = new Ext.dd.DropTarget(grid.getEl(),
-        {
-            ddGroup: grid.ddGroup || 'GridDD',
-            grid: grid,
-            gridDropTarget: this,
-
-            notifyDrop: function(dd, e, data)
-            {
-                // Remove drag lines. The 'if' condition prevents null error when drop occurs without dragging out of the selection area
-                if (this.currentRowEl)
-                {
-                    this.currentRowEl.removeClass('grid-row-insert-below');
-                    this.currentRowEl.removeClass('grid-row-insert-above');
-                }
-
-                // determine the row
-                var t = Ext.lib.Event.getTarget(e);
-                var rindex = this.grid.getView().findRowIndex(t);
-                if (rindex === false || rindex == data.rowIndex)
-                {
-                    return false;
-                }
-                // fire the before move/copy event
-                if (this.gridDropTarget.fireEvent(self.copy ? 'beforerowcopy' : 'beforerowmove', this.gridDropTarget, data.rowIndex, rindex, data.selections, 123) === false)
-                {
-                    return false;
-                }
-
-                // update the store
-                var ds = this.grid.getStore();
-
-                // Changes for multiselction by Spirit
-                var selections = new Array();
-                var keys = ds.data.keys;
-                for (var key in keys)
-                {
-                    for (var i = 0; i < data.selections.length; i++)
-                    {
-                        if (keys[key] == data.selections[i].id)
-                        {
-                            // Exit to prevent drop of selected records on itself.
-                            if (rindex == key)
-                            {
-                                return false;
-                            }
-                            selections.push(data.selections[i]);
-                        }
-                    }
-                }
-
-                // fix rowindex based on before/after move
-                if (rindex > data.rowIndex && this.rowPosition < 0)
-                {
-                    rindex--;
-                }
-                if (rindex < data.rowIndex && this.rowPosition > 0)
-                {
-                    rindex++;
-                }
-
-                // fix rowindex for multiselection
-                if (rindex > data.rowIndex && data.selections.length > 1)
-                {
-                    rindex = rindex - (data.selections.length - 1);
-                }
-
-                // we tried to move this node before the next sibling, we stay in place
-                if (rindex == data.rowIndex)
-                {
-                    return false;
-                }
-
-                // fire the before move/copy event
-                /* dupe - does it belong here or above???
-                if (this.gridDropTarget.fireEvent(self.copy ? 'beforerowcopy' : 'beforerowmove', this.gridDropTarget, data.rowIndex, rindex, data.selections, 123) === false)
-                {
-                    return false;
-                }
-                */
-
-                if (!self.copy)
-                {
-                    for (var i = 0; i < data.selections.length; i++)
-                    {
-                        ds.remove(ds.getById(data.selections[i].id));
-                    }
-                }
-
-                for (var i = selections.length - 1; i >= 0; i--)
-                {
-                    var insertIndex = rindex;
-                    ds.insert(insertIndex, selections[i]);
-                }
-
-                // re-select the row(s)
-                var sm = this.grid.getSelectionModel();
-                if (sm)
-                {
-                    sm.selectRecords(data.selections);
-                }
-
-                // console.info(this.gridDropTarget);
-
-                // fire the after move/copy event
-                this.gridDropTarget.fireEvent(self.copy ? 'afterrowcopy' : 'afterrowmove', this.gridDropTarget, data.rowIndex, rindex, data.selections);
-                return true;
-            },
-
-            notifyOver: function(dd, e, data)
-            {
-              // WIP: todo - rewrite Ext.lib call to Ext 4
-                var t = Ext.lib.Event.getTarget(e);
-                var rindex = this.grid.getView().findRowIndex(t);
-
-                // Similar to the code in notifyDrop. Filters for selected rows and quits function if any one row matches the current selected row.
-                var ds = this.grid.getStore();
-                var keys = ds.data.keys;
-                for (var key in keys)
-                {
-                    for (var i = 0; i < data.selections.length; i++)
-                    {
-                        if (keys[key] == data.selections[i].id)
-                        {
-                            if (rindex == key)
-                            {
-                                if (this.currentRowEl)
-                                {
-                                    this.currentRowEl.removeClass('grid-row-insert-below');
-                                    this.currentRowEl.removeClass('grid-row-insert-above');
-                                }
-                                return this.dropNotAllowed;
-                            }
-                        }
-                    }
-                }
-
-                // If on first row, remove upper line. Prevents negative index error as a result of rindex going negative.
-                if (rindex < 0 || rindex === false)
-                {
-                    this.currentRowEl.removeClass('grid-row-insert-above');
-                    return this.dropNotAllowed;
-                }
-
-                try
-                {
-                    var currentRow = this.grid.getView().getRow(rindex);
-                    // Find position of row relative to page (adjusting for grid's scroll position)
-                    var resolvedRow = new Ext.Element(currentRow).getY() - this.grid.getView().scroller.dom.scrollTop;
-                    var rowHeight = currentRow.offsetHeight;
-
-                    // Cursor relative to a row. -ve value implies cursor is above the row's middle and +ve value implues cursor is below the row's middle.
-                    this.rowPosition = e.getPageY() - resolvedRow - (rowHeight/2);
-
-                    // Clear drag line.
-                    if (this.currentRowEl)
-                    {
-                        this.currentRowEl.removeClass('grid-row-insert-below');
-                        this.currentRowEl.removeClass('grid-row-insert-above');
-                    }
-
-                    if (this.rowPosition > 0)
-                    {
-                        // If the pointer is on the bottom half of the row.
-                        this.currentRowEl = new Ext.Element(currentRow);
-                        this.currentRowEl.addClass('grid-row-insert-below');
-                    }
-                    else
-                    {
-                        // If the pointer is on the top half of the row.
-                        if (rindex - 1 >= 0)
-                        {
-                            var previousRow = this.grid.getView().getRow(rindex - 1);
-                            this.currentRowEl = new Ext.Element(previousRow);
-                            this.currentRowEl.addClass('grid-row-insert-below');
-                        }
-                        else
-                        {
-                            // If the pointer is on the top half of the first row.
-                            this.currentRowEl.addClass('grid-row-insert-above');
-                        }
-                    }
-                }
-                catch (err)
-                {
-                    console.warn(err);
-                    rindex = false;
-                }
-                return (rindex === false)? this.dropNotAllowed : this.dropAllowed;
-            },
-
-            notifyOut: function(dd, e, data)
-            {
-                // Remove drag lines when pointer leaves the gridView.
-                if (this.currentRowEl)
-                {
-                    this.currentRowEl.removeClass('grid-row-insert-above');
-                    this.currentRowEl.removeClass('grid-row-insert-below');
-                }
-            }
-        });
-
-        if (this.targetCfg)
-        {
-            Ext.apply(this.target, this.targetCfg);
-        }
-
-        if (this.scrollable)
-        {
-            Ext.dd.ScrollManager.register(grid.getView().getEditorParent());
-            grid.on({
-                beforedestroy: this.onBeforeDestroy,
-                scope: this,
-                single: true
-            });
-        }
-    },
-
-    getTarget: function()
-    {
-        return this.target;
-    },
-
-    getGrid: function()
-    {
-        return this.grid;
-    },
-
-    getCopy: function()
-    {
-        return this.copy ? true : false;
-    },
-
-    setCopy: function(b)
-    {
-        this.copy = b ? true : false;
-    },
-
-    onBeforeDestroy : function (grid)
-    {
-        // if we previously registered with the scroll manager, unregister
-        // it (if we don't it will lead to problems in IE)
-        Ext.dd.ScrollManager.unregister(grid.getView().getEditorParent());
-    }
-});