netzke-basepack 0.4.2 → 0.5.1

data/lib/netzke/configuration_tool.rb

@@ -1,80 +0,0 @@
-module Netzke
-  #
-  # Include this module into any widget if you want a "Properties" tool button in the top toolbar which will triggger a modal window, which will load the Accordion widgets, which in its turn will contain all the aggregatees specified in "configuration_widgets" method (*must* be defined)
-  #
-  module ConfigurationTool
-    def self.included(base)
-      base.extend ClassMethods
-      
-      base.class_eval do
-        # replacing instance methods
-        [:tools, :initial_aggregatees].each{ |m| alias_method_chain m, :properties }
-
-        # replacing class methods
-        class << self
-          alias_method_chain :js_extend_properties, :properties
-        end
-      end
-
-      # if you include ConfigurationTool, you must define configuration_widgets method which will returns an array of arrgeratees that will be included in the property window (each in its own tab or accordion pane)
-      raise "configuration_widgets method undefined" unless base.instance_methods.include?("configuration_widgets")
-    end
-
-    module ClassMethods
-      def js_extend_properties_with_properties
-        js_extend_properties_without_properties.merge({
-          :gear => <<-JS.l
-            function(){
-              var w = new Ext.Window({
-                title:'Config',
-                layout:'fit',
-                modal:true,
-                width: Ext.lib.Dom.getViewWidth() *0.9,
-                height: Ext.lib.Dom.getViewHeight() *0.9,
-                closeAction:'destroy',
-                buttons:[{
-                  text:'Submit',
-                  handler:function(){
-                    this.ownerCt.closeRes = 'OK'; 
-                    this.ownerCt.close();
-                  }
-                }]
-
-              });
-
-              w.show(null, function(){
-                w.loadWidget(this.initialConfig.id+"__properties__get_widget");
-              }, this);
-
-              w.on('close', function(){
-                if (w.closeRes == 'OK'){
-                  widget = this;
-                  if (widget.ownerCt) {
-                    widget.ownerCt.loadWidget(widget.initialConfig.interface.getWidget);
-                  } else {
-                    this.feedback('Reload current window'); // we are embedded directly in HTML
-                  }
-                }
-              }, this);
-            }
-          JS
-        })
-      end
-    end
-
-    def initial_aggregatees_with_properties
-      res = initial_aggregatees_without_properties
-      # Add the accordion as aggregatee, which in its turn aggregates widgets from the configuration_widgets method
-      res.merge!(:properties => {:widget_class_name => 'TabPanel', :items => configuration_widgets, :ext_config => {:title => false}, :late_aggregation => true}) if config[:ext_config][:config_tool]
-      res
-    end
-
-    def tools_with_properties
-      tools = tools_without_properties
-      # Add the toolbutton
-      tools << 'gear' if config[:ext_config][:config_tool]
-      tools
-    end
-  
-  end
-end

data/lib/netzke/container.rb

@@ -1,77 +0,0 @@
-module Netzke
-  #
-  # Base class for Accordion and TabPanel widgets, it shouldn't be used as a stand-alone class.
-  #
-  class Container < Base
-    def initialize(*args)
-      super
-      for item in initial_items do
-        add_aggregatee item
-        items << item.keys.first
-      end
-    end
-    
-    def initial_dependencies
-      dep = super
-      for item in items
-        candidate_dependency = aggregatees[item][:widget_class_name]
-        dep << candidate_dependency unless dep.include?(candidate_dependency)
-      end
-      dep
-    end
-
-    def self.js_before_constructor
-      js_widget_items
-    end
-    
-    def items
-      @items ||= []
-    end
-    
-    def initial_items
-      config[:items] || []
-    end
-    
-    def self.js_widget_items
-      res = ""
-      item_aggregatees.each_pair do |k,v|
-        next if v[:late_aggregation]
-        res << <<-JS
-        var #{k.to_js} = new Ext.netzke.cache['#{v[:widget_class_name]}'](config.#{k.to_js}Config);
-        JS
-      end
-      res
-    end
-
-    def self.js_items
-      items.inject([]) do |a,i|
-        a << {
-          :title      => i.to_s.humanize,
-          :layout     => 'fit',
-          :id         => i.to_s,
-          :items      => ([i.to_s.to_js.l] if !aggregatees[i][:late_aggregation]),
-          :collapsed  => !aggregatees[i][:active],
-          :listeners  => {
-            :expand     => {:fn => "this.loadItemWidget".l, :scope => this}
-          }
-        }
-      end
-    end
-    
-    def self.js_extend_properties
-      {
-        # loads widget into the panel if it's not loaded yet
-        :load_item_widget => <<-JS.l,
-          function(panel) {
-            if (!panel.getWidget()) panel.loadWidget(this.id + "__" + panel.id + "__get_widget");
-          }
-        JS
-      }
-    end
-
-    protected
-    def self.item_aggregatees
-      aggregatees.delete_if{|k,v| !@items.include?(k)}
-    end
-  end
-end

data/lib/netzke/db_fields.rb

@@ -1,44 +0,0 @@
-module Netzke
-  module DbFields
-    #
-    # Default fields for a widget of class GridPanel or FormPanel
-    # It is a synthesis of 1) columns declared in the model, 2) columns provided in the configuration for the widget
-    #
-    def default_db_fields
-      config[:data_class_name].nil? && raise(ArgumentError, "No data_class_name specified for widget #{config[:name]}")
-      
-      data_class          = config[:data_class_name].constantize
-      exposed_columns     = normalize_columns(data_class.exposed_columns) # columns exposed from the data class
-      columns_from_config = (config[:fields] || config[:columns]) && normalize_columns(config[:fields] || config[:columns]) # columns specified in widget's config
-
-      if columns_from_config
-        # reverse-merge each column hash from config with each column hash from exposed_columns (columns from config have higher priority)
-        for c in columns_from_config
-          corresponding_exposed_column = exposed_columns.find{ |k| k[:name] == c[:name] }
-          c.reverse_merge!(corresponding_exposed_column) if corresponding_exposed_column
-        end
-        columns_for_create = columns_from_config
-      else
-        # we didn't have columns configured in widget's config, so, use the columns from the data class
-        columns_for_create = exposed_columns
-      end
-
-      res = []
-      for c in columns_for_create
-        # finally reverse-merge them with the defaults from the data_class
-        res << (self.class.widget_type == :grid ? data_class.default_column_config(c) : data_class.default_field_config(c))
-      end
-      
-      res
-    end
-
-    protected
-
-    # [:col1, {:name => :col2}, :col3] 
-    #    => [{:name => :col1}, {:name => :col2}, {:name => :col3}]
-    def normalize_columns(items)
-      items.map{|c| c.is_a?(Symbol) ? {:name => c} : c}
-    end
-    
-  end
-end

data/lib/netzke/fields_configurator_old.rb

@@ -1,62 +0,0 @@
-module Netzke
-  class FieldsConfigurator < GridPanel
-    interface :load_defaults
-
-    def self.js_base_class
-      GridPanel
-    end
-    
-    def initialize(*args)
-      super
-
-      config[:conditions]         = {:layout_id => config[:layout].id}
-      config[:data_class_name]    = config[:layout].items_class
-      # config[:persistent_layout]  = false
-    end
-
-    def initial_config
-      super.recursive_merge({
-        :name              => 'columns',
-        :widget_class_name => "GridPanel",
-        :ext_config        => {:title => false}
-      })
-    end
-    
-    def actions
-      super.merge(
-        :defaults => {:text => 'Restore defaults'}
-      )
-    end
-    
-    def bbar
-      super << "-" << "defaults"
-    end
-    
-    def self.js_extend_properties
-      super.merge({
-        :defaults => <<-JS.l,
-          function(){
-            Ext.Msg.confirm('Confirm', 'Are you sure?', function(btn){
-              if (btn == 'yes') {
-                Ext.Ajax.request({
-                  url:this.initialConfig.interface.loadDefaults,
-                  callback:function(){
-                    this.store.reload();
-                  },
-                  scope:this
-                })
-              }
-            }, this);
-          }
-        JS
-      })
-    end
-    
-    def load_defaults(params)
-      NetzkeLayout.destroy(config[:layout].id)
-      config[:data_class_name].constantize.create_layout_for_widget(parent.parent)
-      {}
-    end
-    
-  end
-end

data/lib/netzke/form_panel_extras/interface.rb

