westarete-skylinecms 3.0.8.20100329

data/app/helpers/skyline/editors/editor.rb

@@ -0,0 +1,107 @@
+module Skyline::Editors
+  class Editor
+  
+    class << self
+      def create(field,name_chain,record,template)
+        if field.editor 
+          c = "Skyline::Editors::#{field.editor.to_s.classify}".constantize
+          c.new(name_chain,record,field,template)
+        else
+          Skyline::Editors::TextField.new(name_chain,record,field,template)
+        end
+      rescue NameError => e
+        RAILS_DEFAULT_LOGGER.warn(" Editor instantiation error ".center(50,"="))
+        RAILS_DEFAULT_LOGGER.warn(e.to_s + "\n" + e.backtrace.join("\n"))
+        RAILS_DEFAULT_LOGGER.warn("=" * 50)      
+        Skyline::Editors::TextField.new(name_chain,record,field,template)
+      end
+    
+    end
+  
+    attr_reader :field_names, :attribute_names, :field,:record
+    def initialize(names,record,field,template)
+      @record,@field,@template = record,field,template
+      @field_names = (names.dup || []) << field.name
+      @attribute_names = (names.dup || []) << field.attribute_name
+    end
+  
+    def method_missing(method,*params)
+      @template.send(method,*params)
+    end
+  
+    # Should this editor be postponed until the form tag is closed?
+    def postpone?; false; end
+  
+    # Convert a hash to CSS style definition
+    #   {:height => 13, :width => "13px", :border_left => "1px solid red"}
+    #   "height: 13px; width: 13px; border-left: 1px solid red;"
+    def params_to_styles(opts)
+      return "" if opts.nil?
+      out = ""
+      opts.each do |k,v|
+        out << k.to_s.gsub("_","-") + ": "
+        out << (v.kind_of?(Numeric) ? "#{v}px" : v.to_s )
+        out << "; "
+      end
+      out
+    end
+  
+    def output
+      out = heading
+      if self.respond_to? :output_without_errors
+        out << field_with_errors([field_prefix,output_without_errors,field_suffix].join)
+      end
+      content_tag("div",out, :id  => "field_#{input_id(field_names)}", :class => "editor #{"invalid" if record.errors.on(field.attribute_name)}")
+    end
+  
+    def errors
+      errors = record.errors.on(field.attribute_name)
+      if errors.kind_of?(Array)
+        errors.flatten.to_sentence
+      else
+        errors
+      end
+    end
+  
+    def heading
+      out = content_tag("h3",content_tag("label",field.singular_title + " " + errors.to_s, :for => input_id(attribute_names)))
+      out << content_tag("p",field.description,:class => "description") unless field.description.blank?
+      out
+    end
+  
+    def field_with_errors(content)
+      if self.record.errors.on(self.field.attribute_name) 
+        content_tag("div", content, :class => "fieldWithErrors")
+      else
+        content
+      end
+    end      
+  
+    def field_prefix
+      value = field_text(field.prefix)
+      @template.content_tag("span",value, :class => "prefix") if value.any?
+    end
+  
+    def field_suffix
+      value = field_text(field.suffix)    
+      @template.content_tag("span",value, :class => "suffix") if value.any?
+    end
+  
+    def field_text(att)
+      case att
+        when Proc : perform_proc(att)
+        else att.to_s
+      end
+    end
+  
+    def perform_proc(proc)
+      case proc.arity
+        when 1 : proc.call(record)
+        when -1,0 : proc.call()
+        else
+          []
+      end
+    end      
+  
+  end
+end

data/app/helpers/skyline/editors/file_browser.rb

