netzke-basepack 0.6.5 → 0.7.0

data/lib/netzke/basepack/form_panel/javascripts/n_radio_group.js

@@ -6,9 +6,11 @@ Config options:
   1) all radio buttons, by boxLabel, e.g.: ["Cool", "To read", "Important"]
   2) array of arrays in format [value, label], e.g.: [[1, "Good"], [2, "Average"], [3, "Poor"]]
 */
-Ext.netzke.form.NRadioGroup = Ext.extend(Ext.form.RadioGroup, {
+Ext.define('Ext.netzke.form.NRadioGroup', {
+  extend: 'Ext.form.RadioGroup',
+  alias:  'widget.nradiogroup',
   initComponent: function(){
-    Ext.netzke.form.NRadioGroup.superclass.initComponent.call(this);
+    this.callParent();
 
     this.items = [];
 
@@ -39,4 +41,3 @@ Ext.netzke.form.NRadioGroup = Ext.extend(Ext.form.RadioGroup, {
   }
 });
 
-Ext.reg('nradiogroup', Ext.netzke.form.NRadioGroup);

data/lib/netzke/basepack/form_panel/javascripts/readonly_mode.js

@@ -1,6 +1,7 @@
-Ext.override(Ext.form.Field, {
+// Overrides that implement setReadonlyMode for form fields.
+//
 
-  // By calling this, the field is instructed to replace itself with another instance, configured with displayModeConfig
+Ext.form.field.Base.override({
   setReadonlyMode: function(onOff){
     if (this.hidden) return;
 
@@ -9,18 +10,17 @@ Ext.override(Ext.form.Field, {
     }
 
     if (onOff) {
-      this.addClass("readonly");
-      if (this.label) this.label.addClass("readonly");
+      this.addCls("readonly");
+      if (this.label) this.label.addCls("readonly");
     } else {
-      this.removeClass("readonly");
-      if (this.label) this.label.removeClass("readonly");
+      this.removeCls("readonly");
+      if (this.label) this.label.removeCls("readonly");
     }
   }
-
 });
 
-// Composite field has to take care of its children, by setting them into the "display mode"
-Ext.override(Ext.form.CompositeField, {
+// Also the FieldContainer
+Ext.form.FieldContainer.override({
   setReadonlyMode: function(onOff){
     this.items.each(function(i){
       i.setReadonlyMode(onOff);
@@ -28,7 +28,7 @@ Ext.override(Ext.form.CompositeField, {
   }
 });
 
-Ext.override(Ext.form.Checkbox, {
+Ext.form.field.Checkbox.override({
   setReadonlyMode: function(onOff){
     this.setDisabled(onOff);
   }

data/lib/netzke/basepack/form_panel/services.rb

@@ -65,7 +65,7 @@ module Netzke
             @record.errors.to_a.each do |msg|
               flash :error => msg
             end
-            {:feedback => @flash, :apply_form_errors => build_form_errors(record)}
+            {:netzke_feedback => @flash, :apply_form_errors => build_form_errors(record)}
           end
         end
 

data/lib/netzke/basepack/grid_panel.rb

@@ -51,7 +51,7 @@ module Netzke
     # == Columns
     # Columns are configured by passing an array to the +columns+ option. Each element in the array is either the name of model's (virtual) attribute (in which case the configuration will be fully automatic), or a hash that may contain the following configuration options as keys:
     #
-    # * +name+ - name of the column, that may correspond to the model's (virtual) attribute
+    # * +name+ - (required) name of the column, that may correspond to the model's (virtual) attribute
     # * +read_only+ - a boolean that defines if the cells in the column should be editable
     # * +editable+ - same as +read_only+, but in reverse (takes precedence over +read_only+)
     # * +filterable+ - set to false to disable filtering on this column
@@ -74,7 +74,7 @@ module Netzke
     #       }
     #     end
     #
-    # Besides these options, a column can receive any meaningful config option understood by Ext.grid.Column (http://dev.sencha.com/deploy/dev/docs/?class=Ext.grid.Column)
+    # Besides these options, a column can receive any meaningful config option understood by Ext.grid.column.Column.
     #
     # == One-to-many association support
     # If the model bound to a grid +belongs_to+ another model, GridPanel can display an "assocition column" - where the user can select the associated record from a drop-down box. You can specify which method of the association should be used as the display value for the drop-down box options by using the double-underscore notation on the column name, where the association name is separated from the association method by "__" (double underscore). For example, let's say we have a Book that +belongs_to+ model Author, and Author responds to +first_name+. This way, the book grid can have a column defined as follows:
@@ -87,6 +87,10 @@ module Netzke
     #
     #     {:name => "author__first_name", :scope => lambda{|relation| relation.where(:popular => true)}}
     #
+    # == Add/edit/search forms
+    # The forms will by default display the fields that correspond to the configured columns, taking over meaningful configuration options (e.g. +text+ will be converted into +fieldLabel+).
+    # You may override the default fields displayed in the forms by overriding the +default_fields_for_forms+ method, which should return an array understood by the +items+ config property of the +FormPanel+. If you need to use a custom class instead of +FormPanel+, you may need to go an extra mile overriding the corresponding GridPanel's child component (e.g. "add_form" or "edit_form").
+    #
     # == Actions
     # You can override GridPanel's actions to change their text, icons, and tooltips (see http://api.netzke.org/core/Netzke/Actions.html).
     #
@@ -117,7 +121,7 @@ module Netzke
     # * +edit_in_form_available+ - (defaults to true) include code for (multi-record) editing and adding records through a form
     # * +extended_search_available+ - (defaults to true) include code for extended configurable search
     class GridPanel < Netzke::Base
-      js_base_class "Ext.grid.EditorGridPanel"
+      js_base_class "Ext.grid.Panel"
 
       # Class-level configuration. These options directly influence the amount of generated
       # javascript code for this component's class. For example, if you don't want filters for the grid,
@@ -128,9 +132,9 @@ module Netzke
 
       class_config_option :edit_in_form_available, true
 
-      class_config_option :rows_reordering_available, true
+      class_config_option :rows_reordering_available, false
 
-      class_config_option :config_tool_available, true
+      class_config_option :config_tool_available, false
 
       class_config_option :default_instance_config, {
         :enable_edit_in_form    => edit_in_form_available,
@@ -140,7 +144,7 @@ module Netzke
         :enable_rows_reordering => false, # column drag n drop
         :enable_pagination      => true,
         :rows_per_page          => 30,
-        :tools                  => %w{ refresh },
+        :tools                  => %w{ refresh }
       }
 
       extend ActiveSupport::Memoizable
@@ -149,27 +153,28 @@ module Netzke
       include self::Columns
       include Netzke::Basepack::DataAccessor
 
-      js_mixin :grid_panel
+      js_mixin :grid_panel, :event_handling
       js_mixin :advanced_search if extended_search_available
       js_mixin :edit_in_form if edit_in_form_available
 
-      js_translate *%w[are_you_sure confirmation first_text prev_text next_text last_text before_page_text after_page_text empty_msg refresh_text display_msg]
+      js_translate *%w[are_you_sure confirmation]
 
       # JavaScript includes
-      ex = Netzke::Core.ext_location.join("examples")
+      ex = Netzke::Core.ext_path.join("examples")
 
       js_include(ex.join("ux/CheckColumn.js"))
+      js_include :check_column_fix
 
       # Includes for column filters
       if column_filters_available
         [
-          "ux/gridfilters/menu/ListMenu.js",
-          "ux/gridfilters/menu/RangeMenu.js",
-          "ux/gridfilters/GridFilters.js"
+          "ux/grid/menu/ListMenu.js",
+          "ux/grid/menu/RangeMenu.js",
+          "ux/grid/FiltersFeature.js"
         ].each{ |path| js_include(ex.join(path)) }
 
         %w{Boolean Date List Numeric String}.unshift("").each do |f|
-          js_include(ex.join"ux/gridfilters/filter/#{f}Filter.js")
+          js_include(ex.join"ux/grid/filter/#{f}Filter.js")
         end
       end
 
@@ -198,7 +203,7 @@ module Netzke
 
       def get_default_association_values #:nodoc:
         columns.select{ |c| c[:name].index("__") && c[:default_value] }.each.inject({}) do |r,c|
-          assoc, assoc_method = assoc_and_assoc_method_for_column(c)
+          assoc, assoc_method = assoc_and_assoc_method_for_attr(c)
           assoc_instance = assoc.klass.find(c[:default_value])
           r.merge(c[:name] => assoc_instance.send(assoc_method))
         end
@@ -243,6 +248,7 @@ module Netzke
           :text => I18n.t('netzke.basepack.grid_panel.actions.add'),
           :tooltip => I18n.t('netzke.basepack.grid_panel.actions.add'),
           :disabled => config[:prohibit_create],
+          :handler => "onAddInline", # not following naming conventions here as Ext 4 grid has its own onAdd method
           :icon => :add
         }
       end
@@ -314,7 +320,7 @@ module Netzke
             :strong_default_attrs => config[:strong_default_attrs],
             :border => true,
             :bbar => false,
-            :header => false,
+            :prevent_header => true,
             :mode => config[:mode],
             :record => data_class.new(columns_default_values)
           }.deep_merge(config[:add_form_config] || {})]
@@ -333,7 +339,7 @@ module Netzke
             :items => default_fields_for_forms,
             :persistent_config => config[:persistent_config],
             :bbar => false,
-            :header => false,
+            :prevent_header => true,
             :mode => config[:mode]
             # :record_id gets assigned by deliver_component dynamically, at the moment of loading
           }.deep_merge(config[:edit_form_config] || {})]
@@ -352,7 +358,7 @@ module Netzke
             :items => default_fields_for_forms,
             :persistent_config => config[:persistent_config],
             :bbar => false,
-            :header => false,
+            :prevent_header => true,
             :mode => config[:mode]
           }.deep_merge(config[:multi_edit_form_config] || {})]
         }.deep_merge(config[:multi_edit_form_window_config] || {})

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

@@ -114,7 +114,6 @@ module Netzke
           # 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}) unless columns_from_config.any?{ |c| c[:name] == data_class.primary_key }
@@ -133,23 +132,110 @@ module Netzke
 
           filter_out_excluded_columns(columns_for_create) unless with_excluded
 
-          # Make the column config complete with the defaults
-          columns_for_create.each do |c|
-            detect_association(c)
+          # 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_header(c)
+            set_default_text(c)
             set_default_editor(c)
             set_default_width(c)
             set_default_hidden(c)
             set_default_editable(c)
             set_default_sortable(c)
             set_default_filterable(c)
+            c[:assoc] = association_attr?(c)
           end
 
-          columns_for_create
-        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
 
-        private
+          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) || nil
+            end
+          end
+
+          def set_default_sortable(c)
+            c[:sortable] = !c[:virtual] if c[:sortable].nil? # TODO: optimize - don't set it to false
+          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 = assoc_and_assoc_method_for_attr(c)
+            return unless assoc
+
+            assoc_column = assoc.klass.columns_hash[assoc_method]
+            assoc_method_type = assoc_column.try(:type)
+
+            # 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|
@@ -193,82 +279,36 @@ module Netzke
             # NetzkeModelAttrList.read_list(data_class.name) if persistent_config_enabled?
           end
 
-          def set_default_header(c)
-            c[:label] ||= data_class.human_attribute_name(c[:name])
-          end
-
-          def set_default_editor(c)
-            # c[:editor] ||= editor_for_attr_type(c[:attr_type]) # This is done in JS!
-            c[:editor] = {:xtype => c[:editor]} if c[:editor].is_a?(Symbol)
-          end
-
-          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?
-              not_editable_if = primary_key_attr?(c)
-              not_editable_if ||= c[:virtual] && !association_attr?(c[:name])
-              not_editable_if ||= c.delete(:read_only)
-
-              editable_if = data_class.column_names.include?(c[:name])
-              editable_if ||= data_class.instance_methods.map(&:to_s).include?("#{c[:name]}=")
-              editable_if ||= association_attr?(c[:name])
-
-              c[:editable] = editable_if && !not_editable_if
-            end
-          end
-
-          def set_default_sortable(c)
-            c[:sortable] = !c[:virtual] if c[:sortable].nil? # TODO: optimize - don't set it to false
-          end
-
-          def set_default_filterable(c)
-            c[:filterable] = !c[:virtual] if c[:filterable].nil?
-          end
-
-          # Returns editor's xtype for a column type
+          # Column editor config for attribute type.
           def editor_for_attr_type(type)
-            attr_type_to_editor_map[type] || :textfield
+            {:xtype => attr_type_to_editor_xtype_map[type] || :textfield}
           end
 
+          # Column editor config for one-to-many association
           def editor_for_association
-            :netzkeremotecombo
+            {:xtype => :netzkeremotecombo}
           end
 
-          # Returns a hash that maps a column type to the editor xtype. Override if you want different editors.
-          def attr_type_to_editor_map
+          # 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 => :datetimefield,
+              # :datetime => :datetimefield, WIP: waiting for Ext 4 fix
+              :datetime => :datefield,
               :text => :textarea,
               :string => :textfield
             }
           end
 
-          # Detects an association column and sets up the proper editor.
-          def detect_association(c)
-            assoc, assoc_method = assoc_and_assoc_method_for_column(c)
-            if assoc
-              assoc_column = assoc.klass.columns_hash[assoc_method]
-              assoc_method_type = assoc_column.try(:type)
-
-              # 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
-                c[:assoc] = true
-              end
-            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
@@ -284,11 +324,16 @@ module Netzke
             end
 
             selected_columns.map do |c|
-              field_config = {:name => c[:name]}
+              field_config = {
+                :name => c[:name],
+                :field_label => c[:text] || c[:header]
+              }
 
               # 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
@@ -305,7 +350,7 @@ module Netzke
 
           def columns_default_values
             columns.inject({}) do |r,c|
-              assoc, assoc_method = assoc_and_assoc_method_for_column(c)
+              assoc, assoc_method = assoc_and_assoc_method_for_attr(c)
               if c[:default_value].nil?
                 r
               else