skozlov-netzke-basepack 0.1.1.2 → 0.5.0

data/lib/netzke/panel.rb

@@ -0,0 +1,13 @@
+module Netzke
+  class Panel < Base
+    def self.js_extend_properties
+      {
+        :update_body_html => <<-END_OF_JAVASCRIPT.l,
+          function(html){
+            this.body.update(html);
+          }
+        END_OF_JAVASCRIPT
+      }
+    end
+  end
+end

data/lib/netzke/plugins/configuration_tool.rb

@@ -0,0 +1,121 @@
+module Netzke::Plugins
+  # Include this module into any widget where you want a "gear" tool button in the top toolbar 
+  # which will triggger a modal window, which will load the ConfigurationPanel TabPanel-based 
+  # widget, which in its turn will contain all the aggregatees specified in widget's "configuration_widgets" 
+  # method (which *must* be defined)
+  module ConfigurationTool
+    def self.included(base)
+      base.extend ClassMethods
+      
+      base.class_eval do
+        # replacing instance methods
+        [:config, :initial_aggregatees, :js_config].each{ |m| alias_method_chain m, :config_tool }
+        
+        # replacing class methods
+        class << self
+          alias_method_chain :js_extend_properties, :config_tool
+        end
+
+        # API to commit the changes
+        api :commit
+      end
+
+      # if you include ConfigurationTool, you are supposed to provide 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_config_tool
+        js_extend_properties_without_config_tool.merge({
+          :gear => <<-END_OF_JAVASCRIPT.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:'OK',
+                  disabled: !this.configurable,
+                  tooltip: this.configurable ? null : "No dynamic configuration for this component",
+                  handler:function(){
+                    w.closeRes = 'OK'; 
+                    w.close();
+                  }
+                },{
+                  text:'Cancel',
+                  handler:function(){
+                    w.closeRes = 'cancel'; 
+                    w.close();
+                  }
+                }]
+
+              });
+
+              w.show(null, function(){
+                this.loadAggregatee({id:"configuration_panel", container:w.id});
+              }, this);
+
+              w.on('close', function(){
+                if (w.closeRes == 'OK'){
+                  var configurationPanel = this.getChildWidget('configuration_panel');
+                  var panels = configurationPanel.getLoadedChildren();
+                  var commitData = {};
+                  Ext.each(panels, function(p){
+                    if (p.getCommitData) {commitData[p.localId(configurationPanel)] = p.getCommitData();}
+                  }, this);
+                  configurationPanel.commit({commit_data:Ext.encode(commitData)});
+                }
+              }, this);
+            }
+          END_OF_JAVASCRIPT
+        })
+      end
+    end
+
+    def config_with_config_tool
+      orig_config = config_without_config_tool
+      return orig_config unless config_tool_needed?
+      orig_config.deep_merge({
+        :ext_config => {
+          :tools => orig_config[:ext_config][:tools].clone << "gear",
+          :header => true
+        }
+      })
+    end
+
+    def initial_aggregatees_with_config_tool
+      res = initial_aggregatees_without_config_tool
+      
+      # Add the ConfigurationPanel as aggregatee, which in its turn aggregates widgets from the 
+      # configuration_widgets method
+      res.merge!(:configuration_panel => {
+        :widget_class_name => 'ConfigurationPanel', 
+        :items => configuration_widgets,
+        :late_aggregation => true
+      }) if config_tool_needed?
+      
+      res
+    end
+
+    def tools_with_config_tool
+      tools = tools_without_config_tool
+      # Add the toolbutton
+      tools << 'gear' if config_tool_needed?
+      tools
+    end
+  
+    def js_config_with_config_tool
+      orig_config = js_config_without_config_tool
+      orig_config.merge(:configurable => config[:persistent_config])
+    end
+  
+    def config_tool_needed?
+      config_without_config_tool[:ext_config][:config_tool] || config_without_config_tool[:ext_config][:mode] == :config
+    end
+  
+  end
+end

data/lib/netzke/property_editor.rb

@@ -0,0 +1,105 @@
+module Netzke
+  class PropertyEditor < FormPanel
+    
+    def initialize(*args)
+      super
+      @widget = @passed_config[:widget]
+    end
+    
+    def independent_config
+      res = super
+      res[:ext_config][:bbar] = %w{ restore_defaults }
+      res
+    end
+
+    def actions
+      {:restore_defaults => {:text => "Restore defaults"}}
+    end
+
+    def get_columns
+      fields = @widget.class.property_fields
+
+      for f in fields
+        f[:value] = @widget.flat_config(f[:name]).nil? ? f[:default] : @widget.flat_config(f[:name])
+        f[:xtype] = XTYPE_MAP[f[:type]]
+        f[:field_label] = f[:name].to_s.gsub("__", "/").humanize
+      end
+      
+      fields
+    end
+    
+    def self.js_extend_properties
+      {
+        :label_width => 200,
+        
+        # Disable the 'gear' tool for now
+        :gear => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            this.feedback("You can't configure property editor (yet)");
+          }
+        END_OF_JAVASCRIPT
+        
+        :restore_defaults => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            this.restoreDefaults();
+          }
+        END_OF_JAVASCRIPT
+        
+        :get_commit_data => <<-END_OF_JAVASCRIPT.l
+          function(){
+            if (!this.getForm().isValid()) {this.getForm().reset()}; // if some fields are invalid, don't send anything
+            var values = this.getForm().getValues();
+            for (var k in values) {
+              if (values[k] == "") {values[k] = null}
+            }
+            return values;
+          }
+        END_OF_JAVASCRIPT
+      }
+    end
+    
+    api :restore_defaults
+    def restore_defaults(params)
+      values = []
+      columns.each do |c|
+        init_config = @widget.flat_initial_config.detect{ |ic| ic[:name] == c[:name] }
+        
+        if init_config.nil?
+          property_fields ||= @widget.class.property_fields
+          values << property_fields.detect{ |f| f[:name] == c[:name] }[:default]
+        else
+          values << init_config[:value]
+        end
+        
+      end
+      {:set_form_values => values}
+    end
+    
+    def commit(data)
+      fields = @widget.class.property_fields
+      data.each_pair do |property, value|
+        field = fields.detect{ |f| f[:name] == property.to_sym }
+        # default = @widget.config[property].nil? ? field[:default] : @widget.config[property]
+        default = @widget.flat_initial_config(property).nil? ? field[:default] : @widget.flat_initial_config(property)
+        # Only store the value in persistent config when it's different from the default one
+        if field[:type] == :boolean
+          # handle boolean type separately
+          value = value.to_b
+          @widget.persistent_config[property] = value ^ default ? value : nil
+        else 
+          if field[:type] == :json
+            value = ActiveSupport::JSON.decode(value)
+          end
+
+          # Empty string means "null" for now...
+          # value = nil if value.blank?
+          # logger.debug "!!! value: #{value.inspect}\n"
+          
+          @widget.persistent_config[property] = default == value ? nil : value
+        end
+      end
+      {}
+    end
+    
+  end
+end

data/lib/netzke/property_editor_extras/helper_model.rb

@@ -0,0 +1,126 @@
+module Netzke
+  module PropertyEditorExtras 
+    class HelperModel
+      def self.widget=(w)
+        @@widget = w
+      end
+      
+      def self.widget
+        @@widget ||= raise RuntimeError, "No widget specified for PropertyEditorExtras::HelperModel"
+      end
+      
+      def self.reflect_on_all_associations
+        []
+      end
+      
+      def self.primary_key
+        "id"
+      end
+      
+      def self.netzke_exposed_attributes
+        preferences = self.widget.flat_default_config
+        # preferences = NetzkePreference.find_all_for_widget(widget.name)
+        preferences.each { |p| p.reject!{ |k,v| k == :value}.merge!(:field_label => p[:name].to_s.gsub('__', "/").humanize) }
+        preferences
+      end
+
+      DEFAULTS_FOR_FIELD = {
+        :Fixnum => {
+          :xtype => :numberfield
+        },
+        :Boolean => {
+          :xtype => :xcheckbox,
+          :checked => true
+        },
+        :String => {
+          :xtype => :textfield
+        }
+      }
+
+      # DRY out!
+      def self.default_field_config(config)
+        type = config.delete(:type)
+
+        common = {
+          :field_label => config[:name].to_s.gsub('__', '_').humanize,
+          :hidden      => config[:name] == :id
+        }
+
+        default = DEFAULTS_FOR_FIELD[type] || DEFAULTS_FOR_FIELD[:String] # fallback to plain textfield
+
+        res = default.merge(common).merge(config)
+      end
+  
+      def self.find_by_id(*args)
+        self.new
+      end
+  
+      def save
+      end
+  
+      def errors
+        a = Array.new
+        def a.each_full
+          []
+        end
+        a
+      end
+  
+      def to_array(columns)
+        res = []
+        for c in columns
+          method = c.is_a?(Symbol) ? c : c[:name]
+          value = send(method)
+          res << (value.is_a?(Array) || value.is_a?(Hash) ? value.to_json : value)
+        end
+        res
+      end
+
+      # somewhat sofisticated code to convert all NetzkePreferences for current widget into a hash ("un-flatten")
+      def attributes
+        prefs = NetzkePreference.find_all_for_widget(self.class.widget.id_name)
+        res = {}
+        prefs.each do |p|
+          tmp_res = {}
+          hsh_levels = p.name.split("__").map(&:to_sym)
+          hsh_levels.each do |level_prefix|
+            tmp_res[level_prefix] ||= level_prefix == hsh_levels.last ? p.normalized_value : {}
+            res[level_prefix] = tmp_res[level_prefix] if level_prefix == hsh_levels.first
+            tmp_res = tmp_res[level_prefix]
+          end
+        end
+        res
+      end
+
+      def method_missing(method_name, *args)
+        # Rails.logger.debug "!!! method_name: #{method_name.inspect}"
+        method_name = method_name.to_s
+        method_name_without_equal_sign = method_name.sub(/=$/, '')
+        NetzkePreference.widget_name = self.class.widget.id_name
+
+        if method_name =~ /=$/
+          # current_value = NetzkePreference[method_name_without_equal_sign] # may be nil
+          current_value = self.class.widget.flat_independent_config(method_name_without_equal_sign)
+          
+          begin
+            new_value = ActiveSupport::JSON.decode(args.first) # TODO: provide feedback about this error
+          rescue ActiveSupport::JSON::ParseError
+            new_value = current_value
+          end
+          
+          # default_value = self.class.widget.flat_default_config(method_name_without_equal_sign)
+          initial_value = self.class.widget.flat_initial_config(method_name_without_equal_sign)
+      
+          new_value = nil if new_value == initial_value
+          # Rails.logger.debug "!!! new_value: #{new_value.inspect}"
+          NetzkePreference[method_name_without_equal_sign] = new_value
+        else
+          res = self.class.widget.flat_independent_config(method_name_without_equal_sign)
+          res = ActiveSupport::JSON.encode(res) if res.is_a?(Array) || res.is_a?(Hash)
+          res
+        end
+      end
+  
+    end
+  end
+end