@@ -0,0 +1,54 @@
+class Skyline::Editors::FileBrowser < Skyline::Editors::Editor
+  def output_without_errors
+    attr_names = self.attribute_names.dup
+    attr_names[-1] = attr_names[-1].to_s.gsub(/_id$/, "_attributes")
+    input_name_prefix = input_name(attr_names)                    # ie: element[image_attributes]
+    input_id_prefix = input_id(attr_names)                        # ie: element_image_attributes
+    
+    association = field.name.to_s.gsub(/_id$/, "")                # ie: image
+    location = nil    
+    if record.respond_to?(association)
+      location = :model
+      media_file = record.send(association)
+      media_file ||= record.send("build_#{association}")
+      media_file_name = media_file.referable_id.blank? ? "" : media_file.name
+      linked = !media_file.referable_type.blank?
+      referable_type = media_file.referable_type
+      referable_id = media_file.referable_id
+    else
+      location = :settings
+      media_file = Skyline::MediaFile.find_by_id(field.value(record))
+      media_file_name = media_file.name if media_file
+      linked = media_file.present?
+      referable_type = media_file ? "Skyline::MediaFile" : ""
+      referable_id = media_file ? media_file.id : ""
+    end
+    
+    <<-EOF
+      <div id="#{input_id_prefix}" class="#{!media_file.blank? && media_file.file_type}">
+        #{hidden_field_tag(input_name(attr_names+['id']), media_file.id) if location == :model}
+        #{hidden_field_tag(input_name(attr_names+['_destroy']), 0, :class => 'delete')}
+        #{hidden_field_tag(input_name(attr_names+['referable_type']), referable_type, :class => 'referable_type')}
+        #{hidden_field_tag(input_name(attr_names+['referable_id']), referable_id, :class => 'referable_id')}
+        
+        <div class="content-browser">
+          <div class="relatesTo#{' linked' if linked}">
+            <div class="not-linked">
+              <div class="blank">
+                #{t(:nothing_selected, :scope => [:browser,:file])}
+                #{link_to_function button_text(:browse),  "Application.Browser.browseFileFor('#{input_id_prefix}');", :class => "browse button small"}            
+              </div>
+            </div>        
+
+            <div class="linked">
+              #{t(:links_to, :scope => [:browser,:file], :referable_title => "<span class=\"referable_title\">#{media_file_name}</span>")}
+              #{link_to_function button_text(:delete), "Application.Browser.unlink('#{input_id_prefix}');", :class => "delete button small red"}
+              #{link_to_function button_text(:browse),  "Application.Browser.browseFileFor('#{input_id_prefix}');", :class => "browse button small"}
+            </div>
+          </div>
+        </div>
+      </div>
+EOF
+  end
+end    
+

data/app/helpers/skyline/editors/heading.rb

@@ -0,0 +1,13 @@
+class Skyline::Editors::Heading < Skyline::Editors::Editor
+  def output_without_errors
+    text_field_tag(
+      input_name(self.attribute_names), 
+      field.value(record),
+      :size => 40,
+      :class => "heading",
+      :style => params_to_styles(field.style),
+      :id => input_id(self.attribute_names)
+    )
+  end
+  
+end

data/app/helpers/skyline/editors/inline_list.rb

@@ -0,0 +1,9 @@
+class Skyline::Editors::InlineList < Skyline::Editors::Editor
+  def postpone?; true; end
+        
+  def output
+    klass = field.reflection.klass
+    add_link = render(:partial => "add", :locals => {:klass => klass, :record => record, :field => field, :return_to => url_for({})})
+    heading + add_link + Presenters::Presenter.create(field.presenter,field.value(record),klass,@template, :collection => field.attribute_name).output()
+  end
+end

data/app/helpers/skyline/editors/joinable_list.rb

@@ -0,0 +1,118 @@
+class Skyline::Editors::JoinableList < Skyline::Editors::Editor
+  
+  attr_reader :target_class,:proxy_class, :reflection
+  
+  def initialize(names,record,field,template)
+    super
+    RAILS_DEFAULT_LOGGER.debug("@attribute => #{@attribute_names.inspect}")
+
+    @reflection = self.field.reflection
+    if @reflection.macro == :has_many
+      raise "JoinableList can only be used with HABTM and has_many :through associations" unless @reflection.through_reflection
+      @target_class = reflection.klass
+      @proxy_class = @reflection.through_reflection.klass
+    elsif @reflection.macro == :has_and_belongs_to_many
+      @target_class = @reflection.klass
+      @proxy_class = nil
+    else
+      raise "JoinableList can only be used with HABTM and has_many :through associations (was: #{@reflection.macro})"
+    end
+  end
+  
+  def output_without_errors
+    out = ""
+    out << content_tag("ul",self.rows.join("\n"),:class => "joinable-list #{"orderable" if self.orderable?}", :id => js_object_name)
+    out << browse_window
+    out << hidden_field_tag(input_name(self.attribute_names + ["_order"]),records.map(&:id).join(","),:id => input_id(self.attribute_names + ["order"])) if(self.orderable?)
+#    out << javascript_tag("var #{js_object_name} = new JoinableList('#{js_object_name}','#{input_id(self.attribute_names + ["order"])}')")
+    out
+  end      
+  
+  def orderable?
+    @proxy_class && @proxy_class.respond_to?(:orderable?) && @proxy_class.orderable?
+  end
+    
+  def render_row(row,proxy_id = nil)
+    proxy_id ||= proxy_id(row)
+    edit = hidden_field_tag(input_name(self.attribute_names + [proxy_id,"_target_id"]),target_id(row),:id => input_id(self.attribute_names + [proxy_id,"_target_id"]))
+    edit << delete_button(proxy_id)
+    
+    out = ""
+    out << "<span class=\"drag\">&nbsp;</span>" if self.orderable?        
+    out << content_tag("div",edit,:class => "edit")
+    out << "<div class=\"draggable\">"
+    out << content_tag("div","<h3>#{title_for(row)}</h3>", :class => "content")
+    out << content_tag("div","",:class => "clear")
+    fields = content_fields(row.class,(self.attribute_names + [proxy_id]),row)
+    out << content_tag("div",fields) unless fields.blank?
+    out << "</div>"    
+    content_tag("li",out,:id => row_id(proxy_id),:class => "#{cycle("odd","even")} element")
+  end  
+  
+  def proxy_id(row)
+    if @proxy_class
+      row.new_record? ? random_prefix(row) : row.id
+    else
+      random_prefix(row)
+    end
+  end
+  
+  def random_prefix(row)
+    "n_" + row.id.to_s + "_n" + Time.now.to_i.to_s + Time.now.usec.to_s 
+  end
+  
+  def js_object_name
+    "joinable_list_#{input_id(self.attribute_names)}"
+  end  
+  
+  protected
+  
+  def target_id(row)
+    if @proxy_class
+      row.send(self.reflection.source_reflection.name).id
+    else
+      row.id
+    end
+  end
+  
+  def rows
+    records.collect{|row| render_row(row)}
+  end  
+  
+  def browse_window
+    out = render(:partial => "skyline/content/editors/joinable_list/add", :locals => {:source_object => record, :association => field.name, :target_class => target_class})
+    content_tag("div",out, :id => input_id(self.attribute_names,"browser"), :class => "browser-window")    
+  end
+  
+  def records
+    if @proxy_class
+      @records ||= record.send(self.reflection.through_reflection.name).find(:all,:include => self.reflection.source_reflection.name)
+    else
+      @records ||= record.send(field.name)
+    end
+  end
+
+  
+  def delete_button(row_id)
+    link_to_function image_tag("buttons/delete.gif", :alt => "remove"), 
+                   "#{js_object_name}.remove('#{row_id(row_id)}');"
+  end
+  
+  def row_id(id)
+    input_id(self.attribute_names) + "_#{id}"
+  end
+  
+  def assoc_class
+    field.reflection.klass
+  end
+  
+  def title_for(record)
+    raise "Must have title_field defined in settings for #{target_class}" unless tf = target_class.settings.title_field
+    raise "Title field #{tf} is not defined as field for #{target_class}" unless f = target_class.fields[tf]
+    if @proxy_class
+      f.value(record.send(self.reflection.source_reflection.name))
+    else
+      f.value(record)
+    end
+  end
+end

data/app/helpers/skyline/editors/list.rb

@@ -0,0 +1,15 @@
+class Skyline::Editors::List < Skyline::Editors::Editor
+  def output_without_errors
+    select_tag(input_name(self.attribute_names),option_tags)       
+  end
+  
+  private
+  def option_tags
+    list = case field.list
+      when Array, Hash : field.list
+      when Proc : perform_proc(field.list)
+    end
+    options_for_select(list,field.attribute_value(self.record))
+  end
+    
+end

data/app/helpers/skyline/editors/page_browser.rb

