netzke-basepack 0.5.14 → 0.6.0

data/lib/netzke/border_layout_panel.rb

@@ -1,130 +0,0 @@
-module Netzke
-  # Represents the Ext.Panel with layout 'border'. May serve as parent class for compound widgets.
-  # 
-  # == Features:
-  # * Responds to region resizing, storing the sizes in persistent config
-  # 
-  # == Future features:
-  # * Stores expand/collapse state in the persistent config
-  # 
-  # == Non-functional features:
-  # * (JavaScript) Creates convinient methods to access aggregatees inside the regions, like
-  # <tt>getCenterWidget()</tt>, <tt>getWestWidget()</tt>, etc
-  # 
-  # == Configuration:
-  # <tt>:regions</tt> - a hash in form:
-  #       
-  #     {:center => {<netzke widget config>}, :east => {<another netzke widget config>}, ...}
-  # 
-  # <tt>:regions => :center/:west/:etc => :region_config</tt> - configuration options for
-  # Ext.layout.BorderLayout.SplitRegion.
-  #     
-  # == Example configuration:
-  # 
-  #     :regions => {
-  #       :center => {:class_name => "Panel", :ext_config => {:html => "A panel"}}, 
-  #       :west => {
-  #         :class_name => "GridPanel", 
-  #         :model => "User", 
-  #         :region_config => {
-  #           :width => 100,
-  #           :split => true
-  #         }
-  #       }
-  #     }
-  class BorderLayoutPanel < Base
-    REGIONS = %w(center west east south north).map(&:to_sym)
-
-    # JavaScript part
-    def self.js_extend_properties
-      {
-        :layout => 'border',
-        
-        :init_component => <<-END_OF_JAVASCRIPT.l,
-          function(){
-            this.items = [];
-            Ext.each(['center', 'west', 'east', 'south', 'north'], function(r){
-              var configName = r+'Config';
-              if (this[configName]){
-                var regionConfig = this.regions[r] || {};
-                regionConfig.layout = 'fit';
-                regionConfig.region = r;
-                var klass = this.classifyScopedName(this[configName].scopedClassName);
-                regionConfig.items = [new klass(this[configName])]
-                this.items.push(regionConfig);
-
-                // A function to access a region widget (even if the widget gets reloaded, the function will work).
-                // E.g.: getEastWidget()
-                this['get'+r.capitalize()+'Widget'] = function(){
-                  return this.find('region', r)[0].getWidget()
-                }.createDelegate(this);
-              };
-            }, this);
-            
-            // Now let Ext.Panel do the rest
-            #{js_full_class_name}.superclass.initComponent.call(this);
-            
-            // First time on "afterlayout", set resize events
-            if (this.persistentConfig) {this.on('afterlayout', this.setResizeEvents, this, {single: true});}
-          }
-        END_OF_JAVASCRIPT
-        
-        :get_region_widget => <<-END_OF_JAVASCRIPT.l,
-          function(region){
-            return this.find('region', region)[0].getWidget();
-          }
-        END_OF_JAVASCRIPT
-        
-        :set_resize_events => <<-END_OF_JAVASCRIPT.l,
-        function(){
-          this.items.each(function(item, index, length){
-            if (!item.oldSize) item.oldSize = item.getSize();
-            if (item.region == 'east' || item.region == 'west') item.on('resize', function(panel, w, h){
-              if (panel.oldSize.width != w) {
-                this.resizeRegion({region_name: panel.region, new_width:w});
-                panel.oldSize.width = w;
-              }
-              return true;
-            }, this);
-            else if (item.region == 'south' || item.region == 'north') item.on('resize', function(panel, w, h){
-              if (panel.oldSize.height != h) {
-                this.resizeRegion({region_name: panel.region, new_height:h});
-                panel.oldSize.height = h;
-              }
-              return true;
-            }, this);
-          }, this);
-        }
-      END_OF_JAVASCRIPT
-    }
-    end
-
-    def initial_aggregatees
-      config[:regions] || {}
-    end
-    
-    def region_aggregatees
-      aggregatees.reject{ |k,v| !REGIONS.include?(k) }
-    end
-    
-    def js_config
-      regions = {}
-      REGIONS.each do |r|
-        if region_aggr = aggregatees[r]
-          regions.merge!(r => region_aggr[:region_config] || {})
-        end
-      end
-      super.merge(:regions => regions)
-    end
-
-    # API
-    api :resize_region # handles regions resize
-    def resize_region(params)
-      # Write to persistent_config such way that these settings are automatically picked up by region widgets
-      persistent_config["regions__#{params["region_name"]}__region_config__width"] = params["new_width"].to_i if params["new_width"]
-      persistent_config["regions__#{params["region_name"]}__region_config__height"] = params["new_height"].to_i if params["new_height"]
-      {}
-    end
-    
-  end
-end