data/lib/netzke/search_panel.rb

@@ -0,0 +1,62 @@
+module Netzke
+  # SearchPanel
+  # 
+  # FormPanel-based widget that allows create configurable searchlogic-compatible searches. 
+  # Pretty much work in progress.
+  class SearchPanel < FormPanel
+    # Something like [:equals, :greater_than_or_equal_to, :does_not_equal, :less_than, :less_than_or_equal_to, :greater_than, :ends_with, :like, :begins_with, :empty, :null]
+    CONDITIONS = [:COMPARISON_CONDITIONS, :WILDCARD_CONDITIONS, :BOOLEAN_CONDITIONS].inject([]){|r, c| r + Searchlogic::NamedScopes::Conditions.const_get(c).keys}
+    
+    def default_config
+      super.merge({
+        :data_class_name => @passed_config[:search_class_name]
+      })
+    end
+    
+    def default_columns
+      res = super
+
+      res.map! do |f| 
+        norm_column = normalize_column(f)
+        norm_column.merge!({
+          :condition => "equals"
+        })
+        norm_column.merge!(:hidden => true) if norm_column[:name].to_s.index("__")
+        
+        norm_column
+      end
+      
+      res
+    end
+    
+    # columns to be displayed by the FieldConfigurator (which is GridPanel-based)
+    def self.config_columns
+      [
+        {:name => :hidden, :type => :boolean, :editor => :checkbox, :width => 50},
+        {:name => :name, :type => :string, :editor => :combobox},
+        {:name => :condition, :type => :string, :editor => {:xtype => :combobox, :options => CONDITIONS}},
+        {:name => :field_label, :type => :string},
+        {:name => :xtype, :type => :string},
+        {:name => :value, :type => :string},
+      ]
+    end
+
+    # tweaking the form fields at the last moment
+    def js_config
+      super.merge({
+        :clmns => columns.map{ |c| c.merge({
+          :field_label => "#{c[:field_label] || c[:name]} #{c[:condition]}".humanize,
+          :name => "#{c[:name]}_#{c[:condition]}"
+        })}
+      })
+    end
+    
+    # we need to correct the queries to cut off the condition suffixes, otherwise the FormPanel gets confused
+    def get_combobox_options(params)
+      column_name = params[:column]
+      CONDITIONS.each { |c| column_name.sub!(/_#{c}$/, "") }
+      super(:column => column_name)
+    end
+    
+  end
+end

data/lib/netzke/tab_panel.rb

@@ -0,0 +1,160 @@
+module Netzke
+  # TabPanel
+  # 
+  # Features:
+  # * Dynamically loads widgets for the tabs that get activated for the first time
+  # * Is loaded along with the active widget - saves a request to the server
+  # * Provides the method markTabsOutdated to mark all inactive tabs as 'outdated', and calls "update" method on widgets in tabs when they get activated
+  #
+  # TODO:
+  # * Stores the last active tab in persistent_config
+  # * Introduce a second or two delay before informing the server about a tab switched
+  # 
+  class TabPanel < Base
+    api :api_activate_tab
+    
+    def self.js_base_class
+      "Ext.TabPanel"
+    end
+
+    def self.js_extend_properties
+      {
+        :id_delimiter => "___", # the default was "__", which conflicts with Netzke's double underscore notation
+        :defaults => {:layout => 'fit'}, # all tabs will be Ext.Panel-s with layout 'fit' ("fit-panels")
+        
+        :init_component => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            Ext.netzke.cache.#{short_widget_class_name}.superclass.initComponent.call(this);
+            
+            this.on('tabchange', function(self, tab){this.loadItemWidget(tab)}, this);
+          }
+        END_OF_JAVASCRIPT
+        
+        :mark_tabs_outdated => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            this.items.each(function(i){
+              if (this.getActiveTab() != i){
+                i.outdated = true
+              }
+            }, this);
+          }
+        END_OF_JAVASCRIPT
+        
+        # bulkExecute in active tab
+        :execute_in_active_tab => <<-END_OF_JAVASCRIPT.l,
+          function(commands){
+            this.getActiveTab().getWidget().bulkExecute(commands);
+          }
+        END_OF_JAVASCRIPT
+        
+        :get_loaded_children => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            var res = [];
+            this.items.each(function(tab){
+              var kid = tab.getWidget();
+              if (kid) { res.push(kid) }
+            }, this);
+            return res;
+          }
+        END_OF_JAVASCRIPT
+        
+        # loads widget into the panel if it wasn't loaded yet
+        :load_item_widget => <<-END_OF_JAVASCRIPT.l
+          function(panel) {
+            if (!panel.getWidget()) {
+              if (preloadedItemConfig = this.initialConfig[panel.widget.camelize()+"Config"]){
+                // preloaded widget only needs to be instantiated, as its class and configuration have already been loaded
+                panel.add(new Ext.netzke.cache[preloadedItemConfig.widgetClassName](preloadedItemConfig));
+                panel.doLayout(); // always needed after adding a component
+              } else {
+                // load the widget from the server
+                this.loadAggregatee({id:panel.widget, container:panel.id});
+              }
+            }
+            
+            // inform the server about active tab changed
+            this.apiActivateTab({tab:panel.widget});
+            
+            // call "update" on the widget
+            if (panel.outdated) {
+              delete panel.outdated;
+              var widget = panel.getWidget();
+              if (widget && widget.update) {widget.update.call(widget)};
+            }
+          }
+        END_OF_JAVASCRIPT
+      }
+    end
+    
+    def items
+      @items ||= config[:items]
+    end
+
+    def js_config
+      super.merge({
+        :items => fit_panels,
+        :active_tab => id_name + '_active' # id of the fit panel that is active
+      })
+    end
+
+    # some configuration normalization
+    def initialize(*args)
+      super
+      
+      # to remove duplicated active tabs
+      first_active = nil
+
+      items.each_with_index do |item, i|
+        # if the item is provided without a name, give it a generated name
+        item[:name] ||= "item#{i}"
+
+        # remove duplicated "active" configuration
+        if item[:active]
+          if first_active.nil?
+            first_active = item.name
+          else
+            item[:active] = nil
+          end
+        end
+      end
+      
+      # the first tab is forced to become active, if none was configured as active
+      items.first[:active] = true and first_active = items.first.name if first_active.nil?
+      
+      widget_session[:active_tab] = first_active
+    end
+    
+    # the items are late aggregatees, besides the one that is configured active
+    def initial_aggregatees
+      res = {}
+      items.each_with_index do |item, i|
+        item[:late_aggregation] = !item[:active] && !item[:preloaded]
+        res.merge!(item[:name].to_sym => item)
+      end
+      res
+    end
+
+    # "Fit panels" - Panels with layout 'fit' that serve as containers for (dynamically) loaded widgets
+    def fit_panels
+      res = []
+      items.each_with_index do |item, i|
+        item_config = {
+          :id => item[:active] && id_name + '_active',
+          :title => item[:title] || (item[:name] && item[:name].humanize),
+          :widget => item[:name] # to know which fit-panel will load which widget
+        }
+        res << item_config
+      end
+      res
+    end
+    
+    def api_activate_tab(params)
+      widget_session[:active_tab] = params[:tab]
+      {}
+    end
+    
+    def get_active_tab
+      aggregatee_instance(widget_session[:active_tab])
+    end
+  end
+end