@@ -0,0 +1,54 @@
+class Skyline::Editors::PageBrowser < Skyline::Editors::Editor
+  def output_without_errors
+    attr_names = self.attribute_names.dup
+    attr_names[-1] = attr_names[-1].to_s.gsub(/_id$/, "_attributes")
+    input_name_prefix = input_name(attr_names)                    # ie: element[image_attributes]
+    input_id_prefix = input_id(attr_names)                        # ie: element_image_attributes
+    
+    association = field.name.to_s.gsub(/_id$/, "")                # ie: image
+    location = nil
+    if record.respond_to?(association)
+      location = :model
+      page = record.send(association)
+      page ||= record.send("build_#{association}")
+      page_title = page.referable_type.blank? ? "" : page.andand.default_variant.andand.data.andand.navigation_title
+      linked = !page.referable_type.blank?
+      referable_type = page.referable_type
+      referable_id = page.referable_id
+    else
+      location = :settings
+      page = Skyline::Page.find_by_id(field.value(record))
+      page_title = page.andand.default_variant.andand.data.andand.navigation_title
+      linked = page.present?
+      referable_type = page ? "Skyline::Page" : ""
+      referable_id = page ? page.id : ""
+    end
+    
+    <<-EOF
+      <div id="#{input_id_prefix}">
+        #{hidden_field_tag(input_name(attr_names+['id']), page.id) if location == :model}
+        #{hidden_field_tag(input_name(attr_names+['_destroy']), 0, :class => 'delete')}
+        #{hidden_field_tag(input_name(attr_names+['referable_type']), referable_type, :class => 'referable_type')}
+        #{hidden_field_tag(input_name(attr_names+['referable_id']), referable_id, :class => 'referable_id')}
+
+        <div class="content-browser">
+          <div class="relatesTo#{' linked' if linked}">
+
+            <div class="not-linked">
+              <div class="blank">
+                #{t(:nothing_selected, :scope => [:browser,:page])}
+                #{link_to_function button_text(:browse),  "Application.Browser.browsePageFor('#{input_id_prefix}');", :class => "browse button small"}
+              </div>
+            </div>        
+
+            <div class="linked">
+              #{t(:links_to, :scope => [:browser,:page], :referable_title => "<span class=\"referable_title\">#{page_title}</span>")}
+              #{link_to_function(button_text(:delete), "Application.Browser.unlink('#{input_id_prefix}');", :class => "delete button small red")}
+              #{link_to_function button_text(:browse),  "Application.Browser.browsePageFor('#{input_id_prefix}');", :class => "browse button small"}
+            </div>
+          </div>
+        </div>
+      </div>
+EOF
+  end
+end    

data/app/helpers/skyline/editors/text_field.rb

@@ -0,0 +1,12 @@
+class Skyline::Editors::TextField < Skyline::Editors::Editor
+  def output_without_errors
+   text_field_tag(
+     input_name(self.attribute_names), 
+     field.value(record),
+     :size => 40,
+     :id => input_id(self.attribute_names),
+     :style => params_to_styles(field.style),
+     :class => "full"
+   )
+  end
+end    

data/app/helpers/skyline/editors/textarea.rb

@@ -0,0 +1,11 @@
+class Skyline::Editors::Textarea < Skyline::Editors::Editor
+   def output_without_errors
+     text_area_tag(
+       input_name(self.attribute_names), 
+       field.value(record), 
+       :rows => 8,:cols => 50,
+       :id => input_id(self.attribute_names),
+       :style => params_to_styles(field.style)       
+     )
+   end
+ end

data/app/helpers/skyline/editors/textile.rb

@@ -0,0 +1,12 @@
+class Skyline::Editors::Textile < Skyline::Editors::Editor
+  def output_without_errors
+    text_area_tag(
+      input_name(self.attribute_names), 
+      field.value(record), 
+      :rows => 8,
+      :cols => 50, 
+      :class => "textile",
+      :style => params_to_styles(field.style)
+    ) + content_tag("div", "You can use textile syntax to format your text. See <a href=\"http://hobix.com/textile/\" target=\"_blank\">the syntax rules for help</a>.")
+  end      
+end

data/app/helpers/skyline/editors/wysiwyg.rb

@@ -0,0 +1,28 @@
+class Skyline::Editors::Wysiwyg < Skyline::Editors::Editor
+  def output_without_errors
+    out = content_tag("div",text_area_tag(
+      input_name(self.attribute_names), 
+      record.send(field.name,true), 
+      :class => "wysiwyg", 
+      :rows => 15,
+      :cols => 90,
+      :id => self.tag_id,
+      :style => params_to_styles(field.style)
+    ), :class => "section")
+    out << self.tinymce_js
+  end
+  
+  def tag_id
+    "wysiwyg" + self.attribute_names.join("_")
+  end
+  
+  def tinymce_js
+    javascript_tag "new Skyline.Editor('#{self.tag_id}',{
+      contentCss : '/skyline/stylesheets/wysiwyg.css',
+      #{"enableEditHtml : true," if current_user.allow?("tinymce_edit_html")}
+      language : Application.locale    
+    })"
+  end
+  
+
+end