@@ -1,56 +0,0 @@
-module Netzke
-  module FormPanelExtras
-    module Interface
-      def submit(params)
-        params.delete(:authenticity_token)
-        params.delete(:controller)
-        params.delete(:action)
-
-        klass = config[:data_class_name].constantize
-        record = klass.find_by_id(params[:id])
-        success = true
-
-        record = klass.new if record.nil?
-
-        params.each_pair do |k,v|
-          begin
-            record.send("#{k}=",v)
-          rescue StandardError => exc
-            flash :error => exc.message
-            success = false
-            break
-          end
-        end
-    
-        if success && record.save
-          {:data => [record.to_array(fields)], :success => true}
-        else
-          # flash eventual errors
-          record.errors.each_full do |msg|
-            flash :error => msg
-          end
-          {:success => false, :flash => @flash}
-        end
-      end
-
-      def load(params)
-        klass = config[:data_class_name].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 => [record && record.to_array(fields)]}
-      end
-      
-      # Return the choices for the column
-      def get_cb_choices(params)
-        column = params[:column]
-        query = params[:query]
-    
-        {:data => config[:data_class_name].constantize.choices_for(column, query).map{|s| [s]}}
-      end
-        
-    end
-  end
-end

data/lib/netzke/form_panel_extras/js_builder.rb

@@ -1,134 +0,0 @@
-module Netzke
-  module FormPanelExtras
-    module JsBuilder
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
-      module ClassMethods
-        def js_base_class
-          "Ext.FormPanel"
-        end
-
-        def js_before_constructor
-          <<-JS
-          var fields = config.fields;
-          var recordFields = [];
-          var index = 0;
-          Ext.each(fields, function(field){
-            recordFields.push({
-              name:field.name, 
-              mapping:index++
-            });
-            field.hideLabel = field.hidden; // completely hide fields marked "hidden"
-            var extConfig;
-            try{
-              extConfig = Ext.decode(field.extConfig)
-            }
-            catch(err){
-              extConfig = {}
-            }
-            delete(field.extConfig);
-            Ext.apply(field, extConfig);
-
-            field.parentConfig = config;
-            field.fieldConfig = field;
-          }, this);
-          var Record = Ext.data.Record.create(recordFields);
-          this.reader = new Ext.data.RecordArrayReader({root:"data"}, Record);
-          JS
-        end
-
-        def js_default_config
-          super.merge({
-            :auto_scroll    => true,
-            :bbar           => "config.actions".l,
-            # :plugins      => "plugins".l,
-            :items          => "fields".l,
-            :default_type   => 'textfield',
-            :body_style     => 'padding:5px 5px 0',
-            :label_width    => 150,
-            :listeners      => {
-      				:afterlayout => {
-      				  :fn => "this.afterlayoutHandler".l,
-      				  :scope => this
-  				    }
-				    },
-            :defaults       => {
-              # :anchor       => '-20', # to leave some space for the scrollbar
-              :width => 180,
-              :listeners    => {
-        				:specialkey => {
-        				  :fn => <<-JS.l,
-          				  function(field, event){
-            					if (event.getKey() == 13) this.apply();
-            				}
-        				  JS
-        				  :scope => this
-      				  }
-              }
-            }
-          })
-        end
-        
-        def js_extend_properties
-          {
-            :load_record => <<-JS.l,
-              function(id, neighbour){
-                var proxy = new Ext.data.HttpProxy({url:this.initialConfig.interface.load});
-                proxy.load({id:id, neighbour:neighbour}, this.reader, function(data){
-                  if (data){
-                    this.form.loadRecord(data.records[0])
-                  }
-                }, this)
-              }
-            JS
-            :afterlayout_handler => <<-JS.l,
-              function() {
-                // Load initial data into the form
-                if (this.initialConfig.recordData){
-                  var record = this.reader.readRecord(this.initialConfig.recordData);
-                  this.form.loadRecord(record);
-                }
-              }
-            JS
-            :refresh=> <<-JS.l,
-              function() {
-                this.feedback('Implement me!');
-              }
-            JS
-            :previous => <<-JS.l,
-              function() {
-                var currentId = this.form.getValues().id;
-                this.loadRecord(currentId, 'previous');
-              }
-            JS
-            :next => <<-JS.l,
-              function() {
-                var currentId = this.form.getValues().id;
-                this.loadRecord(currentId, 'next');
-              }
-            JS
-            :apply => <<-JS.l,
-              function() {
-                this.form.submit({
-                  url:this.initialConfig.interface.submit,
-                  success :function(form, action){
-                    if (action.result.flash) this.feedback(action.result.flash);
-                    this.form.loadRecord(this.reader.readRecord(action.result.data[0]));
-                  },
-                  failure :function(form, action){
-                    this.feedback(action.result.flash)
-                  },
-                  scope :this
-                })
-              }
-            JS
-          }
-        end
-        
-      end
-      
-    end
-  end
-end