skozlov-netzke-basepack 0.1.1.2 → 0.5.0

data/lib/netzke/border_layout_panel.rb

@@ -0,0 +1,128 @@
+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 => {:widget_class_name => "Panel", :ext_config => {:html => "A panel"}}, 
+  #       :west => {
+  #         :widget_class_name => "GridPanel", 
+  #         :data_class_name => "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;
+                regionConfig.items = [new Ext.netzke.cache[this[configName].widgetClassName](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
+            Ext.netzke.cache.BorderLayoutPanel.superclass.initComponent.call(this);
+            
+            // First time on "afterlayout", set resize events
+            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)
+      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

@@ -0,0 +1,24 @@
+module Netzke
+  # TabPanel-based widget that wraps-up "conifuration 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)
+      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/data_accessor.rb

@@ -0,0 +1,71 @@
+module Netzke
+  # This module is included into such data-driven widgets as GridPanel, FormPanel, etc. It provides for
+  # flexible pre-configuration of (virtual) attributes.
+  #
+  # TODO: show examples of how to create the helpers
+  module DataAccessor
+    
+    # This method should be called from the constructor of the widget. It dynamically includes:
+    # 1) helpers into the data model for this widget; those may contain instance methods used as virtual attributes
+    # 2) generic (used by all "data accessor" widgets) extensions into the data model for this widget
+    def apply_helpers
+      # Generic extensions to the data model
+      if data_class # because some widgets, like FormPanel, may have it optional
+        data_class.send(:include, Netzke::ActiveRecord::DataAccessor) if !data_class.include?(Netzke::ActiveRecord::DataAccessor)
+      
+        # Model helpers
+        const_name = "Netzke::Helpers::#{data_class.name}"
+        model_extensions = const_name.constantize rescue nil
+        data_class.send(:include, model_extensions) if model_extensions && !data_class.include?(model_extensions)
+      end
+    end
+
+    # Returns columns that are exposed by the class and the helpers
+    def predefined_columns
+      helper_module = "Netzke::Helpers::#{short_widget_class_name}#{data_class.name}".constantize rescue nil
+      
+      data_class_columns = data_class.column_names.map(&:to_sym)
+      
+      if helper_module
+        exposed_attributes = helper_module.respond_to?(:exposed_attributes) ? normalize_array_of_columns(helper_module.exposed_attributes) : nil
+        virtual_attributes = helper_module.respond_to?(:virtual_attributes) ? helper_module.virtual_attributes : []
+        excluded_attributes = helper_module.respond_to?(:excluded_attributes) ? helper_module.excluded_attributes : []
+        attributes_config = helper_module.respond_to?(:attributes_config) ? helper_module.attributes_config : {}
+        
+        res = exposed_attributes || data_class_columns + virtual_attributes
+        
+        res = normalize_columns(res)
+        
+        res.reject!{ |c| excluded_attributes.include? c[:name] }
+
+        res.map!{ |c| c.merge!(attributes_config[c[:name]] || {})}
+      else
+        res = normalize_columns(data_class_columns)
+      end
+      
+      res
+    end
+
+    # Make sure we have keys as symbols, not strings
+    def normalize_array_of_columns(arry)
+      arry.map do |f| 
+        if f.is_a?(Hash)
+          f.symbolize_keys
+        else
+          f.to_sym
+        end
+      end
+    end
+    
+    # From symbol to config hash
+    def normalize_column(field)
+      field.is_a?(Symbol) ? {:name => field} : field
+    end
+    
+    # From symbols to config hashes
+    def normalize_columns(items)
+      items.map{|c| normalize_column(c)}
+    end
+    
+  end
+end

data/lib/netzke/ext.rb

@@ -0,0 +1,6 @@
+module Netzke
+  # Ext-related module. Some constants provide meta-information about the Ext.library.
+  module Ext
+    FORM_FIELD_XTYPES = %w{ textfield numberfield textarea combobox checkbox xdatetime }
+  end
+end

data/lib/netzke/field_model.rb

@@ -0,0 +1,131 @@
+module Netzke
+  class FieldModel < Hash
+    include BasepackActiveRecord
+    
+    def self.new_from_hash(hsh)
+      self.new.replace(hsh)
+    end
+    
+    # def self.json=(str)
+    #   @@data = ActiveSupport::JSON.decode(str)
+    #   process_data
+    # end
+
+    def self.widget_name=(w)
+      @@widget_name = w
+    end
+
+    def self.data_storage=(ds)
+      @@storage = ds
+      process_data
+    end
+
+    # def self.data=(data)
+    #   @@raw_data = data
+    #   process_data
+    # end
+    
+    def self.column_names
+      @@data.inject([]){|res, record| (res + record.keys).uniq}
+    end
+    
+    def self.columns
+      column_names
+    end
+    
+    def self.all(params={})
+      @@data
+    end
+    
+    def self.first
+      @@data[0]
+    end
+    
+    def self.find(id)
+      @@data[id-1]
+    end
+    
+    def self.count(params = {})
+      @@data.size
+    end
+    
+    def self.columns_hash
+      @@columns_hash
+    end
+    
+    def self.reflect_on_all_associations
+      []
+    end
+    
+    # instance methods
+    def id
+      self[:id] || self["id"]
+    end
+    
+    def errors
+      []
+    end
+    
+    def save
+      true
+    end
+    
+    private
+    def self.process_data
+      @@columns_hash = {}
+
+      @@data = []
+      
+      # convert array of hashes into array of FieldModel instances
+      @@storage.each do |hsh|
+        @@data << new_from_hash(hsh)
+      end
+
+      @@data.each do |record|
+        record.keys.each do |k|
+          
+          if @@columns_hash[k.to_s].nil?
+            
+            # calculate column type
+            puts record[k].class.to_s
+            column_type = case record[k].class.to_s
+              when "TrueClass"
+                :boolean
+              when "FalseClass"
+                :boolean
+              when "String"
+                :string
+              when "Fixnum"
+                :integer
+              else
+                :string
+              end
+            
+            column = {:type => column_type}
+
+            # workaround for the "type" method
+            class << column
+              def type
+                self[:type]
+              end
+            end
+
+            @@columns_hash[k.to_s] = column
+          end
+        end
+      end
+    end
+
+    # # Testing
+    # @@data = [
+    #   self.new_from_hash({"id" => 1, "name" => "col1", "column_type" => "text", "read_only" => true}),
+    #   self.new_from_hash({"id" => 2, "name" => "col2", "column_type" => "string", "read_only" => false})
+    # ]
+    # 
+    # process_data
+    # end testing
+
+  end
+  
+  
+end

data/lib/netzke/fields_configurator.rb

@@ -0,0 +1,95 @@
+module Netzke
+  # == FieldsConfigurator
+  # Provides dynamic configuring columns/fields for GridPanel and FormPanel.
+  # Configuration parameters:
+  # * <tt>:widget</tt> - widget to configure columns/fields for
+  class FieldsConfigurator < GridPanel
+    api :load_defaults
+
+    def initialize(*args)
+      super
+      NetzkeAutoColumn.widget = config[:widget]
+    end
+
+    def default_config
+      super.deep_merge({
+        :name              => 'columns',
+        :data_class_name   => "NetzkeAutoColumn",
+        :ext_config        => {
+          :header => false,
+          :enable_extended_search => false,
+          :enable_edit_in_form => false,
+          :enable_rows_reordering => GridPanel.config[:rows_reordering_available],
+          :enable_pagination => false
+        },
+      })
+    end
+    
+    def actions
+      super.merge(
+        :defaults => {:text => 'Restore defaults'}
+      )
+    end
+    
+    def independent_config
+      res = super
+      res[:ext_config][:bbar] = %w{ edit apply - defaults }
+      res
+    end
+        
+    def predefined_columns
+      [{:name => :id}, *config[:widget].class.config_columns]
+    end
+        
+    def self.js_extend_properties
+      {
+        # Disable the 'gear' tool for now
+        :gear => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            this.feedback("You can't configure configurator (yet)");
+          }
+        END_OF_JAVASCRIPT
+        
+        # we need to provide this function so that the server-side commit would happen
+        :get_commit_data => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            return null; // because our commit data is already at the server
+          }
+        END_OF_JAVASCRIPT
+        
+        :defaults => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            Ext.Msg.confirm('Confirm', 'Are you sure?', function(btn){
+              if (btn == 'yes') {
+                this.loadDefaults();
+              }
+            }, this);
+          }
+        END_OF_JAVASCRIPT
+      }
+    end
+    
+    def load_defaults(params)
+      config[:widget].persistent_config[:layout__columns] = config[:widget].default_columns
+      NetzkeAutoColumn.rebuild_table
+      {:load_store_data => get_data, :reconfigure => js_config}
+    end
+   
+    def commit(params)
+      defaults_hash = config[:widget].class.config_columns.inject({}){ |r, c| r.merge!(c[:name] => c[:default]) }
+      config[:widget].persistent_config[:layout__columns] = NetzkeAutoColumn.all_columns.map do |c| 
+        # reject all keys that are 1) same as defaults, 2) 'position'
+        c.reject!{ |k,v| defaults_hash[k.to_sym].to_s == v.to_s || k == 'position'} 
+        c = c["name"] if c.keys.count == 1 # denormalize the column
+        c
+      end
+      {}
+    end
+   
+    # each time that we are loaded into the app, rebuild the table
+    def before_load
+      NetzkeAutoColumn.rebuild_table
+    end
+   
+  end
+end