data/app/helpers/skyline/media_files_helper.rb

@@ -0,0 +1,7 @@
+# @private
+module Skyline::MediaFilesHelper
+  def skyline_media_file_path_with_session_information(media_dir)
+    session_key = ActionController::Base.session_options[:session_key] || ActionController::Base.session_options[:key]
+    skyline_media_dir_media_files_path(media_dir, session_key => cookies[session_key], request_forgery_protection_token => form_authenticity_token)
+  end
+end

data/app/helpers/skyline/message_generator.rb

@@ -0,0 +1,25 @@
+# @private
+class Skyline::MessageGenerator
+  include ActionView::Helpers::JavaScriptHelper
+  
+  def initialize(type,message,options={})
+    (@options = options || {}).update(:type => "'#{escape_javascript(type.to_s)}'")
+    @message = message
+  end
+  
+  def to_s
+    options = @options.dup
+    options.each do |k,v|
+      options[k] = case v
+        when Hash : self.options_for_javascript(v)
+        else v
+      end
+    end    
+    "new Application.Message('#{self.escape_javascript(@message)}',#{self.options_for_javascript(options)})"
+  end
+  
+  def to_str
+    to_s
+  end
+  
+end

data/app/helpers/skyline/pages_helper.rb

@@ -0,0 +1,44 @@
+module Skyline::PagesHelper  
+  
+  # Renders a label and selectbox for the sectionable_type passed in, it doesn't render
+  # anything if there is only one template.
+  #
+  # ==== Parameters
+  # st<String,Symbol> :: The sectionable type
+  # form<FormBuidler> :: The formbuilder to place this select in.
+  # options<Hash>     :: See options
+  #
+  # ==== Options
+  # :label<String,false> :: Use another label or false for no label
+  #
+  # ==== Returns
+  # String :: The label and the selectbox
+  # nil :: Nil if there is nothing to render
+  # --
+  def renderable_templates_select(object, form, options = {})
+    raise "@renderable_scope not available" unless @renderable_scope
+    
+    return nil if @renderable_scope.templates_for(object).size <= 1
+    
+    options.reverse_merge! :label => Skyline::Section.human_attribute_name("template")
+    
+    out = []
+    if options[:label]
+      out << form.label(:template, options[:label]) 
+      out << ": "
+    end
+    out << form.select(:template, templates_for_select(object) )
+    out.join
+  end
+  
+  def templates_for_select(object)
+    raise "@renderable_scope not available" unless @renderable_scope
+    
+    scope = [:templates]
+    scope += object.class.name.sub(/^Skyline::/,"").underscore.split("/").map(&:to_sym)
+    templates = @renderable_scope.templates_for(object).dup
+    templates = (["default"] + templates) if templates.delete("default")
+    templates.map {|tmpl| [t(tmpl,:scope => scope, :default => tmpl),tmpl]  }
+  end
+  
+end

data/app/helpers/skyline/presenters/article_list.rb