data/lib/netzke/configuration_panel.rb

@@ -1,24 +0,0 @@
-module Netzke
-  # TabPanel-based widget that wraps-up "configuration widgets" that each widget can define 
-  # (along) with including the Plugins::ConfigurationTool tool.
-  class ConfigurationPanel < TabPanel
-    api :commit
-    def commit(params)
-      commit_data = ActiveSupport::JSON.decode params[:commit_data]
-      commit_data.each_pair do |k,v|
-        aggregatee_instance(k).commit(v) if aggregatee_instance(k).respond_to?(:commit)
-      end
-      {:reload_parent => true, :feedback => (@flash.empty? ? nil : @flash)}
-    end
-    
-    def self.js_extend_properties
-      {
-        :reload_parent => <<-END_OF_JAVASCRIPT.l,
-          function(){
-            this.getParent().reload();
-          }
-        END_OF_JAVASCRIPT
-      }
-    end
-  end
-end

data/lib/netzke/form_panel.rb

@@ -1,138 +0,0 @@
-require "netzke/form_panel/form_panel_js"
-require "netzke/form_panel/form_panel_api"
-require "netzke/form_panel/form_panel_fields"
-require "netzke/plugins/configuration_tool"
-require "netzke/data_accessor"
-
-module Netzke
-  # = FormPanel
-  # 
-  # Represents Ext.form.FormPanel
-  # 
-  # == Configuration
-  # * <tt>:model</tt> - name of the ActiveRecord model that provides data to this GridPanel.
-  # * <tt>:record</tt> - record to be displayd in the form. Takes precedence over <tt>:record_id</tt>
-  # * <tt>:record_id</tt> - id of the record to be displayd in the form. Also see <tt>:record</tt>
-  # 
-  # In the <tt>:ext_config</tt> hash (see Netzke::Base) the following FormPanel specific options are available:
-  # 
-  # * <tt>:mode</tt> - when set to <tt>:config</tt>, FormPanel loads in configuration mode
-  class FormPanel < Base
-    include FormPanelJs  # javascript (client-side)
-    include FormPanelApi # API (server-side)
-    include FormPanelFields # fields
-    include Netzke::DataAccessor # some code shared between GridPanel, FormPanel, and other widgets that use database attributes
-
-    # Class-level configuration with defaults
-    def self.config
-      set_default_config({
-        :config_tool_available       => true,
-        
-        :default_config => {
-          :persistent_config => true,
-          :ext_config => {
-            :tools => []
-          },
-        }
-      })
-    end
-    
-    def initial_config
-      res = super
-      res[:ext_config][:bbar] = default_bbar if res[:ext_config][:bbar].nil?
-      res
-    end
-
-    def default_bbar
-      %w{ apply }
-    end
-    
-    # Extra javascripts
-    def self.include_js
-      [
-        "#{File.dirname(__FILE__)}/form_panel/javascripts/xcheckbox.js",
-        Netzke::Base.config[:ext_location] + "/examples/ux/fileuploadfield/FileUploadField.js",
-        "#{File.dirname(__FILE__)}/form_panel/javascripts/netzkefileupload.js"
-      ]
-    end
-    
-    api :netzke_submit, :netzke_load, :get_combobox_options
-
-    attr_accessor :record
-    
-    def initialize(*args)
-      super
-      apply_helpers
-    end
-    
-    # Model class
-    # (We can't memoize this method because at some point we extend it, e.g. in Netzke::DataAccessor)
-    def data_class
-      @data_class ||= begin
-        klass = "Netzke::ModelExtensions::#{config[:model]}For#{short_widget_class_name}".constantize rescue nil
-        klass || original_data_class
-      end
-    end
-    
-    # Model class before model extensions are taken into account
-    def original_data_class
-      @original_data_class ||= begin
-        ::ActiveSupport::Deprecation.warn("data_class_name option is deprecated. Use model instead", caller) if config[:data_class_name]
-        model_name = config[:model] || config[:data_class_name]
-        model_name && model_name.constantize
-      end
-    end
-    
-    def record
-      @record ||= config[:record] || config[:record_id] && data_class && data_class.find(:first, :conditions  => {data_class.primary_key => config[:record_id]})
-    end
-    
-    def configuration_widgets
-      res = []
-      
-      res << {
-        :name              => 'fields',
-        :class_name => "FieldsConfigurator",
-        :active            => true,
-        :owner             => self,
-        :persistent_config => true
-      }
-
-      res << {
-        :name               => 'general',
-        :class_name  => "PropertyEditor",
-        :widget             => self,
-        :ext_config         => {:title => false}
-      }
-      
-      res
-    end
-
-    def actions
-      actions = {
-        :apply => {:text => 'Apply'}
-      }
-      
-      if Netzke::Base.config[:with_icons]
-        icons_uri = Netzke::Base.config[:icons_uri]
-        actions.deep_merge!(
-          :apply => {:icon => icons_uri + "tick.png"}
-        )
-      end
-      
-      actions
-    end
-    
-    def self.property_fields
-      res = [
-        {:name => "ext_config__title",               :attr_type => :string},
-        {:name => "ext_config__header",              :attr_type => :boolean, :default => true},
-        # {:name => "ext_config__bbar",              :attr_type => :json}
-      ]
-      
-      res
-    end
- 
-    include Plugins::ConfigurationTool if config[:config_tool_available] # it will load ConfigurationPanel into a modal window      
-  end
-end

