netzke-basepack 0.5.14 → 0.6.0

data/lib/netzke/property_editor/helper_model.rb

@@ -1,122 +0,0 @@
-module Netzke
-  class PropertyEditor < FormPanel
-    class HelperModel
-      def self.widget=(w)
-        @@widget = w
-      end
-      
-      def self.widget
-        @@widget ||= raise RuntimeError, "No widget specified for PropertyEditor::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, widget = nil)
-        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.global_id)
-        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)
-        method_name = method_name.to_s
-        method_name_without_equal_sign = method_name.sub(/=$/, '')
-        NetzkePreference.widget_name = self.class.widget.global_id
-
-        if method_name =~ /=$/
-          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
-          
-          initial_value = self.class.widget.flat_initial_config(method_name_without_equal_sign)
-      
-          new_value = nil if new_value == initial_value
-          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

@@ -1,199 +0,0 @@
-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({
-        :model => @passed_config[:search_class_name]
-      })
-    end
-    
-    def independent_config
-      super.deep_merge(
-        :ext_config => {
-          :tbar => ["Presets:", 
-            {
-              :xtype => "combo", 
-              :fieldLabel => "Presets",
-              :triggerAction => "all",
-              :store => (persistent_config[:saved_searches] || []).map{ |s| s["name"] },
-              :id => "presets-combo",
-              :listeners => {:before_select => {
-                :fn => "function(combo, record){Ext.getCmp('#{global_id}').selectPreset(record.data.field1);}".l
-              }}
-            }, :save, :del]
-        }
-      )
-    end
-    
-    def actions
-      super.merge(
-        :save => {:text => "Save", :icon => Netzke::Base.config[:with_icons] && (Netzke::Base.config[:icons_uri] + "disk.png")},
-        :del => {:text => "Delete", :icon => Netzke::Base.config[:with_icons] && (Netzke::Base.config[:icons_uri] + "delete.png")}
-      )
-    end
-    
-    def self.js_extend_properties
-      {
-        :remove_search_from_list => <<-END_OF_JAVASCRIPT.l,
-          function(name){
-            var presetsCombo = Ext.getCmp("presets-combo");
-            var presetsComboStore = presetsCombo.getStore();
-            presetsComboStore.removeAt(presetsComboStore.find('field1', name));
-            presetsCombo.reset();
-            this.getForm().reset();
-          }
-        END_OF_JAVASCRIPT
-        
-        :set_values => <<-END_OF_JAVASCRIPT.l,
-          function(values){
-            this.getForm().setValues(Ext.decode(values));
-          }
-        END_OF_JAVASCRIPT
-        
-        :select_preset => <<-END_OF_JAVASCRIPT.l,
-          function(name){
-            this.getForm().reset();
-            this.loadSearch({name: name});
-          }
-        END_OF_JAVASCRIPT
-        
-        :on_save => <<-END_OF_JAVASCRIPT.l,
-          function(){
-            var searchName = Ext.getCmp("presets-combo").getValue();
-            if (searchName !== "") {
-              var presetsComboStore = Ext.getCmp("presets-combo").getStore();
-              if (presetsComboStore.find('field1', searchName) !== -1) {
-                Ext.Msg.confirm("Overwriting preset '" + searchName + "'", "Are you sure you want to overwrite this preset?", function(btn, text){
-                  if (btn == 'yes') {
-                     this.doSavePreset(searchName);
-                  }
-                }, this);
-              } else {
-                this.doSavePreset(searchName);
-                presetsComboStore.add(new presetsComboStore.recordType({field1: searchName}));
-              }
-            }
-          }
-        END_OF_JAVASCRIPT
-        
-        :do_save_preset => <<-END_OF_JAVASCRIPT.l,
-          function(name){
-            var values = this.getForm().getValues();
-            for (var k in values) {
-              if (values[k] == "") {delete values[k]}
-            }
-          
-            this.saveSearch({
-              name: name,
-              values: Ext.encode(values)
-            });
-          }
-        END_OF_JAVASCRIPT
-        
-        :on_del => <<-END_OF_JAVASCRIPT.l,
-          function(){
-            var searchName = Ext.getCmp("presets-combo").getValue();
-            if (searchName !== "") {
-              Ext.Msg.confirm("Deleting preset '" + searchName + "'", "Are you sure you want to delete this preset?", function(btn, text){
-                if (btn == 'yes') {
-                  this.deleteSearch({
-                    name: searchName
-                  });
-                }
-              }, this);
-            }
-          }
-        END_OF_JAVASCRIPT
-        
-      }
-    end
-    
-    api :save_search
-    def save_search(params)
-      saved_searches = persistent_config[:saved_searches] || []
-      existing = saved_searches.detect{ |s| s["name"] == params[:name] }
-      values = ActiveSupport::JSON.decode(params[:values])
-      if existing
-        existing["values"].replace(values)
-      else
-        saved_searches << {"name" => params[:name], "values" => values}
-      end
-      persistent_config[:saved_searches] = saved_searches
-      {:feedback => "Preset successfully saved"}
-    end
-    
-    api :delete_search
-    def delete_search(params)
-      saved_searches = persistent_config[:saved_searches]
-      saved_searches.delete_if{ |s| s["name"] == params[:name] }
-      {:feedback => "Preset successfully deleted", :remove_search_from_list => params[:name]}
-    end
-    
-    api :load_search
-    def load_search(params)
-      saved_searches = persistent_config[:saved_searches]
-      the_search = saved_searches.detect{ |s| s["name"] == params[:name] }
-      
-      {:set_values => the_search["values"].to_json}
-    end
-    
-    def initial_fields(only_included = true)
-      res = super
-
-      res.reject!{ |f| f[:virtual] }
-      
-      res.each do |f|
-        f.merge!(:condition => "like", :default_value => nil)
-        f.merge!(:xtype => xtype_for_attr_type(:string), :attr_type => "string") if f[:name].to_s.index("__")
-        f.merge!(:condition => "greater_than") if [:datetime, :integer, :date].include?(f[:attr_type])
-        f.merge!(:condition => "equals") if f[:attr_type] == :boolean
-      end
-
-      res
-    end
-    
-    # columns to be displayed by the FieldConfigurator (which is GridPanel-based)
-    def self.meta_columns
-      [                                         
-        {:name => "hidden",      :attr_type => :boolean, :editor => :checkbox, :width => 50},
-        {:name => "name",        :attr_type => :string,  :editor => :combobox},
-        {:name => "condition",   :attr_type => :string,  :editor => {:xtype => :combo, :store => CONDITIONS}},
-        {:name => "field_label", :attr_type => :string},
-        {:name => "xtype",       :attr_type => :string},
-        {:name => "value",       :attr_type => :string},
-      ]
-    end
-
-    # tweaking the form fields at the last moment
-    def js_config
-      super.merge({
-        :fields => fields.map{ |c| c.merge({
-          :label => "#{c[:label] || c[:name]} #{c[:condition]}".humanize,
-          :name => "#{c[:name]}_#{c[:condition]}"
-        })}
-      })
-    end
-    
-    private
-      # 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
-      
-      def attr_type_to_xtype_map
-        super.merge({
-          :boolean => :tricheckbox
-        })
-      end
-    
-  end
-end