@@ -0,0 +1,139 @@
+class Skyline::Presenters::ArticleList < Skyline::Presenters::Presenter
+    
+  def output
+    ["<div id=\"list-wrapper\"><ul class=\"article-list #{"orderable" if self.fieldset.orderable?}\" id=\"list\">",header,body,"</ul>",footer,"</div>"].join("\n")
+  end
+  
+  def body
+    if self.collection.any?
+      self.collection.map{|el| self.row(el) }
+    else
+      "<li class=\"blank-slate\">#{t(:blank_slate, :scope => [:content,:list], :class =>  self.fieldset.plural_name.downcase)} " +
+      link_to(t(:add_a_new, :scope => [:content], :class => self.fieldset.singular_name.downcase),:action => "create", :types => stack.url_types, :return_to => url_for({})) +
+      "</li>"
+    end
+  end
+  
+  def footer
+    if fieldset.orderable? && self.collection.any?
+      <<-EOS
+        <script type="text/javascript" charset="utf-8">
+          var s = new Skyline.Sortable("list",{handle: "span.drag", clone: true, revert: true, draggables: "li.element"});
+          s.addEvent("afterDrop", function(){
+            #{
+              remote_function(
+                :url => {:action => "order", :types => stack.url_types},
+                :data => "'order=' + Application.getSequence('#list li.element').join(',')"
+              )            
+            }
+          });
+        </script>
+      EOS
+    else
+      ""
+    end
+  end
+  
+  
+  #   <li class="header">
+  #   <div class="draggable">
+  #     <ul class="meta">
+  #       <li style="width: 50%">Sub-pagina's</li>  
+  #       <li style="width: 50%">Publicatiedatum</li>
+  #     </ul>
+  #   </div>
+  # </li>
+  def header
+    out = "<li class=\"header\">"
+    out << "<div class=\"edit\">&nbsp;</div>"    
+    out << "<div class=\"draggable\">"
+    out << "<div class=\"content\">&nbsp;</div>"
+    out << "<ul class=\"meta\">"
+    self.heading_collection.each do |field|
+      out << "<li style=\"width: #{self.heading_size}\">#{field.singular_label}</li>"      
+    end
+    out << "</ul>"    
+    out << "</div><div class=\"clear\">&nbsp;</div>"
+    out << "</li>"
+    if self.options[:navigation] && stack.has_parent?
+      out << "<li class=\"up\">"+link_to(t(:up_one_level, :scope => [:content,:list]), :action => "list", :types => stack.url_types(:up => 1,:collection => true))+"</li>"
+    end
+    out
+  end  
+    
+  # <li class="even">
+  #   <span class="drag" ></span> 
+  #   <div class="edit">
+  #     <a href="#"><img src="/images/buttons/edit.gif?1197741337" alt="Edit"/></a>       
+  #     <a href="#"><img src="/images/buttons/delete.gif?1197741337" alt="Edit"/></a>               
+  #   </div>
+  #   <div class="draggable">
+  #     <div class="content">
+  #       <h3>Titel van dit artikel</h3>
+  #       <p>Some sub info.....</p>
+  #     </div>
+  #     <ul class="meta">
+  #       <li style="width: 50%">7 items (view)</li>
+  #       <li style="width: 50%">Publicatiedatum</li>
+  #     </ul>
+  #   </div>
+  # </li>  
+  def row(record)
+    return if record.new_record? # there can't be any new records in a list!
+    out = ""
+    out << "<span class=\"drag\">&nbsp;</span>" if fieldset.orderable?
+    out << content_tag("div",edit_button(record) + " " + delete_button(record),:class => "edit")
+    out << "<div class=\"draggable\">"
+    out << content(record)
+    out << meta(record)
+    out << "</div><div class=\"clear\">&nbsp;</div>"
+    content_tag("li",out,:class => cycle("odd","even") + " element", :id => "element_#{record.id}")
+  end
+  
+  def content(record)
+    out = "<div class=\"content\">"
+    title,opts = value(record,title_field)
+    out << "<h3>#{title}</h3>"
+    if subtitle_field
+      subtitle,opts = value(record,subtitle_field)
+      out << "<p>#{subtitle}</p>"
+    end
+    out << "</div>"    
+  end
+  
+  def meta(record)
+    out = "<ul class=\"meta\">"
+    self.heading_collection.each do |field|
+      v,rest = value(record,field)
+      out << "<li style=\"width: #{self.heading_size}\">#{v.blank? ? "&nbsp;" : v}</li>"
+    end
+    out << "</ul>"
+  end
+  
+  def heading_collection(fieldset=self.fieldset,cache=true)
+    return @heading_collection if @heading_collection && cache
+    @heading_collection = super.find_all{|f| ![self.title_field,self.subtitle_field].include?(f) }    
+  end
+  
+  # We have to use 99% as to fool IE
+  def heading_size
+    @heading_size ||= "#{(99 / self.heading_collection.size.to_f).to_i}%"
+  end
+  
+  # @deprecated: the use of title_column
+  def title_field
+    self.fieldset.fields[self.fieldset.settings.title_field || self.fieldset.settings.title_column || first_non_hidden_field]
+  end
+
+  # @deprecated: the use of subtitle_column
+  def subtitle_field
+    self.fieldset.settings.subtitle_field && self.fieldset.fields[self.fieldset.settings.subtitle_field] ||
+    self.fieldset.settings.subtitle_column && self.fieldset.fields[self.fieldset.settings.subtitle_column] || 
+    nil
+  end
+  
+  def first_non_hidden_field
+    self.fieldset.field_names.find{|f| self.fieldset.fields.has_key?(f) && !self.fieldset.fields[f].hidden_in(:list) }
+  end
+  
+end