data/lib/netzke/form_panel/form_panel_api.rb

@@ -1,81 +0,0 @@
-module Netzke
-  class FormPanel < Base
-    module FormPanelApi
-      # API handling form submission
-      def netzke_submit(params)
-        success = create_or_update_record(params)
-
-        if success
-          {:set_form_values => array_of_values, :set_result => "ok"}
-        else
-          # flash eventual errors
-          @record.errors.each_full do |msg|
-            flash :error => msg
-          end
-          {:feedback => @flash}
-        end
-      end
-
-      # Creates/updates a record from hash
-      def create_or_update_record(params)
-        hsh = ActiveSupport::JSON.decode(params[:data])
-        hsh.merge!(config[:strong_default_attrs]) if config[:strong_default_attrs]
-        @record ||= data_class.find(:first, :conditions => {data_class.primary_key => hsh.delete(data_class.primary_key)}) # only pick up the record specified in the params if it was not provided in the configuration
-        success = true
-
-        @record = data_class.new if @record.nil?
-
-        hsh.each_pair do |k,v|
-          begin
-            @record.send("#{k}=",v)
-          rescue StandardError => exc
-            flash :error => exc.message
-            success = false
-            break
-          end
-        end
-    
-        # did we have complete success?
-        success && @record.save
-      end
-
-      # API handling form load
-      # def load(params)
-      #   klass = config[:model].constantize
-      #   case params[:neighbour]
-      #     when "previous" then @record = klass.previous(params[:id])
-      #     when "next"     then @record = klass.next(params[:id])
-      #     else                 @record = klass.find(params[:id])
-      #   end
-      #   {:data => [array_of_values]}
-      # end
-  
-      def netzke_load(params)
-        @record = data_class && data_class.find_by_id(params[:id])
-        {:set_form_values => array_of_values}
-      end
-  
-      # API that returns options for a combobox
-      def get_combobox_options(params)
-        column = params[:column]
-        query = params[:query]
-        
-        column = fields.detect{ |c| c[:name] == params[:column] }.try(:to_options!)
-        scopes = column.to_options[:scopes]
-        query = params[:query]
-
-        {:data => combobox_options_for_column(column, :query => query, :scopes => scopes)}
-      end
-  
-      def configuration_panel__fields__get_combobox_options(params)
-        query = params[:query]
-        {:data => (default_columns.map{ |c| c[:name].to_s }).grep(/^#{query}/).map{ |n| [n] }}.to_nifty_json
-      end
-  
-      # Returns array of form values according to the configured columns
-      def array_of_values
-        @record && @record.to_array(fields, self)
-      end
-    end
-  end
-end

data/lib/netzke/form_panel/form_panel_fields.rb

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