data/lib/netzke/tab_panel.rb

@@ -1,174 +0,0 @@
-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")
-        
-        :render => <<-END_OF_JAVASCRIPT.l,
-          function(el){
-            #{js_full_class_name}.superclass.render.call(this, el);
-            
-            // We do this all in +render+ because only at this moment the activeTab is actually activated
-            var activeTab = this.getActiveTab();
-            
-            // Insert (render) preloaded widgets into their respective tabs
-            this.items.each(function(fitPanel){
-              var preloadedItemConfig = this[fitPanel.widget.camelize(true)+"Config"];
-              if (preloadedItemConfig){
-                var klass = this.classifyScopedName(preloadedItemConfig.scopedClassName);
-                fitPanel.add(new klass(preloadedItemConfig));
-                fitPanel.doLayout();
-              }
-            }, this);
-            
-            // setting the tabchange event
-            this.on('tabchange', this.onTabChange, this);
-          }
-        END_OF_JAVASCRIPT
-        
-        # loads widget from the server
-        :load_widget_into => <<-END_OF_JAVASCRIPT.l,
-          function(fitPanel){
-            this.loadAggregatee({id:fitPanel.widget, container:fitPanel.id});
-          }
-        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
-        
-        :on_tab_change => <<-END_OF_JAVASCRIPT.l
-          function(self, tab) {
-            // load widget into the panel from the server if it's not there yet
-            if (!tab.getWidget()) {
-              this.loadWidgetInto(tab);
-            }
-            
-            // inform the server about active tab change
-            this.apiActivateTab({tab:tab.widget});
-            
-            // call "update" on the widget
-            if (tab.outdated) {
-              tab.outdated = false;
-              var widget = tab.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 => global_id + '_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] && global_id + '_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