jro_apps/redmine Commit - r9848:ff68fff80ed1

Adds a helper for preview links....

Jean-Philippe Lang -

r9848:ff68fff80ed1

parent child

Context file:

r9848:ff68fff80ed1

Collapse all files

app/helpers/application_helper.rb +8 0

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'forwardable'
             require 'cgi'
             module ApplicationHelper
               include Redmine::WikiFormatting::Macros::Definitions
               include Redmine::I18n
               include GravatarHelper::PublicMethods
               extend Forwardable
               def_delegators :wiki_helper, :wikitoolbar_for, :heads_for_wiki_formatter
               # Return true if user is authorized for controller/action, otherwise false
               def authorize_for(controller, action)
                 User.current.allowed_to?({:controller => controller, :action => action}, @project)
               end
               # Display a link if user is authorized
               #
               # @param [String] name Anchor text (passed to link_to)
               # @param [Hash] options Hash params. This will checked by authorize_for to see if the user is authorized
               # @param [optional, Hash] html_options Options passed to link_to
               # @param [optional, Hash] parameters_for_method_reference Extra parameters for link_to
               def link_to_if_authorized(name, options = {}, html_options = nil, *parameters_for_method_reference)
                 link_to(name, options, html_options, *parameters_for_method_reference) if authorize_for(options[:controller] || params[:controller], options[:action])
               end
               # Display a link to remote if user is authorized
               def link_to_remote_if_authorized(name, options = {}, html_options = nil)
                 url = options[:url] || {}
                 link_to_remote(name, options, html_options) if authorize_for(url[:controller] || params[:controller], url[:action])
               end
               # Displays a link to user's account page if active
               def link_to_user(user, options={})
                 if user.is_a?(User)
                   name = h(user.name(options[:format]))
                   if user.active?
                     link_to name, :controller => 'users', :action => 'show', :id => user
                   else
                     name
                   end
                 else
                   h(user.to_s)
                 end
               end
               # Displays a link to +issue+ with its subject.
               # Examples:
               #
               #   link_to_issue(issue)                        # => Defect #6: This is the subject
               #   link_to_issue(issue, :truncate => 6)        # => Defect #6: This i...
               #   link_to_issue(issue, :subject => false)     # => Defect #6
               #   link_to_issue(issue, :project => true)      # => Foo - Defect #6
               #
               def link_to_issue(issue, options={})
                 title = nil
                 subject = nil
                 if options[:subject] == false
                   title = truncate(issue.subject, :length => 60)
                 else
                   subject = issue.subject
                   if options[:truncate]
                     subject = truncate(subject, :length => options[:truncate])
                   end
                 end
                 s = link_to "#{h(issue.tracker)} ##{issue.id}", {:controller => "issues", :action => "show", :id => issue},
                                                              :class => issue.css_classes,
                                                              :title => title
                 s << h(": #{subject}") if subject
                 s = h("#{issue.project} - ") + s if options[:project]
                 s
               end
               # Generates a link to an attachment.
               # Options:
               # * :text - Link text (default to attachment filename)
               # * :download - Force download (default: false)
               def link_to_attachment(attachment, options={})
                 text = options.delete(:text) || attachment.filename
                 action = options.delete(:download) ? 'download' : 'show'
                 opt_only_path = {}
                 opt_only_path[:only_path] = (options[:only_path] == false ? false : true)
                 options.delete(:only_path)
                 link_to(h(text),
                        {:controller => 'attachments', :action => action,
                         :id => attachment, :filename => attachment.filename}.merge(opt_only_path),
                        options)
               end
               # Generates a link to a SCM revision
               # Options:
               # * :text - Link text (default to the formatted revision)
               def link_to_revision(revision, repository, options={})
                 if repository.is_a?(Project)
                   repository = repository.repository
                 end
                 text = options.delete(:text) || format_revision(revision)
                 rev = revision.respond_to?(:identifier) ? revision.identifier : revision
                 link_to(
                     h(text),
                     {:controller => 'repositories', :action => 'revision', :id => repository.project, :repository_id => repository.identifier_param, :rev => rev},
                     :title => l(:label_revision_id, format_revision(revision))
                   )
               end
               # Generates a link to a message
               def link_to_message(message, options={}, html_options = nil)
                 link_to(
                   h(truncate(message.subject, :length => 60)),
                   { :controller => 'messages', :action => 'show',
                     :board_id => message.board_id,
                     :id => (message.parent_id || message.id),
                     :r => (message.parent_id && message.id),
                     :anchor => (message.parent_id ? "message-#{message.id}" : nil)
                   }.merge(options),
                   html_options
                 )
               end
               # Generates a link to a project if active
               # Examples:
               #
               #   link_to_project(project)                          # => link to the specified project overview
               #   link_to_project(project, :action=>'settings')     # => link to project settings
               #   link_to_project(project, {:only_path => false}, :class => "project") # => 3rd arg adds html options
               #   link_to_project(project, {}, :class => "project") # => html options with default url (project overview)
               #
               def link_to_project(project, options={}, html_options = nil)
                 if project.archived?
                   h(project)
                 else
                   url = {:controller => 'projects', :action => 'show', :id => project}.merge(options)
                   link_to(h(project), url, html_options)
                 end
               end
               def thumbnail_tag(attachment)
                 link_to image_tag(url_for(:controller => 'attachments', :action => 'thumbnail', :id => attachment)),
                   {:controller => 'attachments', :action => 'show', :id => attachment, :filename => attachment.filename},
                   :title => attachment.filename
               end
               def toggle_link(name, id, options={})
                 onclick = "Element.toggle('#{id}'); "
                 onclick << (options[:focus] ? "Form.Element.focus('#{options[:focus]}'); " : "this.blur(); ")
                 onclick << "return false;"
                 link_to(name, "#", :onclick => onclick)
               end
               def image_to_function(name, function, html_options = {})
                 html_options.symbolize_keys!
                 tag(:input, html_options.merge({
                     :type => "image", :src => image_path(name),
                     :onclick => (html_options[:onclick] ? "#{html_options[:onclick]}; " : "") + "#{function};"
                     }))
               end
               def prompt_to_remote(name, text, param, url, html_options = {})
                 html_options[:onclick] = "promptToRemote('#{text}', '#{param}', '#{url_for(url)}'); return false;"
                 link_to name, {}, html_options
               end
               def format_activity_title(text)
                 h(truncate_single_line(text, :length => 100))
               end
               def format_activity_day(date)
                 date == User.current.today ? l(:label_today).titleize : format_date(date)
               end
               def format_activity_description(text)
                 h(truncate(text.to_s, :length => 120).gsub(%r{[\r\n]*<(pre|code)>.*$}m, '...')
                    ).gsub(/[\r\n]+/, "<br />").html_safe
               end
               def format_version_name(version)
                 if version.project == @project
                 	h(version)
                 else
                   h("#{version.project} - #{version}")
                 end
               end
               def due_date_distance_in_words(date)
                 if date
                   l((date < Date.today ? :label_roadmap_overdue : :label_roadmap_due_in), distance_of_date_in_words(Date.today, date))
                 end
               end
               def render_page_hierarchy(pages, node=nil, options={})
                 content = ''
                 if pages[node]
                   content << "<ul class=\"pages-hierarchy\">\n"
                   pages[node].each do |page|
                     content << "<li>"
                     content << link_to(h(page.pretty_title), {:controller => 'wiki', :action => 'show', :project_id => page.project, :id => page.title},
                                        :title => (options[:timestamp] && page.updated_on ? l(:label_updated_time, distance_of_time_in_words(Time.now, page.updated_on)) : nil))
                     content << "\n" + render_page_hierarchy(pages, page.id, options) if pages[page.id]
                     content << "</li>\n"
                   end
                   content << "</ul>\n"
                 end
                 content.html_safe
               end
               # Renders flash messages
               def render_flash_messages
                 s = ''
                 flash.each do |k,v|
                   s << content_tag('div', v.html_safe, :class => "flash #{k}", :id => "flash_#{k}")
                 end
                 s.html_safe
               end
               # Renders tabs and their content
               def render_tabs(tabs)
                 if tabs.any?
                   render :partial => 'common/tabs', :locals => {:tabs => tabs}
                 else
                   content_tag 'p', l(:label_no_data), :class => "nodata"
                 end
               end
               # Renders the project quick-jump box
               def render_project_jump_box
                 return unless User.current.logged?
                 projects = User.current.memberships.collect(&:project).compact.select(&:active?).uniq
                 if projects.any?
                   options =
                     ("<option value=''>#{ l(:label_jump_to_a_project) }</option>" +
                      '<option value="" disabled="disabled">---</option>').html_safe
                   options << project_tree_options_for_select(projects, :selected => @project) do |p|
                     { :value => project_path(:id => p, :jump => current_menu_item) }
                   end
                   select_tag('project_quick_jump_box', options, :onchange => 'if (this.value != \'\') { window.location = this.value; }')
                 end
               end
               def project_tree_options_for_select(projects, options = {})
                 s = ''
                 project_tree(projects) do |project, level|
                   name_prefix = (level > 0 ? '&nbsp;' * 2 * level + '&#187; ' : '').html_safe
                   tag_options = {:value => project.id}
                   if project == options[:selected] || (options[:selected].respond_to?(:include?) && options[:selected].include?(project))
                     tag_options[:selected] = 'selected'
                   else
                     tag_options[:selected] = nil
                   end
                   tag_options.merge!(yield(project)) if block_given?
                   s << content_tag('option', name_prefix + h(project), tag_options)
                 end
                 s.html_safe
               end
               # Yields the given block for each project with its level in the tree
               #
               # Wrapper for Project#project_tree
               def project_tree(projects, &block)
                 Project.project_tree(projects, &block)
               end
               def project_nested_ul(projects, &block)
                 s = ''
                 if projects.any?
                   ancestors = []
                   projects.sort_by(&:lft).each do |project|
                     if (ancestors.empty? || project.is_descendant_of?(ancestors.last))
                       s << "<ul>\n"
                     else
                       ancestors.pop
                       s << "</li>"
                       while (ancestors.any? && !project.is_descendant_of?(ancestors.last))
                         ancestors.pop
                         s << "</ul></li>\n"
                       end
                     end
                     s << "<li>"
                     s << yield(project).to_s
                     ancestors << project
                   end
                   s << ("</li></ul>\n" * ancestors.size)
                 end
                 s.html_safe
               end
               def principals_check_box_tags(name, principals)
                 s = ''
                 principals.sort.each do |principal|
                   s << "<label>#{ check_box_tag name, principal.id, false } #{h principal}</label>\n"
                 end
                 s.html_safe
               end
               # Returns a string for users/groups option tags
               def principals_options_for_select(collection, selected=nil)
                 s = ''
                 if collection.include?(User.current)
                   s << content_tag('option', "<< #{l(:label_me)} >>".html_safe, :value => User.current.id)
                 end
                 groups = ''
                 collection.sort.each do |element|
                   selected_attribute = ' selected="selected"' if option_value_selected?(element, selected)
                   (element.is_a?(Group) ? groups : s) << %(<option value="#{element.id}"#{selected_attribute}>#{h element.name}</option>)
                 end
                 unless groups.empty?
                   s << %(<optgroup label="#{h(l(:label_group_plural))}">#{groups}</optgroup>)
                 end
                 s.html_safe
               end
               # Truncates and returns the string as a single line
               def truncate_single_line(string, *args)
                 truncate(string.to_s, *args).gsub(%r{[\r\n]+}m, ' ')
               end
               # Truncates at line break after 250 characters or options[:length]
               def truncate_lines(string, options={})
                 length = options[:length] || 250
                 if string.to_s =~ /\A(.{#{length}}.*?)$/m
                   "#{$1}..."
                 else
                   string
                 end
               end
               def anchor(text)
                 text.to_s.gsub(' ', '_')
               end
               def html_hours(text)
                 text.gsub(%r{(\d+)\.(\d+)}, '<span class="hours hours-int">\1</span><span class="hours hours-dec">.\2</span>').html_safe
               end
               def authoring(created, author, options={})
                 l(options[:label] || :label_added_time_by, :author => link_to_user(author), :age => time_tag(created)).html_safe
               end
               def time_tag(time)
                 text = distance_of_time_in_words(Time.now, time)
                 if @project
                   link_to(text, {:controller => 'activities', :action => 'index', :id => @project, :from => User.current.time_to_date(time)}, :title => format_time(time))
                 else
                   content_tag('acronym', text, :title => format_time(time))
                 end
               end
               def syntax_highlight_lines(name, content)
                 lines = []
                 syntax_highlight(name, content).each_line { |line| lines << line }
                 lines
               end
               def syntax_highlight(name, content)
                 Redmine::SyntaxHighlighting.highlight_by_filename(content, name)
               end
               def to_path_param(path)
                 str = path.to_s.split(%r{[/\\]}).select{|p| !p.blank?}.join("/")
                 str.blank? ? nil : str
               end
               def pagination_links_full(paginator, count=nil, options={})
                 page_param = options.delete(:page_param) || :page
                 per_page_links = options.delete(:per_page_links)
                 url_param = params.dup
                 html = ''
                 if paginator.current.previous
                   # \xc2\xab(utf-8) = &#171;
                   html << link_to_content_update(
                                "\xc2\xab " + l(:label_previous),
                                url_param.merge(page_param => paginator.current.previous)) + ' '
                 end
                 html << (pagination_links_each(paginator, options) do |n|
                   link_to_content_update(n.to_s, url_param.merge(page_param => n))
                 end || '')
                 if paginator.current.next
                   # \xc2\xbb(utf-8) = &#187;
                   html << ' ' + link_to_content_update(
                                   (l(:label_next) + " \xc2\xbb"),
                                   url_param.merge(page_param => paginator.current.next))
                 end
                 unless count.nil?
                   html << " (#{paginator.current.first_item}-#{paginator.current.last_item}/#{count})"
                   if per_page_links != false && links = per_page_links(paginator.items_per_page, count)
             	      html << " | #{links}"
                   end
                 end
                 html.html_safe
               end
               def per_page_links(selected=nil, item_count=nil)
                 values = Setting.per_page_options_array
                 if item_count && values.any?
                   if item_count > values.first
                     max = values.detect {|value| value >= item_count} || item_count
                   else
                     max = item_count
                   end
                   values = values.select {|value| value <= max || value == selected}
                 end
                 if values.empty? || (values.size == 1 && values.first == selected)
                   return nil
                 end
                 links = values.collect do |n|
                   n == selected ? n : link_to_content_update(n, params.merge(:per_page => n))
                 end
                 l(:label_display_per_page, links.join(', '))
               end
               def reorder_links(name, url, method = :post)
                 link_to(image_tag('2uparrow.png', :alt => l(:label_sort_highest)),
                         url.merge({"#{name}[move_to]" => 'highest'}),
                         :method => method, :title => l(:label_sort_highest)) +
                 link_to(image_tag('1uparrow.png',   :alt => l(:label_sort_higher)),
                         url.merge({"#{name}[move_to]" => 'higher'}),
                        :method => method, :title => l(:label_sort_higher)) +
                 link_to(image_tag('1downarrow.png', :alt => l(:label_sort_lower)),
                         url.merge({"#{name}[move_to]" => 'lower'}),
                         :method => method, :title => l(:label_sort_lower)) +
                 link_to(image_tag('2downarrow.png', :alt => l(:label_sort_lowest)),
                         url.merge({"#{name}[move_to]" => 'lowest'}),
                        :method => method, :title => l(:label_sort_lowest))
               end
               def breadcrumb(*args)
                 elements = args.flatten
                 elements.any? ? content_tag('p', (args.join(" \xc2\xbb ") + " \xc2\xbb ").html_safe, :class => 'breadcrumb') : nil
               end
               def other_formats_links(&block)
                 concat('<p class="other-formats">'.html_safe + l(:label_export_to))
                 yield Redmine::Views::OtherFormatsBuilder.new(self)
                 concat('</p>'.html_safe)
               end
               def page_header_title
                 if @project.nil? || @project.new_record?
                   h(Setting.app_title)
                 else
                   b = []
                   ancestors = (@project.root? ? [] : @project.ancestors.visible.all)
                   if ancestors.any?
                     root = ancestors.shift
                     b << link_to_project(root, {:jump => current_menu_item}, :class => 'root')
                     if ancestors.size > 2
                       b << "\xe2\x80\xa6"
                       ancestors = ancestors[-2, 2]
                     end
                     b += ancestors.collect {|p| link_to_project(p, {:jump => current_menu_item}, :class => 'ancestor') }
                   end
                   b << h(@project)
                   b.join(" \xc2\xbb ").html_safe
                 end
               end
               def html_title(*args)
                 if args.empty?
                   title = @html_title || []
                   title << @project.name if @project
                   title << Setting.app_title unless Setting.app_title == title.last
                   title.select {|t| !t.blank? }.join(' - ')
                 else
                   @html_title ||= []
                   @html_title += args
                 end
               end
               # Returns the theme, controller name, and action as css classes for the
               # HTML body.
               def body_css_classes
                 css = []
                 if theme = Redmine::Themes.theme(Setting.ui_theme)
                   css << 'theme-' + theme.name
                 end
                 css << 'controller-' + controller_name
                 css << 'action-' + action_name
                 css.join(' ')
               end
               def accesskey(s)
                 Redmine::AccessKeys.key_for s
               end
               # Formats text according to system settings.
               # 2 ways to call this method:
               # * with a String: textilizable(text, options)
               # * with an object and one of its attribute: textilizable(issue, :description, options)
               def textilizable(*args)
                 options = args.last.is_a?(Hash) ? args.pop : {}
                 case args.size
                 when 1
                   obj = options[:object]
                   text = args.shift
                 when 2
                   obj = args.shift
                   attr = args.shift
                   text = obj.send(attr).to_s
                 else
                   raise ArgumentError, 'invalid arguments to textilizable'
                 end
                 return '' if text.blank?
                 project = options[:project] || @project || (obj && obj.respond_to?(:project) ? obj.project : nil)
                 only_path = options.delete(:only_path) == false ? false : true
                 text = Redmine::WikiFormatting.to_html(Setting.text_formatting, text, :object => obj, :attribute => attr)
                 @parsed_headings = []
                 @heading_anchors = {}
                 @current_section = 0 if options[:edit_section_links]
                 parse_sections(text, project, obj, attr, only_path, options)
                 text = parse_non_pre_blocks(text) do |text|
                   [:parse_inline_attachments, :parse_wiki_links, :parse_redmine_links, :parse_macros].each do |method_name|
                     send method_name, text, project, obj, attr, only_path, options
                   end
                 end
                 parse_headings(text, project, obj, attr, only_path, options)
                 if @parsed_headings.any?
                   replace_toc(text, @parsed_headings)
                 end
                 text.html_safe
               end
               def parse_non_pre_blocks(text)
                 s = StringScanner.new(text)
                 tags = []
                 parsed = ''
                 while !s.eos?
                   s.scan(/(.*?)(<(\/)?(pre|code)(.*?)>|\z)/im)
                   text, full_tag, closing, tag = s[1], s[2], s[3], s[4]
                   if tags.empty?
                     yield text
                   end
                   parsed << text
                   if tag
                     if closing
                       if tags.last == tag.downcase
                         tags.pop
                       end
                     else
                       tags << tag.downcase
                     end
                     parsed << full_tag
                   end
                 end
                 # Close any non closing tags
                 while tag = tags.pop
                   parsed << "</#{tag}>"
                 end
                 parsed
               end
               def parse_inline_attachments(text, project, obj, attr, only_path, options)
                 # when using an image link, try to use an attachment, if possible
                 if options[:attachments] || (obj && obj.respond_to?(:attachments))
                   attachments = options[:attachments] || obj.attachments
                   text.gsub!(/src="([^\/"]+\.(bmp|gif|jpg|jpe|jpeg|png))"(\s+alt="([^"]*)")?/i) do |m|
                     filename, ext, alt, alttext = $1.downcase, $2, $3, $4
                     # search for the picture in attachments
                     if found = Attachment.latest_attach(attachments, filename)
                       image_url = url_for :only_path => only_path, :controller => 'attachments',
                                           :action => 'download', :id => found
                       desc = found.description.to_s.gsub('"', '')
                       if !desc.blank? && alttext.blank?
                         alt = " title=\"#{desc}\" alt=\"#{desc}\""
                       end
                       "src=\"#{image_url}\"#{alt}"
                     else
                       m
                     end
                   end
                 end
               end
               # Wiki links
               #
               # Examples:
               #   [[mypage]]
               #   [[mypage|mytext]]
               # wiki links can refer other project wikis, using project name or identifier:
               #   [[project:]] -> wiki starting page
               #   [[project:|mytext]]
               #   [[project:mypage]]
               #   [[project:mypage|mytext]]
               def parse_wiki_links(text, project, obj, attr, only_path, options)
                 text.gsub!(/(!)?(\[\[([^\]\n\|]+)(\|([^\]\n\|]+))?\]\])/) do |m|
                   link_project = project
                   esc, all, page, title = $1, $2, $3, $5
                   if esc.nil?
                     if page =~ /^([^\:]+)\:(.*)$/
                       link_project = Project.find_by_identifier($1) || Project.find_by_name($1)
                       page = $2
                       title ||= $1 if page.blank?
                     end
                     if link_project && link_project.wiki
                       # extract anchor
                       anchor = nil
                       if page =~ /^(.+?)\#(.+)$/
                         page, anchor = $1, $2
                       end
                       anchor = sanitize_anchor_name(anchor) if anchor.present?
                       # check if page exists
                       wiki_page = link_project.wiki.find_page(page)
                       url = if anchor.present? && wiki_page.present? && (obj.is_a?(WikiContent) || obj.is_a?(WikiContent::Version)) && obj.page == wiki_page
                         "##{anchor}"
                       else
                         case options[:wiki_links]
                         when :local; "#{page.present? ? Wiki.titleize(page) : ''}.html" + (anchor.present? ? "##{anchor}" : '')
                         when :anchor; "##{page.present? ? Wiki.titleize(page) : title}" + (anchor.present? ? "_#{anchor}" : '') # used for single-file wiki export
                         else
                           wiki_page_id = page.present? ? Wiki.titleize(page) : nil
                           parent = wiki_page.nil? && obj.is_a?(WikiContent) && obj.page && project == link_project ? obj.page.title : nil
                           url_for(:only_path => only_path, :controller => 'wiki', :action => 'show', :project_id => link_project,
                            :id => wiki_page_id, :anchor => anchor, :parent => parent)
                         end
                       end
                       link_to(title.present? ? title.html_safe : h(page), url, :class => ('wiki-page' + (wiki_page ? '' : ' new')))
                     else
                       # project or wiki doesn't exist
                       all
                     end
                   else
                     all
                   end
                 end
               end
               # Redmine links
               #
               # Examples:
               #   Issues:
               #     #52 -> Link to issue #52
               #   Changesets:
               #     r52 -> Link to revision 52
               #     commit:a85130f -> Link to scmid starting with a85130f
               #   Documents:
               #     document#17 -> Link to document with id 17
               #     document:Greetings -> Link to the document with title "Greetings"
               #     document:"Some document" -> Link to the document with title "Some document"
               #   Versions:
               #     version#3 -> Link to version with id 3
               #     version:1.0.0 -> Link to version named "1.0.0"
               #     version:"1.0 beta 2" -> Link to version named "1.0 beta 2"
               #   Attachments:
               #     attachment:file.zip -> Link to the attachment of the current object named file.zip
               #   Source files:
               #     source:some/file -> Link to the file located at /some/file in the project's repository
               #     source:some/file@52 -> Link to the file's revision 52
               #     source:some/file#L120 -> Link to line 120 of the file
               #     source:some/file@52#L120 -> Link to line 120 of the file's revision 52
               #     export:some/file -> Force the download of the file
               #   Forum messages:
               #     message#1218 -> Link to message with id 1218
               #
               #   Links can refer other objects from other projects, using project identifier:
               #     identifier:r52
               #     identifier:document:"Some document"
               #     identifier:version:1.0.0
               #     identifier:source:some/file
               def parse_redmine_links(text, project, obj, attr, only_path, options)
                 text.gsub!(%r{([\s\(,\-\[\>]|^)(!)?(([a-z0-9\-_]+):)?(attachment|document|version|forum|news|message|project|commit|source|export)?(((#)|((([a-z0-9\-]+)\|)?(r)))((\d+)((#note)?-(\d+))?)|(:)([^"\s<>][^\s<>]*?|"[^"]+?"))(?=(?=[[:punct:]][^A-Za-z0-9_/])|,|\s|\]|<|$)}) do |m|
                   leading, esc, project_prefix, project_identifier, prefix, repo_prefix, repo_identifier, sep, identifier, comment_suffix, comment_id = $1, $2, $3, $4, $5, $10, $11, $8 || $12 || $18, $14 || $19, $15, $17
                   link = nil
                   if project_identifier
                     project = Project.visible.find_by_identifier(project_identifier)
                   end
                   if esc.nil?
                     if prefix.nil? && sep == 'r'
                       if project
                         repository = nil
                         if repo_identifier
                           repository = project.repositories.detect {|repo| repo.identifier == repo_identifier}
                         else
                           repository = project.repository
                         end
                         # project.changesets.visible raises an SQL error because of a double join on repositories
                         if repository && (changeset = Changeset.visible.find_by_repository_id_and_revision(repository.id, identifier))
                           link = link_to(h("#{project_prefix}#{repo_prefix}r#{identifier}"), {:only_path => only_path, :controller => 'repositories', :action => 'revision', :id => project, :repository_id => repository.identifier_param, :rev => changeset.revision},
                                                     :class => 'changeset',
                                                     :title => truncate_single_line(changeset.comments, :length => 100))
                         end
                       end
                     elsif sep == '#'
                       oid = identifier.to_i
                       case prefix
                       when nil
                         if issue = Issue.visible.find_by_id(oid, :include => :status)
                           anchor = comment_id ? "note-#{comment_id}" : nil
                           link = link_to("##{oid}", {:only_path => only_path, :controller => 'issues', :action => 'show', :id => oid, :anchor => anchor},
                                                     :class => issue.css_classes,
                                                     :title => "#{truncate(issue.subject, :length => 100)} (#{issue.status.name})")
                         end
                       when 'document'
                         if document = Document.visible.find_by_id(oid)
                           link = link_to h(document.title), {:only_path => only_path, :controller => 'documents', :action => 'show', :id => document},
                                                             :class => 'document'
                         end
                       when 'version'
                         if version = Version.visible.find_by_id(oid)
                           link = link_to h(version.name), {:only_path => only_path, :controller => 'versions', :action => 'show', :id => version},
                                                           :class => 'version'
                         end
                       when 'message'
                         if message = Message.visible.find_by_id(oid, :include => :parent)
                           link = link_to_message(message, {:only_path => only_path}, :class => 'message')
                         end
                       when 'forum'
                         if board = Board.visible.find_by_id(oid)
                           link = link_to h(board.name), {:only_path => only_path, :controller => 'boards', :action => 'show', :id => board, :project_id => board.project},
                                                          :class => 'board'
                         end
                       when 'news'
                         if news = News.visible.find_by_id(oid)
                           link = link_to h(news.title), {:only_path => only_path, :controller => 'news', :action => 'show', :id => news},
                                                         :class => 'news'
                         end
                       when 'project'
                         if p = Project.visible.find_by_id(oid)
                           link = link_to_project(p, {:only_path => only_path}, :class => 'project')
                         end
                       end
                     elsif sep == ':'
                       # removes the double quotes if any
                       name = identifier.gsub(%r{^"(.*)"$}, "\\1")
                       case prefix
                       when 'document'
                         if project && document = project.documents.visible.find_by_title(name)
                           link = link_to h(document.title), {:only_path => only_path, :controller => 'documents', :action => 'show', :id => document},
                                                             :class => 'document'
                         end
                       when 'version'
                         if project && version = project.versions.visible.find_by_name(name)
                           link = link_to h(version.name), {:only_path => only_path, :controller => 'versions', :action => 'show', :id => version},
                                                           :class => 'version'
                         end
                       when 'forum'
                         if project && board = project.boards.visible.find_by_name(name)
                           link = link_to h(board.name), {:only_path => only_path, :controller => 'boards', :action => 'show', :id => board, :project_id => board.project},
                                                          :class => 'board'
                         end
                       when 'news'
                         if project && news = project.news.visible.find_by_title(name)
                           link = link_to h(news.title), {:only_path => only_path, :controller => 'news', :action => 'show', :id => news},
                                                         :class => 'news'
                         end
                       when 'commit', 'source', 'export'
                         if project
                           repository = nil
                           if name =~ %r{^(([a-z0-9\-]+)\|)(.+)$}
                             repo_prefix, repo_identifier, name = $1, $2, $3
                             repository = project.repositories.detect {|repo| repo.identifier == repo_identifier}
                           else
                             repository = project.repository
                           end
                           if prefix == 'commit'
                             if repository && (changeset = Changeset.visible.find(:first, :conditions => ["repository_id = ? AND scmid LIKE ?", repository.id, "#{name}%"]))
                               link = link_to h("#{project_prefix}#{repo_prefix}#{name}"), {:only_path => only_path, :controller => 'repositories', :action => 'revision', :id => project, :repository_id => repository.identifier_param, :rev => changeset.identifier},
                                                            :class => 'changeset',
                                                            :title => truncate_single_line(h(changeset.comments), :length => 100)
                             end
                           else
                             if repository && User.current.allowed_to?(:browse_repository, project)
                               name =~ %r{^[/\\]*(.*?)(@([0-9a-f]+))?(#(L\d+))?$}
                               path, rev, anchor = $1, $3, $5
                               link = link_to h("#{project_prefix}#{prefix}:#{repo_prefix}#{name}"), {:controller => 'repositories', :action => 'entry', :id => project, :repository_id => repository.identifier_param,
                                                                       :path => to_path_param(path),
                                                                       :rev => rev,
                                                                       :anchor => anchor,
                                                                       :format => (prefix == 'export' ? 'raw' : nil)},
                                                                      :class => (prefix == 'export' ? 'source download' : 'source')
                             end
                           end
                           repo_prefix = nil
                         end
                       when 'attachment'
                         attachments = options[:attachments] || (obj && obj.respond_to?(:attachments) ? obj.attachments : nil)
                         if attachments && attachment = attachments.detect {|a| a.filename == name }
                           link = link_to h(attachment.filename), {:only_path => only_path, :controller => 'attachments', :action => 'download', :id => attachment},
                                                                  :class => 'attachment'
                         end
                       when 'project'
                         if p = Project.visible.find(:first, :conditions => ["identifier = :s OR LOWER(name) = :s", {:s => name.downcase}])
                           link = link_to_project(p, {:only_path => only_path}, :class => 'project')
                         end
                       end
                     end
                   end
                   (leading + (link || "#{project_prefix}#{prefix}#{repo_prefix}#{sep}#{identifier}#{comment_suffix}"))
                 end
               end
               HEADING_RE = /(<h(1|2|3|4)( [^>]+)?>(.+?)<\/h(1|2|3|4)>)/i unless const_defined?(:HEADING_RE)
               def parse_sections(text, project, obj, attr, only_path, options)
                 return unless options[:edit_section_links]
                 text.gsub!(HEADING_RE) do
                   heading = $1
                   @current_section += 1
                   if @current_section > 1
                     content_tag('div',
                       link_to(image_tag('edit.png'), options[:edit_section_links].merge(:section => @current_section)),
                       :class => 'contextual',
                       :title => l(:button_edit_section)) + heading.html_safe
                   else
                     heading
                   end
                 end
               end
               # Headings and TOC
               # Adds ids and links to headings unless options[:headings] is set to false
               def parse_headings(text, project, obj, attr, only_path, options)
                 return if options[:headings] == false
                 text.gsub!(HEADING_RE) do
                   level, attrs, content = $2.to_i, $3, $4
                   item = strip_tags(content).strip
                   anchor = sanitize_anchor_name(item)
                   # used for single-file wiki export
                   anchor = "#{obj.page.title}_#{anchor}" if options[:wiki_links] == :anchor && (obj.is_a?(WikiContent) || obj.is_a?(WikiContent::Version))
                   @heading_anchors[anchor] ||= 0
                   idx = (@heading_anchors[anchor] += 1)
                   if idx > 1
                     anchor = "#{anchor}-#{idx}"
                   end
                   @parsed_headings << [level, anchor, item]
                   "<a name=\"#{anchor}\"></a>\n<h#{level} #{attrs}>#{content}<a href=\"##{anchor}\" class=\"wiki-anchor\">&para;</a></h#{level}>"
                 end
               end
               MACROS_RE = /
                             (!)?                        # escaping
                             (
                             \{\{                        # opening tag
                             ([\w]+)                     # macro name
                             (\(([^\}]*)\))?             # optional arguments
                             \}\}                        # closing tag
                             )
                           /x unless const_defined?(:MACROS_RE)
               # Macros substitution
               def parse_macros(text, project, obj, attr, only_path, options)
                 text.gsub!(MACROS_RE) do
                   esc, all, macro = $1, $2, $3.downcase
                   args = ($5 || '').split(',').each(&:strip)
                   if esc.nil?
                     begin
                       exec_macro(macro, obj, args)
                     rescue => e
                       "<div class=\"flash error\">Error executing the <strong>#{macro}</strong> macro (#{e})</div>"
                     end || all
                   else
                     all
                   end
                 end
               end
               TOC_RE = /<p>\{\{([<>]?)toc\}\}<\/p>/i unless const_defined?(:TOC_RE)
               # Renders the TOC with given headings
               def replace_toc(text, headings)
                 text.gsub!(TOC_RE) do
                   if headings.empty?
                     ''
                   else
                     div_class = 'toc'
                     div_class << ' right' if $1 == '>'
                     div_class << ' left' if $1 == '<'
                     out = "<ul class=\"#{div_class}\"><li>"
                     root = headings.map(&:first).min
                     current = root
                     started = false
                     headings.each do |level, anchor, item|
                       if level > current
                         out << '<ul><li>' * (level - current)
                       elsif level < current
                         out << "</li></ul>\n" * (current - level) + "</li><li>"
                       elsif started
                         out << '</li><li>'
                       end
                       out << "<a href=\"##{anchor}\">#{item}</a>"
                       current = level
                       started = true
                     end
                     out << '</li></ul>' * (current - root)
                     out << '</li></ul>'
                   end
                 end
               end
               # Same as Rails' simple_format helper without using paragraphs
               def simple_format_without_paragraph(text)
                 text.to_s.
                   gsub(/\r\n?/, "\n").                    # \r\n and \r -> \n
                   gsub(/\n\n+/, "<br /><br />").          # 2+ newline  -> 2 br
                   gsub(/([^\n]\n)(?=[^\n])/, '\1<br />'). # 1 newline   -> br
                   html_safe
               end
               def lang_options_for_select(blank=true)
                 (blank ? [["(auto)", ""]] : []) +
                   valid_languages.collect{|lang| [ ll(lang.to_s, :general_lang_name), lang.to_s]}.sort{|x,y| x.last <=> y.last }
               end
               def label_tag_for(name, option_tags = nil, options = {})
                 label_text = l(("field_"+field.to_s.gsub(/\_id$/, "")).to_sym) + (options.delete(:required) ? @template.content_tag("span", " *", :class => "required"): "")
                 content_tag("label", label_text)
               end
               def labelled_tabular_form_for(*args, &proc)
                 ActiveSupport::Deprecation.warn "ApplicationHelper#labelled_tabular_form_for is deprecated and will be removed in Redmine 1.5. Use #labelled_form_for instead."
                 args << {} unless args.last.is_a?(Hash)
                 options = args.last
                 options[:html] ||= {}
                 options[:html][:class] = 'tabular' unless options[:html].has_key?(:class)
                 options.merge!({:builder => Redmine::Views::LabelledFormBuilder})
                 form_for(*args, &proc)
               end
               def labelled_form_for(*args, &proc)
                 args << {} unless args.last.is_a?(Hash)
                 options = args.last
                 if args.first.is_a?(Symbol)
                   options.merge!(:as => args.shift)
                 end
                 options.merge!({:builder => Redmine::Views::LabelledFormBuilder})
                 form_for(*args, &proc)
               end
               def labelled_fields_for(*args, &proc)
                 args << {} unless args.last.is_a?(Hash)
                 options = args.last
                 options.merge!({:builder => Redmine::Views::LabelledFormBuilder})
                 fields_for(*args, &proc)
               end
               def labelled_remote_form_for(*args, &proc)
                 args << {} unless args.last.is_a?(Hash)
                 options = args.last
                 options.merge!({:builder => Redmine::Views::LabelledFormBuilder, :remote => true})
                 form_for(*args, &proc)
               end
               def error_messages_for(*objects)
                 html = ""
                 objects = objects.map {|o| o.is_a?(String) ? instance_variable_get("@#{o}") : o}.compact
                 errors = objects.map {|o| o.errors.full_messages}.flatten
                 if errors.any?
                   html << "<div id='errorExplanation'><ul>\n"
                   errors.each do |error|
                     html << "<li>#{h error}</li>\n"
                   end
                   html << "</ul></div>\n"
                 end
                 html.html_safe
               end
               def delete_link(url, options={})
                 options = {
                   :method => :delete,
                   :data => {:confirm => l(:text_are_you_sure)},
                   :class => 'icon icon-del'
                 }.merge(options)
                 link_to l(:button_delete), url, options
               end
+              def preview_link(url, form, target='preview', options={})
+                content_tag 'a', l(:label_preview), {
+                    :href => "#",
+                    :onclick => %|submitPreview("#{escape_javascript url_for(url)}", "#{escape_javascript form}", "#{escape_javascript target}"); return false;|,
+                    :accesskey => accesskey(:preview)
+                  }.merge(options)
+              end
               def back_url_hidden_field_tag
                 back_url = params[:back_url] || request.env['HTTP_REFERER']
                 back_url = CGI.unescape(back_url.to_s)
                 hidden_field_tag('back_url', CGI.escape(back_url), :id => nil) unless back_url.blank?
               end
               def check_all_links(form_name)
                 link_to_function(l(:button_check_all), "checkAll('#{form_name}', true)") +
                 " | ".html_safe +
                 link_to_function(l(:button_uncheck_all), "checkAll('#{form_name}', false)")
               end
               def progress_bar(pcts, options={})
                 pcts = [pcts, pcts] unless pcts.is_a?(Array)
                 pcts = pcts.collect(&:round)
                 pcts[1] = pcts[1] - pcts[0]
                 pcts << (100 - pcts[1] - pcts[0])
                 width = options[:width] || '100px;'
                 legend = options[:legend] || ''
                 content_tag('table',
                   content_tag('tr',
                     (pcts[0] > 0 ? content_tag('td', '', :style => "width: #{pcts[0]}%;", :class => 'closed') : ''.html_safe) +
                     (pcts[1] > 0 ? content_tag('td', '', :style => "width: #{pcts[1]}%;", :class => 'done') : ''.html_safe) +
                     (pcts[2] > 0 ? content_tag('td', '', :style => "width: #{pcts[2]}%;", :class => 'todo') : ''.html_safe)
                   ), :class => 'progress', :style => "width: #{width};").html_safe +
                   content_tag('p', legend, :class => 'pourcent').html_safe
               end
               def checked_image(checked=true)
                 if checked
                   image_tag 'toggle_check.png'
                 end
               end
               def context_menu(url)
                 unless @context_menu_included
                   content_for :header_tags do
                     javascript_include_tag('context_menu') +
                       stylesheet_link_tag('context_menu')
                   end
                   if l(:direction) == 'rtl'
                     content_for :header_tags do
                       stylesheet_link_tag('context_menu_rtl')
                     end
                   end
                   @context_menu_included = true
                 end
                 javascript_tag "new ContextMenu('#{ url_for(url) }')"
               end
               def calendar_for(field_id)
                 include_calendar_headers_tags
                 image_tag("calendar.png", {:id => "#{field_id}_trigger",:class => "calendar-trigger"}) +
                 javascript_tag("Calendar.setup({inputField : '#{field_id}', ifFormat : '%Y-%m-%d', button : '#{field_id}_trigger' });")
               end
               def include_calendar_headers_tags
                 unless @calendar_headers_tags_included
                   @calendar_headers_tags_included = true
                   content_for :header_tags do
                     start_of_week = case Setting.start_of_week.to_i
                     when 1
                       'Calendar._FD = 1;' # Monday
                     when 7
                       'Calendar._FD = 0;' # Sunday
                     when 6
                       'Calendar._FD = 6;' # Saturday
                     else
                       '' # use language
                     end
                     javascript_include_tag('calendar/calendar') +
                     javascript_include_tag("calendar/lang/calendar-#{current_language.to_s.downcase}.js") +
                     javascript_tag(start_of_week) +
                     javascript_include_tag('calendar/calendar-setup') +
                     stylesheet_link_tag('calendar')
                   end
                 end
               end
               # Overrides Rails' stylesheet_link_tag with themes and plugins support.
               # Examples:
               #   stylesheet_link_tag('styles') # => picks styles.css from the current theme or defaults
               #   stylesheet_link_tag('styles', :plugin => 'foo) # => picks styles.css from plugin's assets
               #
               def stylesheet_link_tag(*sources)
                 options = sources.last.is_a?(Hash) ? sources.pop : {}
                 plugin = options.delete(:plugin)
                 sources = sources.map do |source|
                   if plugin
                     "/plugin_assets/#{plugin}/stylesheets/#{source}"
                   elsif current_theme && current_theme.stylesheets.include?(source)
                     current_theme.stylesheet_path(source)
                   else
                     source
                   end
                 end
                 super sources, options
               end
               # Overrides Rails' image_tag with themes and plugins support.
               # Examples:
               #   image_tag('image.png') # => picks image.png from the current theme or defaults
               #   image_tag('image.png', :plugin => 'foo) # => picks image.png from plugin's assets
               #
               def image_tag(source, options={})
                 if plugin = options.delete(:plugin)
                   source = "/plugin_assets/#{plugin}/images/#{source}"
                 elsif current_theme && current_theme.images.include?(source)
                   source = current_theme.image_path(source)
                 end
                 super source, options
               end
               # Overrides Rails' javascript_include_tag with plugins support
               # Examples:
               #   javascript_include_tag('scripts') # => picks scripts.js from defaults
               #   javascript_include_tag('scripts', :plugin => 'foo) # => picks scripts.js from plugin's assets
               #
               def javascript_include_tag(*sources)
                 options = sources.last.is_a?(Hash) ? sources.pop : {}
                 if plugin = options.delete(:plugin)
                   sources = sources.map do |source|
                     if plugin
                       "/plugin_assets/#{plugin}/javascripts/#{source}"
                     else
                       source
                     end
                   end
                 end
                 super sources, options
               end
               def content_for(name, content = nil, &block)
                 @has_content ||= {}
                 @has_content[name] = true
                 super(name, content, &block)
               end
               def has_content?(name)
                 (@has_content && @has_content[name]) || false
               end
               def sidebar_content?
                 has_content?(:sidebar) || view_layouts_base_sidebar_hook_response.present?
               end
               def view_layouts_base_sidebar_hook_response
                 @view_layouts_base_sidebar_hook_response ||= call_hook(:view_layouts_base_sidebar)
               end
               def email_delivery_enabled?
                 !!ActionMailer::Base.perform_deliveries
               end
               # Returns the avatar image tag for the given +user+ if avatars are enabled
               # +user+ can be a User or a string that will be scanned for an email address (eg. 'joe <joe@foo.bar>')
               def avatar(user, options = { })
                 if Setting.gravatar_enabled?
                   options.merge!({:ssl => (request && request.ssl?), :default => Setting.gravatar_default})
                   email = nil
                   if user.respond_to?(:mail)
                     email = user.mail
                   elsif user.to_s =~ %r{<(.+?)>}
                     email = $1
                   end
                   return gravatar(email.to_s.downcase, options) unless email.blank? rescue nil
                 else
                   ''
                 end
               end
               def sanitize_anchor_name(anchor)
                 anchor.gsub(%r{[^\w\s\-]}, '').gsub(%r{\s+(\-+\s*)?}, '-')
               end
               # Returns the javascript tags that are included in the html layout head
               def javascript_heads
                 tags = javascript_include_tag('prototype', 'effects', 'dragdrop', 'controls', 'rails', 'application')
                 unless User.current.pref.warn_on_leaving_unsaved == '0'
                   tags << "\n".html_safe + javascript_tag("Event.observe(window, 'load', function(){ new WarnLeavingUnsaved('#{escape_javascript( l(:text_warn_on_leaving_unsaved) )}'); });")
                 end
                 tags
               end
               def favicon
                 "<link rel='shortcut icon' href='#{image_path('/favicon.ico')}' />".html_safe
               end
               def robot_exclusion_tag
                 '<meta name="robots" content="noindex,follow,noarchive" />'.html_safe
               end
               # Returns true if arg is expected in the API response
               def include_in_api_response?(arg)
                 unless @included_in_api_response
                   param = params[:include]
                   @included_in_api_response = param.is_a?(Array) ? param.collect(&:to_s) : param.to_s.split(',')
                   @included_in_api_response.collect!(&:strip)
                 end
                 @included_in_api_response.include?(arg.to_s)
               end
               # Returns options or nil if nometa param or X-Redmine-Nometa header
               # was set in the request
               def api_meta(options)
                 if params[:nometa].present? || request.headers['X-Redmine-Nometa']
                   # compatibility mode for activeresource clients that raise
                   # an error when unserializing an array with attributes
                   nil
                 else
                   options
                 end
               end
               private
               def wiki_helper
                 helper = Redmine::WikiFormatting.helper_for(Setting.text_formatting)
                 extend helper
                 return self
               end
               def link_to_content_update(text, url_params = {}, html_options = {})
                 link_to(text, url_params, html_options)
               end
             end

app/views/boards/show.html.erb +1 -7

             <%= breadcrumb link_to(l(:label_board_plural), project_boards_path(@project)) %>
             <div class="contextual">
             <%= link_to_if_authorized l(:label_message_new),
                                       {:controller => 'messages', :action => 'new', :board_id => @board},
                                       :class => 'icon icon-add',
                                       :onclick => 'Element.show("add-message"); Form.Element.focus("message_subject"); return false;' %>
             <%= watcher_tag(@board, User.current) %>
             </div>
             <div id="add-message" style="display:none;">
             <% if authorize_for('messages', 'new') %>
             <h2><%= link_to h(@board.name), :controller => 'boards', :action => 'show', :project_id => @project, :id => @board %> &#187; <%= l(:label_message_new) %></h2>
             <%= form_for @message, :url => {:controller => 'messages', :action => 'new', :board_id => @board}, :html => {:multipart => true, :id => 'message-form'} do |f| %>
               <%= render :partial => 'messages/form', :locals => {:f => f} %>
               <p><%= submit_tag l(:button_create) %>
-              <%= link_to_remote l(:label_preview),
+              <%= preview_link({:controller => 'messages', :action => 'preview', :board_id => @board}, 'message-form') %> |
-                                 { :url => { :controller => 'messages', :action => 'preview', :board_id => @board },
-                                   :method => 'post',
-                                   :update => 'preview',
-                                   :with => "Form.serialize('message-form')",
-                                   :complete => "Element.scrollTo('preview')"
-                                 }, :accesskey => accesskey(:preview) %> |
               <%= link_to l(:button_cancel), "#", :onclick => 'Element.hide("add-message")' %></p>
             <% end %>
             <div id="preview" class="wiki"></div>
             <% end %>
             </div>
             <h2><%=h @board.name %></h2>
             <p class="subtitle"><%=h @board.description %></p>
             <% if @topics.any? %>
             <table class="list messages">
               <thead><tr>
                 <th><%= l(:field_subject) %></th>
                 <th><%= l(:field_author) %></th>
                 <%= sort_header_tag('created_on', :caption => l(:field_created_on)) %>
                 <%= sort_header_tag('replies', :caption => l(:label_reply_plural)) %>
                 <%= sort_header_tag('updated_on', :caption => l(:label_message_last)) %>
               </tr></thead>
               <tbody>
               <% @topics.each do |topic| %>
                 <tr class="message <%= cycle 'odd', 'even' %> <%= topic.sticky? ? 'sticky' : '' %> <%= topic.locked? ? 'locked' : '' %>">
                   <td class="subject"><%= link_to h(topic.subject), { :controller => 'messages', :action => 'show', :board_id => @board, :id => topic } %></td>
                   <td class="author" align="center"><%= link_to_user(topic.author) %></td>
                   <td class="created_on" align="center"><%= format_time(topic.created_on) %></td>
                   <td class="replies" align="center"><%= topic.replies_count %></td>
                   <td class="last_message">
                     <% if topic.last_reply %>
                     <%= authoring topic.last_reply.created_on, topic.last_reply.author %><br />
                     <%= link_to_message topic.last_reply %>
                     <% end %>
                   </td>
                 </tr>
               <% end %>
               </tbody>
             </table>
             <p class="pagination"><%= pagination_links_full @topic_pages, @topic_count %></p>
             <% else %>
             <p class="nodata"><%= l(:label_no_data) %></p>
             <% end %>
             <% other_formats_links do |f| %>
               <%= f.link_to 'Atom', :url => {:key => User.current.rss_key} %>
             <% end %>
             <% html_title @board.name %>
             <% content_for :header_tags do %>
                 <%= auto_discovery_link_tag(:atom, {:format => 'atom', :key => User.current.rss_key}, :title => "#{@project}: #{@board}") %>
                 <%= stylesheet_link_tag 'scm' %>
             <% end %>

app/views/issues/_edit.html.erb +1 -7

             <%= labelled_form_for @issue, :html => {:id => 'issue-form', :multipart => true} do |f| %>
                 <%= error_messages_for 'issue', 'time_entry' %>
                 <%= render :partial => 'conflict' if @conflict %>
                 <div class="box">
                 <% if @edit_allowed || !@allowed_statuses.empty? %>
                     <fieldset class="tabular"><legend><%= l(:label_change_properties) %></legend>
                     <div id="all_attributes">
                     <%= render :partial => 'form', :locals => {:f => f} %>
                     </div>
                     </fieldset>
                 <% end %>
                 <% if User.current.allowed_to?(:log_time, @project) %>
                     <fieldset class="tabular"><legend><%= l(:button_log_time) %></legend>
                     <%= labelled_fields_for :time_entry, @time_entry do |time_entry| %>
                     <div class="splitcontentleft">
                     <p><%= time_entry.text_field :hours, :size => 6, :label => :label_spent_time %> <%= l(:field_hours) %></p>
                     </div>
                     <div class="splitcontentright">
                     <p><%= time_entry.select :activity_id, activity_collection_for_select_options %></p>
                     </div>
                     <p><%= time_entry.text_field :comments, :size => 60 %></p>
                     <% @time_entry.custom_field_values.each do |value| %>
                       <p><%= custom_field_tag_with_label :time_entry, value %></p>
                     <% end %>
                     <% end %>
                 </fieldset>
                 <% end %>
                 <fieldset><legend><%= l(:field_notes) %></legend>
                 <%= text_area_tag 'notes', @notes, :cols => 60, :rows => 10, :class => 'wiki-edit' %>
                 <%= wikitoolbar_for 'notes' %>
                 <%= call_hook(:view_issues_edit_notes_bottom, { :issue => @issue, :notes => @notes, :form => f }) %>
                 <p><%=l(:label_attachment_plural)%><br /><%= render :partial => 'attachments/form', :locals => {:container => @issue} %></p>
                 </fieldset>
                 </div>
                 <%= f.hidden_field :lock_version %>
                 <%= hidden_field_tag 'last_journal_id', params[:last_journal_id] || @issue.last_journal_id %>
                 <%= submit_tag l(:button_submit) %>
-                <%= link_to_remote l(:label_preview),
+                <%= preview_link preview_edit_issue_path(:project_id => @project, :id => @issue), 'issue-form' %>
-                                   { :url => preview_edit_issue_path(:project_id => @project, :id => @issue),
-                                     :method => 'post',
-                                     :update => 'preview',
-                                     :with => 'Form.serialize("issue-form")',
-                                     :complete => "Element.scrollTo('preview')"
-                                   }, :accesskey => accesskey(:preview) %>
             <% end %>
             <div id="preview" class="wiki"></div>

app/views/issues/new.html.erb +1 -7

             <h2><%=l(:label_issue_new)%></h2>
             <%= call_hook(:view_issues_new_top, {:issue => @issue}) %>
             <%= labelled_form_for @issue, :url => project_issues_path(@project),
                                          :html => {:id => 'issue-form', :multipart => true} do |f| %>
               <%= error_messages_for 'issue' %>
               <%= hidden_field_tag 'copy_from', params[:copy_from] if params[:copy_from] %>
               <div class="box tabular">
                 <div id="all_attributes">
                 <%= render :partial => 'issues/form', :locals => {:f => f} %>
                 </div>
                 <% if @copy_from && @copy_from.attachments.any? %>
                 <p>
                   <label for="copy_attachments"><%= l(:label_copy_attachments) %></label>
                   <%= check_box_tag 'copy_attachments', '1', @copy_attachments %>
                 </p>
                 <% end %>
                 <p id="attachments_form"><%= label_tag('attachments[1][file]', l(:label_attachment_plural))%><%= render :partial => 'attachments/form', :locals => {:container => @issue} %></p>
                 <% if @issue.safe_attribute? 'watcher_user_ids' -%>
                   <p id="watchers_form"><label><%= l(:label_issue_watchers) %></label>
                   <span id="watchers_inputs">
                     <%= watchers_checkboxes(@issue, @available_watchers) %>
                   </span>
                   <span class="search_for_watchers">
                   <%= link_to_remote l(:label_search_for_watchers),
                                :url => {:controller => 'watchers', :action => 'new', :project_id => @issue.project},
                                :method => 'get' %>
                   </span>
                   </p>
                 <% end %>
               </div>
               <%= submit_tag l(:button_create) %>
               <%= submit_tag l(:button_create_and_continue), :name => 'continue' %>
-              <%= link_to_remote l(:label_preview),
+              <%= preview_link preview_new_issue_path(:project_id => @project), 'issue-form' %>
-                                   { :url => preview_new_issue_path(:project_id => @project),
-                                     :method => 'post',
-                                     :update => 'preview',
-                                     :with => "Form.serialize('issue-form')",
-                                     :complete => "Element.scrollTo('preview')"
-                                   }, :accesskey => accesskey(:preview) %>
               <%= javascript_tag "Form.Element.focus('issue_subject');" %>
             <% end %>
             <div id="preview" class="wiki"></div>
             <% content_for :header_tags do %>
                 <%= stylesheet_link_tag 'scm' %>
                 <%= robot_exclusion_tag %>
             <% end %>

app/views/journals/_notes_form.html.erb +3 -8

             <%= form_remote_tag(:url => {}, :html => { :id => "journal-#{@journal.id}-form" }) do %>
                 <%= label_tag "notes", l(:description_notes), :class => "hidden-for-sighted" %>
                 <%= text_area_tag :notes, @journal.notes,
                       :id => "journal_#{@journal.id}_notes",
                       :class => 'wiki-edit',
                       :rows => (@journal.notes.blank? ? 10 : [[10, @journal.notes.length / 50].max, 100].min) %>
                 <%= call_hook(:view_journals_notes_form_after_notes, { :journal => @journal}) %>
                 <p><%= submit_tag l(:button_save) %>
-                <%= link_to_remote l(:label_preview),
+                <%= preview_link preview_edit_issue_path(:project_id => @project, :id => @journal.issue),
-                                   { :url => preview_edit_issue_path(:project_id => @project, :id => @journal.issue),
+                                 "journal-#{@journal.id}-form",
-                                     :method => 'post',
+                                 "journal_#{@journal.id}_preview" %> |
-                                     :update => "journal_#{@journal.id}_preview",
-                                     :with => "Form.serialize('journal-#{@journal.id}-form')",
-                                     :complete => "Element.scrollTo('journal_#{@journal.id}_preview')"
-                                   }, :accesskey => accesskey(:preview) %>
                 <%= link_to l(:button_cancel), '#', :onclick => "Element.remove('journal-#{@journal.id}-form'); " +
                                                                 "Element.show('journal-#{@journal.id}-notes'); return false;" %></p>
                 <div id="journal_<%= @journal.id %>_preview" class="wiki"></div>
             <% end %>
             <%= wikitoolbar_for "journal_#{@journal.id}_notes" %>

app/views/messages/edit.html.erb +1 -8

             <h2><%= link_to h(@board.name), :controller => 'boards',
                            :action => 'show', :project_id => @project,
                            :id => @board %> &#187; <%= h @message.subject %></h2>
             <%= form_for @message, {
                            :as => :message,
                            :url => {:action => 'edit'},
                            :html => {:multipart => true,
                                      :id => 'message-form',
                                      :method => :post}
                       } do |f| %>
               <%= render :partial => 'form',
                          :locals => {:f => f, :replying => !@message.parent.nil?} %>
               <%= submit_tag l(:button_save) %>
-              <%= link_to_remote l(:label_preview),
+              <%= preview_link({:controller => 'messages', :action => 'preview', :board_id => @board, :id => @message}, 'message-form') %>
-                                 { :url => { :controller => 'messages',
-                                             :action => 'preview', :board_id => @board, :id => @message },
-                                   :method => 'post',
-                                   :update => 'preview',
-                                   :with => "Form.serialize('message-form')",
-                                   :complete => "Element.scrollTo('preview')"
-                                 }, :accesskey => accesskey(:preview) %>
             <% end %>
             <div id="preview" class="wiki"></div>
             <% content_for :header_tags do %>
                 <%= stylesheet_link_tag 'scm' %>
             <% end %>

app/views/messages/new.html.erb +1 -7

             <h2><%= link_to h(@board.name), :controller => 'boards', :action => 'show', :project_id => @project, :id => @board %> &#187; <%= l(:label_message_new) %></h2>
             <%= form_for @message, :url => {:action => 'new'}, :html => {:multipart => true, :id => 'message-form'} do |f| %>
               <%= render :partial => 'form', :locals => {:f => f} %>
               <%= submit_tag l(:button_create) %>
-              <%= link_to_remote l(:label_preview),
+              <%= preview_link({:controller => 'messages', :action => 'preview', :board_id => @board}, 'message-form') %>
-                                 { :url => { :controller => 'messages', :action => 'preview', :board_id => @board },
-                                   :method => 'post',
-                                   :update => 'preview',
-                                   :with => "Form.serialize('message-form')",
-                                   :complete => "Element.scrollTo('preview')"
-                                 }, :accesskey => accesskey(:preview) %>
             <% end %>
             <div id="preview" class="wiki"></div>

app/views/messages/show.html.erb +1 -7

             <%= breadcrumb link_to(l(:label_board_plural), project_boards_path(@project)),
                            link_to(h(@board.name), project_board_path(@project, @board)) %>
             <div class="contextual">
                 <%= watcher_tag(@topic, User.current) %>
                 <%= link_to_remote_if_authorized(
                       l(:button_quote),
                       { :url => {:action => 'quote', :id => @topic} },
                       :class => 'icon icon-comment'
                     ) unless @topic.locked? %>
                 <%= link_to(
                       l(:button_edit),
                       {:action => 'edit', :id => @topic},
                       :class => 'icon icon-edit'
                     ) if @message.editable_by?(User.current) %>
                 <%= link_to(
                       l(:button_delete),
                       {:action => 'destroy', :id => @topic},
                       :method => :post,
                       :data => {:confirm => l(:text_are_you_sure)},
                       :class => 'icon icon-del'
                      ) if @message.destroyable_by?(User.current) %>
             </div>
             <h2><%= avatar(@topic.author, :size => "24") %><%=h @topic.subject %></h2>
             <div class="message">
             <p><span class="author"><%= authoring @topic.created_on, @topic.author %></span></p>
             <div class="wiki">
             <%= textilizable(@topic, :content) %>
             </div>
             <%= link_to_attachments @topic, :author => false %>
             </div>
             <br />
             <% unless @replies.empty? %>
             <h3 class="comments"><%= l(:label_reply_plural) %> (<%= @reply_count %>)</h3>
             <% @replies.each do |message| %>
               <div class="message reply" id="<%= "message-#{message.id}" %>">
                 <div class="contextual">
                   <%= link_to_remote_if_authorized(
                         image_tag('comment.png'),
                         { :url => {:action => 'quote', :id => message} },
                         :title => l(:button_quote)
                       ) unless @topic.locked? %>
                   <%= link_to(
                         image_tag('edit.png'),
                         {:action => 'edit', :id => message},
                         :title => l(:button_edit)
                       ) if message.editable_by?(User.current) %>
                   <%= link_to(
                         image_tag('delete.png'),
                         {:action => 'destroy', :id => message},
                         :method => :post,
                         :data => {:confirm => l(:text_are_you_sure)},
                         :title => l(:button_delete)
                       ) if message.destroyable_by?(User.current) %>
                 </div>
               <h4>
                 <%= avatar(message.author, :size => "24") %>
                 <%= link_to h(message.subject), { :controller => 'messages', :action => 'show', :board_id => @board, :id => @topic, :r => message, :anchor => "message-#{message.id}" } %>
                 -
                 <%= authoring message.created_on, message.author %>
               </h4>
               <div class="wiki"><%= textilizable message, :content, :attachments => message.attachments %></div>
               <%= link_to_attachments message, :author => false %>
               </div>
             <% end %>
             <p class="pagination"><%= pagination_links_full @reply_pages, @reply_count, :per_page_links => false %></p>
             <% end %>
             <% if !@topic.locked? && authorize_for('messages', 'reply') %>
             <p><%= toggle_link l(:button_reply), "reply", :focus => 'message_content' %></p>
             <div id="reply" style="display:none;">
             <%= form_for @reply, :as => :reply, :url => {:action => 'reply', :id => @topic}, :html => {:multipart => true, :id => 'message-form'} do |f| %>
               <%= render :partial => 'form', :locals => {:f => f, :replying => true} %>
               <%= submit_tag l(:button_submit) %>
-              <%= link_to_remote l(:label_preview),
+              <%= preview_link({:controller => 'messages', :action => 'preview', :board_id => @board}, 'message-form') %>
-                                 { :url => { :controller => 'messages', :action => 'preview', :board_id => @board },
-                                   :method => 'post',
-                                   :update => 'preview',
-                                   :with => "Form.serialize('message-form')",
-                                   :complete => "Element.scrollTo('preview')"
-                                 }, :accesskey => accesskey(:preview) %>
             <% end %>
             <div id="preview" class="wiki"></div>
             </div>
             <% end %>
             <% content_for :header_tags do %>
               <%= stylesheet_link_tag 'scm' %>
             <% end %>
             <% html_title @topic.subject %>

app/views/news/edit.html.erb +1 -6

             <h2><%=l(:label_news)%></h2>
             <%= labelled_form_for @news, :html => { :id => 'news-form', :multipart => true, :method => :put } do |f| %>
             <%= render :partial => 'form', :locals => { :f => f } %>
             <%= submit_tag l(:button_save) %>
-            <%= link_to_remote l(:label_preview),
+            <%= preview_link preview_news_path(:project_id => @project), 'news-form' %>
-                               { :url => preview_news_path(:project_id => @project),
-                                 :method => 'get',
-                                 :update => 'preview',
-                                 :with => "Form.serialize('news-form')"
-                               }, :accesskey => accesskey(:preview) %>
             <% end %>
             <div id="preview" class="wiki"></div>
             <% content_for :header_tags do %>
               <%= stylesheet_link_tag 'scm' %>
             <% end %>

app/views/news/index.html.erb +1 -6

             <div class="contextual">
             <%= link_to(l(:label_news_new),
                         new_project_news_path(@project),
                         :class => 'icon icon-add',
                         :onclick => 'Element.show("add-news"); Form.Element.focus("news_title"); return false;') if @project && User.current.allowed_to?(:manage_news, @project) %>
             </div>
             <div id="add-news" style="display:none;">
             <h2><%=l(:label_news_new)%></h2>
             <%= labelled_form_for @news, :url => project_news_index_path(@project),
                                                        :html => { :id => 'news-form', :multipart => true } do |f| %>
             <%= render :partial => 'news/form', :locals => { :f => f } %>
             <%= submit_tag l(:button_create) %>
-            <%= link_to_remote l(:label_preview),
+            <%= preview_link preview_news_path(:project_id => @project), 'news-form' %> |
-                               { :url => preview_news_path(:project_id => @project),
-                                 :method => 'get',
-                                 :update => 'preview',
-                                 :with => "Form.serialize('news-form')"
-                               }, :accesskey => accesskey(:preview) %> |
             <%= link_to l(:button_cancel), "#", :onclick => 'Element.hide("add-news")' %>
             <% end if @project %>
             <div id="preview" class="wiki"></div>
             </div>
             <h2><%=l(:label_news_plural)%></h2>
             <% if @newss.empty? %>
             <p class="nodata"><%= l(:label_no_data) %></p>
             <% else %>
             <% @newss.each do |news| %>
                 <h3><%= avatar(news.author, :size => "24") %><%= link_to_project(news.project) + ': ' unless news.project == @project %>
                 <%= link_to h(news.title), news_path(news) %>
                 <%= "(#{l(:label_x_comments, :count => news.comments_count)})" if news.comments_count > 0 %></h3>
                 <p class="author"><%= authoring news.created_on, news.author %></p>
                 <div class="wiki">
                 <%= textilizable(news, :description) %>
                 </div>
             <% end %>
             <% end %>
             <p class="pagination"><%= pagination_links_full @news_pages %></p>
             <% other_formats_links do |f| %>
               <%= f.link_to 'Atom', :url => {:project_id => @project, :key => User.current.rss_key} %>
             <% end %>
             <% content_for :header_tags do %>
               <%= auto_discovery_link_tag(:atom, params.merge({:format => 'atom', :page => nil, :key => User.current.rss_key})) %>
               <%= stylesheet_link_tag 'scm' %>
             <% end %>
             <% html_title(l(:label_news_plural)) -%>

app/views/news/new.html.erb +1 -6

             <h2><%=l(:label_news_new)%></h2>
             <%= labelled_form_for @news, :url => project_news_index_path(@project),
                                                        :html => { :id => 'news-form', :multipart => true } do |f| %>
               <%= render :partial => 'news/form', :locals => { :f => f } %>
               <%= submit_tag l(:button_create) %>
-              <%= link_to_remote l(:label_preview),
+              <%= preview_link preview_news_path(:project_id => @project), 'news-form' %>
-                                 { :url => preview_news_path(:project_id => @project),
-                                   :method => 'get',
-                                   :update => 'preview',
-                                   :with => "Form.serialize('news-form')"
-                                 }, :accesskey => accesskey(:preview) %>
             <% end %>
             <div id="preview" class="wiki"></div>

app/views/news/show.html.erb +1 -6

             <div class="contextual">
             <%= watcher_tag(@news, User.current) %>
             <%= link_to(l(:button_edit),
                   edit_news_path(@news),
                   :class => 'icon icon-edit',
                   :accesskey => accesskey(:edit),
                   :onclick => 'Element.show("edit-news"); return false;') if User.current.allowed_to?(:manage_news, @project) %>
             <%= delete_link news_path(@news) if User.current.allowed_to?(:manage_news, @project) %>
             </div>
             <h2><%= avatar(@news.author, :size => "24") %><%=h @news.title %></h2>
             <% if authorize_for('news', 'edit') %>
             <div id="edit-news" style="display:none;">
             <%= labelled_form_for :news, @news, :url => news_path(@news),
                                                        :html => { :id => 'news-form', :multipart => true, :method => :put } do |f| %>
             <%= render :partial => 'form', :locals => { :f => f } %>
             <%= submit_tag l(:button_save) %>
-            <%= link_to_remote l(:label_preview),
+            <%= preview_link preview_news_path(:project_id => @project), 'news-form' %> |
-                               { :url => preview_news_path(:project_id => @project),
-                                 :method => 'get',
-                                 :update => 'preview',
-                                 :with => "Form.serialize('news-form')"
-                               }, :accesskey => accesskey(:preview) %> |
             <%= link_to l(:button_cancel), "#", :onclick => 'Element.hide("edit-news"); return false;' %>
             <% end %>
             <div id="preview" class="wiki"></div>
             </div>
             <% end %>
             <p><% unless @news.summary.blank? %><em><%=h @news.summary %></em><br /><% end %>
             <span class="author"><%= authoring @news.created_on, @news.author %></span></p>
             <div class="wiki">
             <%= textilizable(@news, :description) %>
             </div>
             <%= link_to_attachments @news %>
             <br />
             <div id="comments" style="margin-bottom:16px;">
             <h3 class="comments"><%= l(:label_comment_plural) %></h3>
             <% @comments.each do |comment| %>
                 <% next if comment.new_record? %>
                 <div class="contextual">
                 <%= link_to_if_authorized image_tag('delete.png'), {:controller => 'comments', :action => 'destroy', :id => @news, :comment_id => comment},
                                                                    :data => {:confirm => l(:text_are_you_sure)}, :method => :delete, :title => l(:button_delete) %>
                 </div>
                 <h4><%= avatar(comment.author, :size => "24") %><%= authoring comment.created_on, comment.author %></h4>
                 <%= textilizable(comment.comments) %>
             <% end if @comments.any? %>
             </div>
             <% if @news.commentable? %>
             <p><%= toggle_link l(:label_comment_add), "add_comment_form", :focus => "comment_comments" %></p>
             <%= form_tag({:controller => 'comments', :action => 'create', :id => @news}, :id => "add_comment_form", :style => "display:none;") do %>
             <div class="box">
                 <%= text_area 'comment', 'comments', :cols => 80, :rows => 15, :class => 'wiki-edit' %>
                 <%= wikitoolbar_for 'comment_comments' %>
             </div>
             <p><%= submit_tag l(:button_add) %></p>
             <% end %>
             <% end %>
             <% html_title @news.title -%>
             <% content_for :header_tags do %>
               <%= stylesheet_link_tag 'scm' %>
             <% end %>

app/views/wiki/edit.html.erb +1 -8

             <%= wiki_page_breadcrumb(@page) %>
             <h2><%= h @page.pretty_title %></h2>
             <%= form_for @content, :as => :content,
                         :url => {:action => 'update', :id => @page.title},
                         :html => {:method => :put, :multipart => true, :id => 'wiki_form'} do |f| %>
             <%= f.hidden_field :version %>
             <% if @section %>
             <%= hidden_field_tag 'section', @section %>
             <%= hidden_field_tag 'section_hash', @section_hash %>
             <% end %>
             <%= error_messages_for 'content' %>
             <div class="box tabular">
             <%= text_area_tag 'content[text]', @text, :cols => 100, :rows => 25,
                               :class => 'wiki-edit', :accesskey => accesskey(:edit) %>
             <% if @page.safe_attribute_names.include?('parent_id') && @wiki.pages.any? %>
               <%= fields_for @page do |fp| %>
                 <p>
                   <label><%= l(:field_parent_title) %></label>
                   <%= fp.select :parent_id,
                                 content_tag('option', '', :value => '') +
                                    wiki_page_options_for_select(@wiki.pages.all(:include => :parent) -
                                      @page.self_and_descendants, @page.parent) %>
                 </p>
               <% end %>
             <% end %>
             <p><label><%= l(:field_comments) %></label><%= f.text_field :comments, :size => 120 %></p>
             <p><label><%=l(:label_attachment_plural)%></label><%= render :partial => 'attachments/form' %></p>
             </div>
             <p><%= submit_tag l(:button_save) %>
-               <%= link_to_remote l(:label_preview),
+               <%= preview_link({:controller => 'wiki', :action => 'preview', :project_id => @project, :id => @page.title }, 'wiki_form') %></p>
-                                   { :url => { :controller => 'wiki', :action => 'preview',
-                                               :project_id => @project, :id => @page.title },
-                                     :method => :post,
-                                     :update => 'preview',
-                                     :with => "Form.serialize('wiki_form')",
-                                     :complete => "Element.scrollTo('preview')"
-                                   }, :accesskey => accesskey(:preview) %></p>
             <%= wikitoolbar_for 'content_text' %>
             <% end %>
             <div id="preview" class="wiki"></div>
             <% content_for :header_tags do %>
               <%= stylesheet_link_tag 'scm' %>
               <%= robot_exclusion_tag %>
             <% end %>
             <% html_title @page.pretty_title %>

public/javascripts/application.js +10 0

             /* Redmine - project management software
                Copyright (C) 2006-2012  Jean-Philippe Lang */
             function checkAll (id, checked) {
               var els = Element.descendants(id);
               for (var i = 0; i < els.length; i++) {
                 if (els[i].disabled==false) {
                   els[i].checked = checked;
                 }
               }
             }
             function toggleCheckboxesBySelector(selector) {
               boxes = $$(selector);
               var all_checked = true;
               for (i = 0; i < boxes.length; i++) { if (boxes[i].checked == false) { all_checked = false; } }
               for (i = 0; i < boxes.length; i++) { boxes[i].checked = !all_checked; }
             }
             function setCheckboxesBySelector(checked, selector) {
               var boxes = $$(selector);
               boxes.each(function(ele) {
                 ele.checked = checked;
               });
             }
             function showAndScrollTo(id, focus) {
               Element.show(id);
               if (focus!=null) { Form.Element.focus(focus); }
               Element.scrollTo(id);
             }
             function toggleRowGroup(el) {
               var tr = Element.up(el, 'tr');
               var n = Element.next(tr);
               tr.toggleClassName('open');
               while (n != undefined && !n.hasClassName('group')) {
                 Element.toggle(n);
                 n = Element.next(n);
               }
             }
             function collapseAllRowGroups(el) {
               var tbody = Element.up(el, 'tbody');
               tbody.childElements('tr').each(function(tr) {
                 if (tr.hasClassName('group')) {
                   tr.removeClassName('open');
                 } else {
                   tr.hide();
                 }
               })
             }
             function expandAllRowGroups(el) {
               var tbody = Element.up(el, 'tbody');
               tbody.childElements('tr').each(function(tr) {
                 if (tr.hasClassName('group')) {
                   tr.addClassName('open');
                 } else {
                   tr.show();
                 }
               })
             }
             function toggleAllRowGroups(el) {
               var tr = Element.up(el, 'tr');
               if (tr.hasClassName('open')) {
                 collapseAllRowGroups(el);
               } else {
                 expandAllRowGroups(el);
               }
             }
             function toggleFieldset(el) {
               var fieldset = Element.up(el, 'fieldset');
               fieldset.toggleClassName('collapsed');
               Effect.toggle(fieldset.down('div'), 'slide', {duration:0.2});
             }
             function hideFieldset(el) {
               var fieldset = Element.up(el, 'fieldset');
               fieldset.toggleClassName('collapsed');
               fieldset.down('div').hide();
             }
             function add_filter() {
               select = $('add_filter_select');
               field = select.value
               Element.show('tr_' +  field);
               check_box = $('cb_' + field);
               check_box.checked = true;
               toggle_filter(field);
               select.selectedIndex = 0;
               for (i=0; i<select.options.length; i++) {
                 if (select.options[i].value == field) {
                   select.options[i].disabled = true;
                 }
               }
             }
             function toggle_filter(field) {
               check_box = $('cb_' + field);
               if (check_box.checked) {
                 Element.show("operators_" + field);
                 Form.Element.enable("operators_" + field);
                 toggle_operator(field);
               } else {
                 Element.hide("operators_" + field);
                 Form.Element.disable("operators_" + field);
                 enableValues(field, []);
               }
             }
             function enableValues(field, indexes) {
               var f = $$(".values_" + field);
               for(var i=0;i<f.length;i++) {
                 if (indexes.include(i)) {
                   Form.Element.enable(f[i]);
                   f[i].up('span').show();
                 } else {
                   f[i].value = '';
                   Form.Element.disable(f[i]);
                   f[i].up('span').hide();
                 }
               }
               if (indexes.length > 0) {
                 Element.show("div_values_" + field);
               } else {
                 Element.hide("div_values_" + field);
               }
             }
             function toggle_operator(field) {
               operator = $("operators_" + field);
               switch (operator.value) {
                 case "!*":
                 case "*":
                 case "t":
                 case "w":
                 case "o":
                 case "c":
                   enableValues(field, []);
                   break;
                 case "><":
                   enableValues(field, [0,1]);
                   break;
                 case "<t+":
                 case ">t+":
                 case "t+":
                 case ">t-":
                 case "<t-":
                 case "t-":
                   enableValues(field, [2]);
                   break;
                 default:
                   enableValues(field, [0]);
                   break;
               }
             }
             function toggle_multi_select(el) {
               var select = $(el);
               if (select.multiple == true) {
                 select.multiple = false;
               } else {
                 select.multiple = true;
               }
             }
             function submit_query_form(id) {
               selectAllOptions("selected_columns");
               $(id).submit();
             }
             function apply_filters_observer() {
               $$("#query_form input[type=text]").invoke("observe", "keypress", function(e){
                 if(e.keyCode == Event.KEY_RETURN) {
                   submit_query_form("query_form");
                 }
               });
             }
             var fileFieldCount = 1;
             function addFileField() {
               var fields = $('attachments_fields');
               if (fields.childElements().length >= 10) return false;
               fileFieldCount++;
               var s = new Element('span');
               s.update(fields.down('span').innerHTML);
               s.down('input.file').name = "attachments[" + fileFieldCount + "][file]";
               s.down('input.description').name = "attachments[" + fileFieldCount + "][description]";
               fields.appendChild(s);
             }
             function removeFileField(el) {
               var fields = $('attachments_fields');
               var s = Element.up(el, 'span');
               if (fields.childElements().length > 1) {
                 s.remove();
               } else {
                 s.update(s.innerHTML);
               }
             }
             function checkFileSize(el, maxSize, message) {
               var files = el.files;
               if (files) {
                 for (var i=0; i<files.length; i++) {
                   if (files[i].size > maxSize) {
                     alert(message);
                     el.value = "";
                   }
                 }
               }
             }
             function showTab(name) {
               var f = $$('div#content .tab-content');
               for(var i=0; i<f.length; i++){
                 Element.hide(f[i]);
               }
               var f = $$('div.tabs a');
               for(var i=0; i<f.length; i++){
                 Element.removeClassName(f[i], "selected");
               }
               Element.show('tab-content-' + name);
               Element.addClassName('tab-' + name, "selected");
               return false;
             }
             function moveTabRight(el) {
               var lis = Element.up(el, 'div.tabs').down('ul').childElements();
               var tabsWidth = 0;
               var i;
               for (i=0; i<lis.length; i++) {
                 if (lis[i].visible()) {
                   tabsWidth += lis[i].getWidth() + 6;
                 }
               }
               if (tabsWidth < Element.up(el, 'div.tabs').getWidth() - 60) {
                 return;
               }
               i=0;
               while (i<lis.length && !lis[i].visible()) {
                 i++;
               }
               lis[i].hide();
             }
             function moveTabLeft(el) {
               var lis = Element.up(el, 'div.tabs').down('ul').childElements();
               var i = 0;
               while (i<lis.length && !lis[i].visible()) {
                 i++;
               }
               if (i>0) {
                 lis[i-1].show();
               }
             }
             function displayTabsButtons() {
               var lis;
               var tabsWidth = 0;
               var i;
               $$('div.tabs').each(function(el) {
                 lis = el.down('ul').childElements();
                 for (i=0; i<lis.length; i++) {
                   if (lis[i].visible()) {
                     tabsWidth += lis[i].getWidth() + 6;
                   }
                 }
                 if ((tabsWidth < el.getWidth() - 60) && (lis[0].visible())) {
                   el.down('div.tabs-buttons').hide();
                 } else {
                   el.down('div.tabs-buttons').show();
                 }
               });
             }
             function setPredecessorFieldsVisibility() {
                 relationType = $('relation_relation_type');
                 if (relationType && (relationType.value == "precedes" || relationType.value == "follows")) {
                     Element.show('predecessor_fields');
                 } else {
                     Element.hide('predecessor_fields');
                 }
             }
             function promptToRemote(text, param, url) {
                 value = prompt(text + ':');
                 if (value) {
                     new Ajax.Request(url + '?' + param + '=' + encodeURIComponent(value), {asynchronous:true, evalScripts:true});
                     return false;
                 }
             }
             function showModal(id, width) {
               el = $(id);
               if (el == undefined || el.visible()) {return;}
               var h = $$('body')[0].getHeight();
               var d = document.createElement("div");
               d.id = 'modalbg';
               $('main').appendChild(d);
               $('modalbg').setStyle({ width: '100%', height: h + 'px' });
               $('modalbg').show();
               var pageWidth = document.viewport.getWidth();
               if (width) {
                 el.setStyle({'width': width});
               }
               el.setStyle({'left': (((pageWidth - el.getWidth())/2  *100) / pageWidth) + '%'});
               el.addClassName('modal');
               el.show();
               if (el.down("input[type=text]")) {
                 el.down("input[type=text]").focus();
               } else if (el.down("input[type=submit]")) {
                 el.down("input[type=submit]").focus();
             	}
             }
             function hideModal(el) {
               var modal;
             	if (el) {
             		modal = Element.up(el, 'div.modal');
             	} else {
             		modal = $('ajax-modal');
             	}
               if (modal) {
                 modal.hide();
               }
               var bg = $('modalbg');
               if (bg) {
                 bg.remove();
               }
             }
+            function submitPreview(url, form, target) {
+              new Ajax.Updater(target, url, {
+                asynchronous:true,
+                evalScripts:true,
+                method:'post',
+                onComplete:function(request){Element.scrollTo(target)},
+                parameters:Form.serialize(form)
+              });
+            }
             function collapseScmEntry(id) {
               var els = document.getElementsByClassName(id, 'browser');
               for (var i = 0; i < els.length; i++) {
                  if (els[i].hasClassName('open')) {
                      collapseScmEntry(els[i].id);
                  }
                  Element.hide(els[i]);
               }
               $(id).removeClassName('open');
             }
             function expandScmEntry(id) {
                 var els = document.getElementsByClassName(id, 'browser');
                 for (var i = 0; i < els.length; i++) {
                    Element.show(els[i]);
                    if (els[i].hasClassName('loaded') && !els[i].hasClassName('collapsed')) {
                         expandScmEntry(els[i].id);
                    }
                 }
                 $(id).addClassName('open');
             }
             function scmEntryClick(id) {
                 el = $(id);
                 if (el.hasClassName('open')) {
                     collapseScmEntry(id);
                     el.addClassName('collapsed');
                     return false;
                 } else if (el.hasClassName('loaded')) {
                     expandScmEntry(id);
                     el.removeClassName('collapsed');
                     return false;
                 }
                 if (el.hasClassName('loading')) {
                     return false;
                 }
                 el.addClassName('loading');
                 return true;
             }
             function scmEntryLoaded(id) {
                 Element.addClassName(id, 'open');
                 Element.addClassName(id, 'loaded');
                 Element.removeClassName(id, 'loading');
             }
             function randomKey(size) {
               var chars = new Array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z');
               var key = '';
               for (i = 0; i < size; i++) {
                 key += chars[Math.floor(Math.random() * chars.length)];
               }
               return key;
             }
             function observeParentIssueField(url) {
               new Ajax.Autocompleter('issue_parent_issue_id',
                                      'parent_issue_candidates',
                                      url,
                                      { minChars: 3,
                                        frequency: 0.5,
                                        paramName: 'q',
                                        method: 'get',
                                        updateElement: function(value) {
                                          document.getElementById('issue_parent_issue_id').value = value.id;
                                        }});
             }
             function observeRelatedIssueField(url) {
               new Ajax.Autocompleter('relation_issue_to_id',
                                      'related_issue_candidates',
                                      url,
                                      { minChars: 3,
                                        frequency: 0.5,
                                        paramName: 'q',
                                        method: 'get',
                                        updateElement: function(value) {
                                          document.getElementById('relation_issue_to_id').value = value.id;
                                        },
                                        parameters: 'scope=all'
                                        });
             }
             function setVisible(id, visible) {
               var el = $(id);
               if (el) {if (visible) {el.show();} else {el.hide();}}
             }
             function observeProjectModules() {
               var f = function() {
                 /* Hides trackers and issues custom fields on the new project form when issue_tracking module is disabled */
                 var c = ($('project_enabled_module_names_issue_tracking').checked == true);
                 setVisible('project_trackers', c);
                 setVisible('project_issue_custom_fields', c);
               };
               Event.observe(window, 'load', f);
               Event.observe('project_enabled_module_names_issue_tracking', 'change', f);
             }
             /*
              * Class used to warn user when leaving a page with unsaved textarea
              * Author: mathias.fischer@berlinonline.de
             */
             var WarnLeavingUnsaved = Class.create({
               observedForms: false,
               observedElements: false,
               changedForms: false,
               message: null,
               initialize: function(message){
                 this.observedForms = $$('form');
                 this.observedElements =  $$('textarea');
                 this.message = message;
                 this.observedElements.each(this.observeChange.bind(this));
                 this.observedForms.each(this.submitAction.bind(this));
                 window.onbeforeunload = this.unload.bind(this);
               },
               unload: function(){
                 this.observedElements.each(function(el) {el.blur();})
                 if(this.changedForms)
                   return this.message;
               },
               setChanged: function(){
                 this.changedForms = true;
               },
               setUnchanged: function(){
                 this.changedForms = false;
               },
               observeChange: function(element){
                 element.observe('change',this.setChanged.bindAsEventListener(this));
               },
               submitAction: function(element){
                 element.observe('submit',this.setUnchanged.bindAsEventListener(this));
               }
             });
             /*
              * 1 - registers a callback which copies the csrf token into the
              * X-CSRF-Token header with each ajax request.  Necessary to
              * work with rails applications which have fixed
              * CVE-2011-0447
              * 2 - shows and hides ajax indicator
              */
             Ajax.Responders.register({
                 onCreate: function(request){
                     var csrf_meta_tag = $$('meta[name=csrf-token]')[0];
                     if (csrf_meta_tag) {
                         var header = 'X-CSRF-Token',
                             token = csrf_meta_tag.readAttribute('content');
                         if (!request.options.requestHeaders) {
                           request.options.requestHeaders = {};
                         }
                         request.options.requestHeaders[header] = token;
                       }
                     if ($('ajax-indicator') && Ajax.activeRequestCount > 0 && $$('input.ajax-loading').size() == 0) {
                         Element.show('ajax-indicator');
                     }
                 },
                 onComplete: function(){
                     if ($('ajax-indicator') && Ajax.activeRequestCount == 0) {
                         Element.hide('ajax-indicator');
                     }
                 }
             });
             function hideOnLoad() {
               $$('.hol').each(function(el) {
                 el.hide();
               });
             }
             function addFormObserversForDoubleSubmit() {
               $$('form[method=post]').each(function(form) {
                 if (!form.hasClassName('multiple-submit')) {
                   form.on('submit', function(form_submission) {
                     if (form.getStorage().get('submitted')) {
                       form_submission.stop();
                     } else {
                       form.getStorage().set('submitted', true);
                     }
                   });
                 }
               });
             }
             Event.observe(window, 'load', hideOnLoad);
             Event.observe(window, 'load', addFormObserversForDoubleSubmit);

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages