jro_apps/redmine Commit - r13045:cc688bb1b114

Backport r13313 from rails-4.1 to trunk....

Toshi MARUYAMA -

r13045:cc688bb1b114

parent child

Context file:

r13045:cc688bb1b114

Expand all files

The requested changes are too big and content was truncated. Show full diff

public/javascripts/jquery-1.11.1-ui-1.11.0-ujs-3.1.1.js created 644 0 0

	1	NO CONTENT: new file 100644			NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

public/stylesheets/jquery/images/animated-overlay.gif created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

public/stylesheets/jquery/jquery-ui-1.11.0.css created 644 0 0

	1	NO CONTENT: new file 100644			NO CONTENT: new file 100644
The requested commit or file is too big and content was truncated. Show full diff

Gemfile +1 -1

             source 'https://rubygems.org'
             gem "rails", "3.2.19"
-            gem "jquery-rails", "~> 2.0.2"
+            gem "jquery-rails", "~> 3.1.1"
             gem "coderay", "~> 1.1.0"
             gem "fastercsv", "~> 1.5.0", :platforms => [:mri_18, :mingw_18, :jruby]
             gem "builder", ">= 3.0.4"
             gem "request_store", "1.0.5"
             gem "mime-types"
             gem "rbpdf", "~> 1.18.0"
             # Optional gem for LDAP authentication
             group :ldap do
               gem "net-ldap", "~> 0.3.1"
             end
             # Optional gem for OpenID authentication
             group :openid do
               gem "ruby-openid", "~> 2.3.0", :require => "openid"
               gem "rack-openid"
             end
             platforms :mri, :mingw do
               # Optional gem for exporting the gantt to a PNG file, not supported with jruby
               group :rmagick do
                 # RMagick 2 supports ruby 1.9
                 # RMagick 1 would be fine for ruby 1.8 but Bundler does not support
                 # different requirements for the same gem on different platforms
                 gem "rmagick", ">= 2.0.0"
               end
               # Optional Markdown support, not for JRuby
               group :markdown do
                 # TODO: upgrade to redcarpet 3.x when ruby1.8 support is dropped
                 gem "redcarpet", "~> 2.3.0"
               end
             end
             platforms :jruby do
               # jruby-openssl is bundled with JRuby 1.7.0
               gem "jruby-openssl" if Object.const_defined?(:JRUBY_VERSION) && JRUBY_VERSION < '1.7.0'
               gem "activerecord-jdbc-adapter", "~> 1.3.2"
             end
             # Include database gems for the adapters found in the database
             # configuration file
             require 'erb'
             require 'yaml'
             database_file = File.join(File.dirname(__FILE__), "config/database.yml")
             if File.exist?(database_file)
               database_config = YAML::load(ERB.new(IO.read(database_file)).result)
               adapters = database_config.values.map {|c| c['adapter']}.compact.uniq
               if adapters.any?
                 adapters.each do |adapter|
                   case adapter
                   when 'mysql2'
                     gem "mysql2", "~> 0.3.11", :platforms => [:mri, :mingw]
                     gem "activerecord-jdbcmysql-adapter", :platforms => :jruby
                   when 'mysql'
                     gem "mysql", "~> 2.8.1", :platforms => [:mri, :mingw]
                     gem "activerecord-jdbcmysql-adapter", :platforms => :jruby
                   when /postgresql/
                     gem "pg", ">= 0.11.0", :platforms => [:mri, :mingw]
                     gem "activerecord-jdbcpostgresql-adapter", :platforms => :jruby
                   when /sqlite3/
                     gem "sqlite3", :platforms => [:mri, :mingw]
                     gem "activerecord-jdbcsqlite3-adapter", :platforms => :jruby
                   when /sqlserver/
                     gem "tiny_tds", "~> 0.6.2", :platforms => [:mri, :mingw]
                     gem "activerecord-sqlserver-adapter", :platforms => [:mri, :mingw]
                   else
                     warn("Unknown database adapter `#{adapter}` found in config/database.yml, use Gemfile.local to load your own database gems")
                   end
                 end
               else
                 warn("No adapter found in config/database.yml, please configure it first")
               end
             else
               warn("Please configure your config/database.yml first")
             end
             group :development do
               gem "rdoc", ">= 2.4.2"
               gem "yard"
             end
             group :test do
               gem "shoulda", "~> 3.3.2"
               gem "mocha", "~> 1.0.0", :require => 'mocha/api'
               if RUBY_VERSION >= '1.9.3'
                 gem "capybara", "~> 2.1.0"
                 gem "selenium-webdriver"
               end
             end
             local_gemfile = File.join(File.dirname(__FILE__), "Gemfile.local")
             if File.exists?(local_gemfile)
               puts "Loading Gemfile.local ..." if $DEBUG # `ruby -d` or `bundle -v`
               instance_eval File.read(local_gemfile)
             end
             # Load plugins' Gemfiles
             Dir.glob File.expand_path("../plugins/*/{Gemfile,PluginGemfile}", __FILE__) do |file|
               puts "Loading #{file} ..." if $DEBUG # `ruby -d` or `bundle -v`
               #TODO: switch to "eval_gemfile file" when bundler >= 1.2.0 will be required (rails 4)
               instance_eval File.read(file), file
             end

app/helpers/application_helper.rb +1 -1

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2014  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
               include Redmine::Pagination::Helper
               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
               # 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? || (User.current.admin? && user.logged?)
                     link_to name, user_path(user), :class => user.css_classes
                   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
               #   link_to_issue(issue, :subject => false, :tracker => false)     # => #6
               #
               def link_to_issue(issue, options={})
                 title = nil
                 subject = nil
                 text = options[:tracker] == false ? "##{issue.id}" : "#{issue.tracker} ##{issue.id}"
                 if options[:subject] == false
                   title = issue.subject.truncate(60)
                 else
                   subject = issue.subject
                   if truncate_length = options[:truncate]
                     subject = subject.truncate(truncate_length)
                   end
                 end
                 only_path = options[:only_path].nil? ? true : options[:only_path]
                 s = link_to(text, issue_path(issue, :only_path => only_path),
                             :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
                 route_method = options.delete(:download) ? :download_named_attachment_path : :named_attachment_path
                 html_options = options.slice!(:only_path)
                 url = send(route_method, attachment, attachment.filename, options)
                 link_to text, url, html_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(
                   message.subject.truncate(60),
                   board_message_path(message.board_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, {: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.name)
                 elsif options.key?(:action)
                   ActiveSupport::Deprecation.warn "#link_to_project with :action option is deprecated and will be removed in Redmine 3.0."
                   url = {:controller => 'projects', :action => 'show', :id => project}.merge(options)
                   link_to project.name, url, html_options
                 else
                   link_to project.name, project_path(project, options), html_options
                 end
               end
               # Generates a link to a project settings if active
               def link_to_project_settings(project, options={}, html_options=nil)
                 if project.active?
                   link_to project.name, settings_project_path(project, options), html_options
                 elsif project.archived?
                   h(project.name)
                 else
                   link_to project.name, project_path(project, options), html_options
                 end
               end
               # Generates a link to a version
               def link_to_version(version, options = {})
                 return '' unless version && version.is_a?(Version)
                 options = {:title => format_date(version.effective_date)}.merge(options)
                 link_to_if version.visible?, format_version_name(version), version_path(version), options
               end
               # Helper that formats object for html or text rendering
               def format_object(object, html=true, &block)
                 if block_given?
                   object = yield object
                 end
                 case object.class.name
                 when 'Array'
                   object.map {|o| format_object(o, html)}.join(', ').html_safe
                 when 'Time'
                   format_time(object)
                 when 'Date'
                   format_date(object)
                 when 'Fixnum'
                   object.to_s
                 when 'Float'
                   sprintf "%.2f", object
                 when 'User'
                   html ? link_to_user(object) : object.to_s
                 when 'Project'
                   html ? link_to_project(object) : object.to_s
                 when 'Version'
                   html ? link_to_version(object) : object.to_s
                 when 'TrueClass'
                   l(:general_text_Yes)
                 when 'FalseClass'
                   l(:general_text_No)
                 when 'Issue'
                   object.visible? && html ? link_to_issue(object) : "##{object.id}"
                 when 'CustomValue', 'CustomFieldValue'
                   if object.custom_field
                     f = object.custom_field.format.formatted_custom_value(self, object, html)
                     if f.nil? || f.is_a?(String)
                       f
                     else
                       format_object(f, html, &block)
                     end
                   else
                     object.value.to_s
                   end
                 else
                   html ? h(object) : object.to_s
                 end
               end
               def wiki_page_path(page, options={})
                 url_for({:controller => 'wiki', :action => 'show', :project_id => page.project, :id => page.title}.merge(options))
               end
               def thumbnail_tag(attachment)
                 link_to image_tag(thumbnail_path(attachment)),
                   named_attachment_path(attachment, attachment.filename),
                   :title => attachment.filename
               end
               def toggle_link(name, id, options={})
                 onclick = "$('##{id}').toggle(); "
                 onclick << (options[:focus] ? "$('##{options[:focus]}').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 format_activity_title(text)
                 h(truncate_single_line_raw(text, 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(text.to_s.truncate(120).gsub(%r{[\r\n]*<(pre|code)>.*$}m, '...')
                    ).gsub(/[\r\n]+/, "<br />").html_safe
               end
               def format_version_name(version)
                 if !version.shared? || 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
               # Renders a tree of projects as a nested set of unordered lists
               # The given collection may be a subset of the whole project tree
               # (eg. some intermediate nodes are private and can not be seen)
               def render_project_nested_lists(projects)
                 s = ''
                 if projects.any?
                   ancestors = []
                   original_project = @project
                   projects.sort_by(&:lft).each do |project|
                     # set the project environment to please macros.
                     @project = project
                     if (ancestors.empty? || project.is_descendant_of?(ancestors.last))
                       s << "<ul class='projects #{ ancestors.empty? ? 'root' : nil}'>\n"
                     else
                       ancestors.pop
                       s << "</li>"
                       while (ancestors.any? && !project.is_descendant_of?(ancestors.last))
                         ancestors.pop
                         s << "</ul></li>\n"
                       end
                     end
                     classes = (ancestors.empty? ? 'root' : 'child')
                     s << "<li class='#{classes}'><div class='#{classes}'>"
                     s << h(block_given? ? yield(project) : project.name)
                     s << "</div>\n"
                     ancestors << project
                   end
                   s << ("</li></ul>\n" * ancestors.size)
                   @project = original_project
                 end
                 s.html_safe
               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, :version => nil},
                                        :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, selected=params[:tab])
                 if tabs.any?
                   unless tabs.detect {|tab| tab[:name] == selected}
                     selected = nil
                   end
                   selected ||= tabs.first[:name]
                   render :partial => 'common/tabs', :locals => {:tabs => tabs, :selected_tab => selected}
                 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 principals_check_box_tags(name, principals)
                 s = ''
                 principals.each do |principal|
                   s << "<label>#{ check_box_tag name, principal.id, false, :id => nil } #{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)} >>", :value => User.current.id)
                 end
                 groups = ''
                 collection.sort.each do |element|
                   selected_attribute = ' selected="selected"' if option_value_selected?(element, selected) || element.id.to_s == 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
               # Options for the new membership projects combo-box
               def options_for_membership_project_select(principal, projects)
                 options = content_tag('option', "--- #{l(:actionview_instancetag_blank_option)} ---")
                 options << project_tree_options_for_select(projects) do |p|
                   {:disabled => principal.projects.to_a.include?(p)}
                 end
                 options
               end
               def option_tag(name, text, value, selected=nil, options={})
                 content_tag 'option', value, options.merge(:value => value, :selected => (value == selected))
               end
               # Truncates and returns the string as a single line
               def truncate_single_line(string, *args)
                 ActiveSupport::Deprecation.warn(
                   "ApplicationHelper#truncate_single_line is deprecated and will be removed in Rails 4 poring")
                 # Rails 4 ActionView::Helpers::TextHelper#truncate escapes.
                 # So, result is broken.
                 truncate(string.to_s, *args).gsub(%r{[\r\n]+}m, ' ')
               end
               def truncate_single_line_raw(string, length)
                 string.truncate(length).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('abbr', 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 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
               # Returns a h2 tag and sets the html title with the given arguments
               def title(*args)
                 strings = args.map do |arg|
                   if arg.is_a?(Array) && arg.size >= 2
                     link_to(*arg)
                   else
                     h(arg.to_s)
                   end
                 end
                 html_title args.reverse.map {|s| (s.is_a?(Array) ? s.first : s).to_s}
                 content_tag('h2', strings.join(' &#187; ').html_safe)
               end
               # Sets the html title
               # Returns the html title when called without arguments
               # Current project name and app_title and automatically appended
               # Exemples:
               #   html_title 'Foo', 'Bar'
               #   html_title # => 'Foo - Bar - My Project - Redmine'
               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.reject(&: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 << 'project-' + @project.identifier if @project && @project.identifier.present?
                 css << 'controller-' + controller_name
                 css << 'action-' + action_name
                 css.join(' ')
               end
               def accesskey(s)
                 @used_accesskeys ||= []
                 key = Redmine::AccessKeys.key_for(s)
                 return nil if @used_accesskeys.include?(key)
                 @used_accesskeys << key
                 key
               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 = text.dup
                 macros = catch_macros(text)
                 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, obj, macros) do |text|
                   [:parse_inline_attachments, :parse_wiki_links, :parse_redmine_links].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, obj, macros)
                 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
                     inject_macros(text, obj, macros) if macros.any?
                   else
                     inject_macros(text, obj, macros, false) if macros.any?
                   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
                 attachments = options[:attachments] || []
                 attachments += obj.attachments if obj.respond_to?(:attachments)
                 if attachments.present?
                   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 = download_named_attachment_path(found, found.filename, :only_path => only_path)
                       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 =~ /^([^\:]+)\:(.*)$/
                       identifier, page = $1, $2
                       link_project = Project.find_by_identifier(identifier) || Project.find_by_name(identifier)
                       title ||= identifier 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, :version => nil, :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
               #  Projects:
               #     project:someproject -> Link to project named "someproject"
               #     project#3 -> Link to project with id 3
               #
               #   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, default_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
                   project = default_project
                   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_raw(changeset.comments, 100))
                         end
                       end
                     elsif sep == '#'
                       oid = identifier.to_i
                       case prefix
                       when nil
                         if oid.to_s == identifier &&
                               issue = Issue.visible.includes(:status).find_by_id(oid)
                           anchor = comment_id ? "note-#{comment_id}" : nil
                           link = link_to(h("##{oid}#{comment_suffix}"),
                                          {:only_path => only_path, :controller => 'issues',
                                           :action => 'show', :id => oid, :anchor => anchor},
                                          :class => issue.css_classes,
                                          :title => "#{issue.subject.truncate(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.includes(:parent).find_by_id(oid)
                           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")
                       name = CGI.unescapeHTML(name)
                       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.where("repository_id = ? AND scmid LIKE ?", repository.id, "#{name}%").first)
                               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_raw(changeset.comments, 100)
                             end
                           else
                             if repository && User.current.allowed_to?(:browse_repository, project)
                               name =~ %r{^[/\\]*(.*?)(@([^/\\@]+?))?(#(L\d+))?$}
                               path, rev, anchor = $1, $3, $5
                               link = link_to h("#{project_prefix}#{prefix}:#{repo_prefix}#{name}"), {:only_path => only_path, :controller => 'repositories', :action => (prefix == 'export' ? 'raw' : 'entry'), :id => project, :repository_id => repository.identifier_param,
                                                                       :path => to_path_param(path),
                                                                       :rev => rev,
                                                                       :anchor => anchor},
                                                                      :class => (prefix == 'export' ? 'source download' : 'source')
                             end
                           end
                           repo_prefix = nil
                         end
                       when 'attachment'
                         attachments = options[:attachments] || []
                         attachments += obj.attachments if obj.respond_to?(:attachments)
                         if attachments && attachment = Attachment.latest_attach(attachments, name)
                           link = link_to_attachment(attachment, :only_path => only_path, :download => true, :class => 'attachment')
                         end
                       when 'project'
                         if p = Project.visible.where("identifier = :s OR LOWER(name) = :s", :s => name.downcase).first
                           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(\d)( [^>]+)?>(.+?)<\/h(\d)>)/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),
                       :id => "section-#{@current_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
                             (\(([^\n\r]*?)\))?          # optional arguments
                             ([\n\r].*?[\n\r])?          # optional block of text
                             \}\}                        # closing tag
                             )
                            )/mx unless const_defined?(:MACROS_RE)
               MACRO_SUB_RE = /(
                               \{\{
                               macro\((\d+)\)
                               \}\}
                               )/x unless const_defined?(:MACRO_SUB_RE)
               # Extracts macros from text
               def catch_macros(text)
                 macros = {}
                 text.gsub!(MACROS_RE) do
                   all, macro = $1, $4.downcase
                   if macro_exists?(macro) || all =~ MACRO_SUB_RE
                     index = macros.size
                     macros[index] = all
                     "{{macro(#{index})}}"
                   else
                     all
                   end
                 end
                 macros
               end
               # Executes and replaces macros in text
               def inject_macros(text, obj, macros, execute=true)
                 text.gsub!(MACRO_SUB_RE) do
                   all, index = $1, $2.to_i
                   orig = macros.delete(index)
                   if execute && orig && orig =~ MACROS_RE
                     esc, all, macro, args, block = $2, $3, $4.downcase, $6.to_s, $7.try(:strip)
                     if esc.nil?
                       h(exec_macro(macro, obj, args, block) || all)
                     else
                       h(all)
                     end
                   elsif orig
                     h(orig)
                   else
                     h(all)
                   end
                 end
               end
               TOC_RE = /<p>\{\{((<|&lt;)|(>|&gt;))?toc\}\}<\/p>/i unless const_defined?(:TOC_RE)
               # Renders the TOC with given headings
               def replace_toc(text, headings)
                 text.gsub!(TOC_RE) do
                   left_align, right_align = $2, $3
                   # Keep only the 4 first levels
                   headings = headings.select{|level, anchor, item| level <= 4}
                   if headings.empty?
                     ''
                   else
                     div_class = 'toc'
                     div_class << ' right' if right_align
                     div_class << ' left' if left_align
                     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)", ""]] : []) + languages_options
               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_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)
                 ActiveSupport::Deprecation.warn "ApplicationHelper#labelled_remote_form_for is deprecated and will be removed in Redmine 2.2."
                 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 link_to_function(name, function, html_options={})
                 content_tag(:a, name, {:href => '#', :onclick => "#{function}; return false;"}.merge(html_options))
               end
               # Helper to render JSON in views
               def raw_json(arg)
                 arg.to_json.to_s.gsub('/', '\/').html_safe
               end
               def back_url
                 url = params[:back_url]
                 if url.nil? && referer = request.env['HTTP_REFERER']
                   url = CGI.unescape(referer.to_s)
                 end
                 url
               end
               def back_url_hidden_field_tag
                 url = back_url
                 hidden_field_tag('back_url', url, :id => nil) unless 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 progress-#{pcts[0]}", :style => "width: #{width};").html_safe +
                   content_tag('p', legend, :class => 'percent').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 "contextMenuInit('#{ url_for(url) }')"
               end
               def calendar_for(field_id)
                 include_calendar_headers_tags
                 javascript_tag("$(function() { $('##{field_id}').datepicker(datepickerOptions); });")
               end
               def include_calendar_headers_tags
                 unless @calendar_headers_tags_included
                   tags = javascript_include_tag("datepicker")
                   @calendar_headers_tags_included = true
                   content_for :header_tags do
                     start_of_week = Setting.start_of_week
                     start_of_week = l(:general_first_day_of_week, :default => '1') if start_of_week.blank?
                     # Redmine uses 1..7 (monday..sunday) in settings and locales
                     # JQuery uses 0..6 (sunday..saturday), 7 needs to be changed to 0
                     start_of_week = start_of_week.to_i % 7
                     tags << javascript_tag(
                                "var datepickerOptions={dateFormat: 'yy-mm-dd', firstDay: #{start_of_week}, " +
                                  "showOn: 'button', buttonImageOnly: true, buttonImage: '" +
                                  path_to_image('/images/calendar.png') +
                                  "', showButtonPanel: true, showWeek: true, showOtherMonths: true, " +
                                  "selectOtherMonths: true, changeMonth: true, changeYear: true, " +
                                  "beforeShow: beforeShowDatePicker};")
                     jquery_locale = l('jquery.locale', :default => current_language.to_s)
                     unless jquery_locale == 'en'
                       tags << javascript_include_tag("i18n/jquery.ui.datepicker-#{jquery_locale}.js")
                     end
                     tags
                   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
               # TODO: remove this in 2.5.0
               def has_content?(name)
                 content_for?(name)
               end
               def sidebar_content?
                 content_for?(: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)
                 if ''.respond_to?(:encoding) || RUBY_PLATFORM == 'java'
                   anchor.gsub(%r{[^\s\-\p{Word}]}, '').gsub(%r{\s+(\-+\s*)?}, '-')
                 else
                   # TODO: remove when ruby1.8 is no longer supported
                   anchor.gsub(%r{[^\w\s\-]}, '').gsub(%r{\s+(\-+\s*)?}, '-')
                 end
               end
               # Returns the javascript tags that are included in the html layout head
               def javascript_heads
-                tags = javascript_include_tag('jquery-1.8.3-ui-1.9.2-ujs-2.0.3', 'application')
+                tags = javascript_include_tag('jquery-1.11.1-ui-1.11.0-ujs-3.1.1', 'application')
                 unless User.current.pref.warn_on_leaving_unsaved == '0'
                   tags << "\n".html_safe + javascript_tag("$(window).load(function(){ warnLeavingUnsaved('#{escape_javascript l(:text_warn_on_leaving_unsaved)}'); });")
                 end
                 tags
               end
               def favicon
                 "<link rel='shortcut icon' href='#{favicon_path}' />".html_safe
               end
               # Returns the path to the favicon
               def favicon_path
                 icon = (current_theme && current_theme.favicon?) ? current_theme.favicon_path : '/favicon.ico'
                 image_path(icon)
               end
               # Returns the full URL to the favicon
               def favicon_url
                 # TODO: use #image_url introduced in Rails4
                 path = favicon_path
                 base = url_for(:controller => 'welcome', :action => 'index', :only_path => false)
                 base.sub(%r{/+$},'') + '/' + path.sub(%r{^/+},'')
               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 deserializing 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/issues/bulk_edit.html.erb +1 -1

             <h2><%= @copy ? l(:button_copy) : l(:label_bulk_edit_selected_issues) %></h2>
             <% if @saved_issues && @unsaved_issues.present? %>
             <div id="errorExplanation">
               <span>
                 <%= l(:notice_failed_to_save_issues,
                     :count => @unsaved_issues.size,
                     :total => @saved_issues.size,
                     :ids => @unsaved_issues.map {|i| "##{i.id}"}.join(', ')) %>
               </span>
               <ul>
               <% bulk_edit_error_messages(@unsaved_issues).each do |message| %>
                 <li><%= message %></li>
               <% end %>
               </ul>
             </div>
             <% end %>
             <ul id="bulk-selection">
             <% @issues.each do |issue| %>
               <%= content_tag 'li', link_to_issue(issue) %>
             <% end %>
             </ul>
             <%= form_tag(bulk_update_issues_path, :id => 'bulk_edit_form') do %>
             <%= @issues.collect {|i| hidden_field_tag('ids[]', i.id)}.join("\n").html_safe %>
             <div class="box tabular">
             <fieldset class="attributes">
             <legend><%= l(:label_change_properties) %></legend>
             <div class="splitcontentleft">
             <% if @allowed_projects.present? %>
             <p>
               <label for="issue_project_id"><%= l(:field_project) %></label>
               <%= select_tag('issue[project_id]',
                              content_tag('option', l(:label_no_change_option), :value => '') +
                                project_tree_options_for_select(@allowed_projects, :selected => @target_project),
                              :onchange => "updateBulkEditFrom('#{escape_javascript url_for(:action => 'bulk_edit', :format => 'js')}')") %>
             </p>
             <% end %>
             <p>
               <label for="issue_tracker_id"><%= l(:field_tracker) %></label>
               <%= select_tag('issue[tracker_id]',
                              content_tag('option', l(:label_no_change_option), :value => '') +
                                options_from_collection_for_select(@trackers, :id, :name, @issue_params[:tracker_id])) %>
             </p>
             <% if @available_statuses.any? %>
             <p>
               <label for='issue_status_id'><%= l(:field_status) %></label>
               <%= select_tag('issue[status_id]',
                              content_tag('option', l(:label_no_change_option), :value => '') +
                                options_from_collection_for_select(@available_statuses, :id, :name, @issue_params[:status_id])) %>
             </p>
             <% end %>
             <% if @safe_attributes.include?('priority_id') -%>
             <p>
               <label for='issue_priority_id'><%= l(:field_priority) %></label>
               <%= select_tag('issue[priority_id]',
                              content_tag('option', l(:label_no_change_option), :value => '') +
                                options_from_collection_for_select(IssuePriority.active, :id, :name, @issue_params[:priority_id])) %>
             </p>
             <% end %>
             <% if @safe_attributes.include?('assigned_to_id') -%>
             <p>
               <label for='issue_assigned_to_id'><%= l(:field_assigned_to) %></label>
               <%= select_tag('issue[assigned_to_id]',
                              content_tag('option', l(:label_no_change_option), :value => '') +
                                content_tag('option', l(:label_nobody), :value => 'none', :selected => (@issue_params[:assigned_to_id] == 'none')) +
                                principals_options_for_select(@assignables, @issue_params[:assigned_to_id])) %>
             </p>
             <% end %>
             <% if @safe_attributes.include?('category_id') -%>
             <p>
               <label for='issue_category_id'><%= l(:field_category) %></label>
               <%= select_tag('issue[category_id]', content_tag('option', l(:label_no_change_option), :value => '') +
                                             content_tag('option', l(:label_none), :value => 'none', :selected => (@issue_params[:category_id] == 'none')) +
                                             options_from_collection_for_select(@categories, :id, :name, @issue_params[:category_id])) %>
             </p>
             <% end %>
             <% if @safe_attributes.include?('fixed_version_id') -%>
             <p>
               <label for='issue_fixed_version_id'><%= l(:field_fixed_version) %></label>
               <%= select_tag('issue[fixed_version_id]', content_tag('option', l(:label_no_change_option), :value => '') +
                                                content_tag('option', l(:label_none), :value => 'none', :selected => (@issue_params[:fixed_version_id] == 'none')) +
                                                version_options_for_select(@versions.sort, @issue_params[:fixed_version_id])) %>
             </p>
             <% end %>
             <% @custom_fields.each do |custom_field| %>
               <p>
                 <label><%= h(custom_field.name) %></label>
                 <%= custom_field_tag_for_bulk_edit('issue', custom_field, @issues, @issue_params[:custom_field_values][custom_field.id.to_s]) %>
               </p>
             <% end %>
             <% if @copy && @attachments_present %>
             <%= hidden_field_tag 'copy_attachments', '0' %>
             <p>
               <label for='copy_attachments'><%= l(:label_copy_attachments) %></label>
               <%= check_box_tag 'copy_attachments', '1', params[:copy_attachments] != '0' %>
             </p>
             <% end %>
             <% if @copy && @subtasks_present %>
             <%= hidden_field_tag 'copy_subtasks', '0' %>
             <p>
               <label for='copy_subtasks'><%= l(:label_copy_subtasks) %></label>
               <%= check_box_tag 'copy_subtasks', '1', params[:copy_subtasks] != '0' %>
             </p>
             <% end %>
             <%= call_hook(:view_issues_bulk_edit_details_bottom, { :issues => @issues }) %>
             </div>
             <div class="splitcontentright">
             <% if @safe_attributes.include?('is_private') %>
             <p>
               <label for='issue_is_private'><%= l(:field_is_private) %></label>
               <%= select_tag('issue[is_private]', content_tag('option', l(:label_no_change_option), :value => '') +
                                             content_tag('option', l(:general_text_Yes), :value => '1', :selected => (@issue_params[:is_private] == '1')) +
                                             content_tag('option', l(:general_text_No), :value => '0', :selected => (@issue_params[:is_private] == '0'))) %>
             </p>
             <% end %>
             <% if @safe_attributes.include?('parent_issue_id') && @project %>
             <p>
               <label for='issue_parent_issue_id'><%= l(:field_parent_issue) %></label>
               <%= text_field_tag 'issue[parent_issue_id]', '', :size => 10, :value => @issue_params[:parent_issue_id] %>
               <label class="inline"><%= check_box_tag 'issue[parent_issue_id]', 'none', (@issue_params[:parent_issue_id] == 'none'), :id => nil, :data => {:disables => '#issue_parent_issue_id'} %><%= l(:button_clear) %></label>
             </p>
             <%= javascript_tag "observeAutocompleteField('issue_parent_issue_id', '#{escape_javascript auto_complete_issues_path(:project_id => @project)}')" %>
             <% end %>
             <% if @safe_attributes.include?('start_date') %>
             <p>
               <label for='issue_start_date'><%= l(:field_start_date) %></label>
               <%= text_field_tag 'issue[start_date]', '', :value => @issue_params[:start_date], :size => 10 %><%= calendar_for('issue_start_date') %>
               <label class="inline"><%= check_box_tag 'issue[start_date]', 'none', (@issue_params[:start_date] == 'none'), :id => nil, :data => {:disables => '#issue_start_date'} %><%= l(:button_clear) %></label>
             </p>
             <% end %>
             <% if @safe_attributes.include?('due_date') %>
             <p>
               <label for='issue_due_date'><%= l(:field_due_date) %></label>
               <%= text_field_tag 'issue[due_date]', '', :value => @issue_params[:due_date], :size => 10 %><%= calendar_for('issue_due_date') %>
               <label class="inline"><%= check_box_tag 'issue[due_date]', 'none', (@issue_params[:due_date] == 'none'), :id => nil, :data => {:disables => '#issue_due_date'} %><%= l(:button_clear) %></label>
             </p>
             <% end %>
             <% if @safe_attributes.include?('done_ratio') && Issue.use_field_for_done_ratio? %>
             <p>
               <label for='issue_done_ratio'><%= l(:field_done_ratio) %></label>
               <%= select_tag 'issue[done_ratio]', options_for_select([[l(:label_no_change_option), '']] + (0..10).to_a.collect {|r| ["#{r*10} %", r*10] }, @issue_params[:done_ratio]) %>
             </p>
             <% end %>
             </div>
             </fieldset>
             <fieldset>
             <legend><%= l(:field_notes) %></legend>
             <%= text_area_tag 'notes', @notes, :cols => 60, :rows => 10, :class => 'wiki-edit' %>
             <%= wikitoolbar_for 'notes' %>
             </fieldset>
             </div>
             <p>
               <% if @copy %>
                 <%= hidden_field_tag 'copy', '1' %>
                 <%= submit_tag l(:button_copy) %>
                 <%= submit_tag l(:button_copy_and_follow), :name => 'follow' %>
               <% elsif @target_project %>
                 <%= submit_tag l(:button_move) %>
                 <%= submit_tag l(:button_move_and_follow), :name => 'follow' %>
               <% else %>
                 <%= submit_tag l(:button_submit) %>
               <% end %>
             </p>
             <% end %>
             <%= javascript_tag do %>
             $(window).load(function(){
               $(document).on('change', 'input[data-disables]', function(){
-                if ($(this).attr('checked')){
+                if ($(this).prop('checked')){
                   $($(this).data('disables')).attr('disabled', true).val('');
                 } else {
                   $($(this).data('disables')).attr('disabled', false);
                 }
               });
             });
             $(document).ready(function(){
               $('input[data-disables]').trigger('change');
             });
             <% end %>

app/views/journals/new.js.erb +1 -1

             $('#issue_notes').val("<%= raw escape_javascript(@content) %>");
             <%
               # when quoting a private journal, check the private checkbox
               if @journal && @journal.private_notes?
             %>
-            $('#issue_private_notes').attr('checked', true);
+            $('#issue_private_notes').prop('checked', true);
             <% end %>
             showAndScrollTo("update", "notes");
             $('#notes').scrollTop = $('#notes').scrollHeight - $('#notes').clientHeight;

app/views/layouts/base.html.erb +1 -1

             <!DOCTYPE html>
             <html lang="<%= current_language %>">
             <head>
             <meta charset="utf-8" />
             <title><%=h html_title %></title>
             <meta name="description" content="<%= Redmine::Info.app_name %>" />
             <meta name="keywords" content="issue,bug,tracker" />
             <%= csrf_meta_tag %>
             <%= favicon %>
-            <%= stylesheet_link_tag 'jquery/jquery-ui-1.9.2', 'application', :media => 'all' %>
+            <%= stylesheet_link_tag 'jquery/jquery-ui-1.11.0', 'application', :media => 'all' %>
             <%= stylesheet_link_tag 'rtl', :media => 'all' if l(:direction) == 'rtl' %>
             <%= javascript_heads %>
             <%= heads_for_theme %>
             <%= call_hook :view_layouts_base_html_head %>
             <!-- page specific tags -->
             <%= yield :header_tags -%>
             </head>
             <body class="<%=h body_css_classes %>">
             <div id="wrapper">
             <div id="wrapper2">
             <div id="wrapper3">
             <div id="top-menu">
                 <div id="account">
                     <%= render_menu :account_menu -%>
                 </div>
                 <%= content_tag('div', "#{l(:label_logged_as)} #{link_to_user(User.current, :format => :username)}".html_safe, :id => 'loggedas') if User.current.logged? %>
                 <%= render_menu :top_menu if User.current.logged? || !Setting.login_required? -%>
             </div>
             <div id="header">
                 <% if User.current.logged? || !Setting.login_required? %>
                 <div id="quick-search">
                     <%= form_tag({:controller => 'search', :action => 'index', :id => @project}, :method => :get ) do %>
                     <%= hidden_field_tag(controller.default_search_scope, 1, :id => nil) if controller.default_search_scope %>
                     <label for='q'>
                       <%= link_to l(:label_search), {:controller => 'search', :action => 'index', :id => @project}, :accesskey => accesskey(:search) %>:
                     </label>
                     <%= text_field_tag 'q', @question, :size => 20, :class => 'small', :accesskey => accesskey(:quick_search) %>
                     <% end %>
                     <%= render_project_jump_box %>
                 </div>
                 <% end %>
                 <h1><%= page_header_title %></h1>
                 <% if display_main_menu?(@project) %>
                 <div id="main-menu">
                     <%= render_main_menu(@project) %>
                 </div>
                 <% end %>
             </div>
             <div id="main" class="<%= sidebar_content? ? '' : 'nosidebar' %>">
                 <div id="sidebar">
                     <%= yield :sidebar %>
                     <%= view_layouts_base_sidebar_hook_response %>
                 </div>
                 <div id="content">
                     <%= render_flash_messages %>
                     <%= yield %>
                     <%= call_hook :view_layouts_base_content %>
                     <div style="clear:both;"></div>
                 </div>
             </div>
             </div>
             <div id="ajax-indicator" style="display:none;"><span><%= l(:label_loading) %></span></div>
             <div id="ajax-modal" style="display:none;"></div>
             <div id="footer">
               <div class="bgl"><div class="bgr">
                 Powered by <%= link_to Redmine::Info.app_name, Redmine::Info.url %> &copy; 2006-2014 Jean-Philippe Lang
               </div></div>
             </div>
             </div>
             </div>
             <%= call_hook :view_layouts_base_body_bottom %>
             </body>
             </html>

app/views/projects/_form.html.erb +1 -1

             <%= error_messages_for 'project' %>
             <div class="box tabular">
             <!--[form:project]-->
             <p><%= f.text_field :name, :required => true, :size => 60 %></p>
             <p><%= f.text_area :description, :rows => 8, :class => 'wiki-edit' %></p>
             <p><%= f.text_field :identifier, :required => true, :size => 60, :disabled => @project.identifier_frozen?, :maxlength => Project::IDENTIFIER_MAX_LENGTH %>
             <% unless @project.identifier_frozen? %>
               <em class="info"><%= l(:text_length_between, :min => 1, :max => Project::IDENTIFIER_MAX_LENGTH) %> <%= l(:text_project_identifier_info).html_safe %></em>
             <% end %></p>
             <p><%= f.text_field :homepage, :size => 60 %></p>
             <p><%= f.check_box :is_public %></p>
             <% unless @project.allowed_parents.compact.empty? %>
                 <p><%= label(:project, :parent_id, l(:field_parent)) %><%= parent_project_select_tag(@project) %></p>
             <% end %>
             <% if @project.safe_attribute? 'inherit_members' %>
             <p><%= f.check_box :inherit_members %></p>
             <% end %>
             <%= wikitoolbar_for 'project_description' %>
             <% @project.custom_field_values.each do |value| %>
               <p><%= custom_field_tag_with_label :project, value %></p>
             <% end %>
             <%= call_hook(:view_projects_form, :project => @project, :form => f) %>
             </div>
             <% if @project.new_record? %>
             <fieldset class="box tabular"><legend><%= l(:label_module_plural) %></legend>
             <% Redmine::AccessControl.available_project_modules.each do |m| %>
                 <label class="floating">
                 <%= check_box_tag 'project[enabled_module_names][]', m, @project.module_enabled?(m), :id => "project_enabled_module_names_#{m}" %>
                 <%= l_or_humanize(m, :prefix => "project_module_") %>
                 </label>
             <% end %>
             <%= hidden_field_tag 'project[enabled_module_names][]', '' %>
             </fieldset>
             <% end %>
             <% if @project.new_record? || @project.module_enabled?('issue_tracking') %>
             <% unless @trackers.empty? %>
             <fieldset class="box tabular" id="project_trackers"><legend><%=l(:label_tracker_plural)%></legend>
             <% @trackers.each do |tracker| %>
                 <label class="floating">
                 <%= check_box_tag 'project[tracker_ids][]', tracker.id, @project.trackers.include?(tracker), :id => nil %>
                 <%=h tracker %>
                 </label>
             <% end %>
             <%= hidden_field_tag 'project[tracker_ids][]', '' %>
             </fieldset>
             <% end %>
             <% unless @issue_custom_fields.empty? %>
             <fieldset class="box tabular" id="project_issue_custom_fields"><legend><%=l(:label_custom_field_plural)%></legend>
             <% @issue_custom_fields.each do |custom_field| %>
                 <label class="floating">
               <%= check_box_tag 'project[issue_custom_field_ids][]', custom_field.id, (@project.all_issue_custom_fields.include? custom_field),
                     :disabled => (custom_field.is_for_all? ? "disabled" : nil),
                     :id => nil %>
               <%=h custom_field.name %>
               </label>
             <% end %>
             <%= hidden_field_tag 'project[issue_custom_field_ids][]', '' %>
             </fieldset>
             <% end %>
             <% end %>
             <!--[eoform:project]-->
             <% unless @project.identifier_frozen? %>
               <% content_for :header_tags do %>
                 <%= javascript_include_tag 'project_identifier' %>
               <% end %>
             <% end %>
             <% if !User.current.admin? && @project.inherit_members? && @project.parent && User.current.member_of?(@project.parent) %>
               <%= javascript_tag do %>
                 $(document).ready(function() {
                   $("#project_inherit_members").change(function(){
                     if (!$(this).is(':checked')) {
                       if (!confirm("<%= escape_javascript(l(:text_own_membership_delete_confirmation)) %>")) {
                         $("#project_inherit_members").attr("checked", true);
                       }
                     }
                   });
                 });
               <% end %>
             <% end %>
             <%= javascript_tag do %>
             $(document).ready(function() {
               $('#project_enabled_module_names_issue_tracking').on('change', function(){
-                if ($(this).attr('checked')){
+                if ($(this).prop('checked')){
                   $('#project_trackers, #project_issue_custom_fields').show();
                 } else {
                   $('#project_trackers, #project_issue_custom_fields').hide();
                 }
               }).trigger('change');
             });
             <% end %>

app/views/repositories/_revisions.html.erb +2 -2

             <% show_revision_graph = ( @repository.supports_revision_graph? && path.blank? ) %>
             <%= if show_revision_graph && revisions && revisions.any?
                 indexed_commits, graph_space = index_commits(revisions, @repository.branches) do |scmid|
                                          url_for(
                                            :controller => 'repositories',
                                            :action => 'revision',
                                            :id => project,
                                            :repository_id => @repository.identifier_param,
                                            :rev => scmid)
                                      end
                 render :partial => 'revision_graph',
                      :locals => {
                         :commits => indexed_commits,
                         :space => graph_space
                     }
             end %>
             <%= form_tag(
                   {:controller => 'repositories', :action => 'diff', :id => project,
                    :repository_id => @repository.identifier_param, :path => to_path_param(path)},
                   :method => :get
                  ) do %>
             <table class="list changesets">
             <thead><tr>
             <th>#</th>
             <th></th>
             <th></th>
             <th><%= l(:label_date) %></th>
             <th><%= l(:field_author) %></th>
             <th><%= l(:field_comments) %></th>
             </tr></thead>
             <tbody>
             <% show_diff = revisions.size > 1 %>
             <% line_num = 1 %>
             <% revisions.each do |changeset| %>
             <tr class="changeset <%= cycle 'odd', 'even' %>">
             <% id_style = (show_revision_graph ? "padding-left:#{(graph_space + 1) * 20}px" : nil) %>
             <%= content_tag(:td, :class => 'id', :style => id_style) do %>
               <%= link_to_revision(changeset, @repository) %>
             <% end %>
-            <td class="checkbox"><%= radio_button_tag('rev', changeset.identifier, (line_num==1), :id => "cb-#{line_num}", :onclick => "$('#cbto-#{line_num+1}').attr('checked',true);") if show_diff && (line_num < revisions.size) %></td>
+            <td class="checkbox"><%= radio_button_tag('rev', changeset.identifier, (line_num==1), :id => "cb-#{line_num}", :onclick => "$('#cbto-#{line_num+1}').prop('checked',true);") if show_diff && (line_num < revisions.size) %></td>
-            <td class="checkbox"><%= radio_button_tag('rev_to', changeset.identifier, (line_num==2), :id => "cbto-#{line_num}", :onclick => "if ($('#cb-#{line_num}').attr('checked')) {$('#cb-#{line_num-1}').attr('checked',true);}") if show_diff && (line_num > 1) %></td>
+            <td class="checkbox"><%= radio_button_tag('rev_to', changeset.identifier, (line_num==2), :id => "cbto-#{line_num}", :onclick => "if ($('#cb-#{line_num}').prop('checked')) {$('#cb-#{line_num-1}').prop('checked',true);}") if show_diff && (line_num > 1) %></td>
             <td class="committed_on"><%= format_time(changeset.committed_on) %></td>
             <td class="author"><%= changeset.author.to_s.truncate(30) %></td>
             <td class="comments"><%= textilizable(truncate_at_line_break(changeset.comments)) %></td>
             </tr>
             <% line_num += 1 %>
             <% end %>
             </tbody>
             </table>
             <%= submit_tag(l(:label_view_diff), :name => nil) if show_diff %>
             <% end %>

app/views/search/index.html.erb +2 -2

             <h2><%= l(:label_search) %></h2>
             <div class="box">
             <%= form_tag({}, :method => :get, :id => 'search-form') do %>
             <%= label_tag "search-input", l(:description_search), :class => "hidden-for-sighted" %>
             <p><%= text_field_tag 'q', @question, :size => 60, :id => 'search-input' %>
             <%= project_select_tag %>
             <%= hidden_field_tag 'all_words', '', :id => nil %>
             <label><%= check_box_tag 'all_words', 1, @all_words %> <%= l(:label_all_words) %></label>
             <%= hidden_field_tag 'titles_only', '', :id => nil %>
             <label><%= check_box_tag 'titles_only', 1, @titles_only %> <%= l(:label_search_titles_only) %></label>
             </p>
             <p id="search-types">
             <% @object_types.each do |t| %>
             <label><%= check_box_tag t, 1, @scope.include?(t) %> <%= link_to type_label(t), "#" %></label>
             <% end %>
             </p>
             <p><%= submit_tag l(:button_submit) %></p>
             <% end %>
             </div>
             <% if @results %>
                 <div id="search-results-counts">
                   <%= render_results_by_type(@results_by_type) unless @scope.size == 1 %>
                 </div>
                 <h3><%= l(:label_result_plural) %> (<%= @results_by_type.values.sum %>)</h3>
                 <dl id="search-results">
                   <% @results.each do |e| %>
                     <dt class="<%= e.event_type %>">
                       <%= content_tag('span', h(e.project), :class => 'project') unless @project == e.project %>
                       <%= link_to(highlight_tokens(e.event_title.truncate(255), @tokens), e.event_url) %>
                     </dt>
                     <dd><span class="description"><%= highlight_tokens(e.event_description, @tokens) %></span>
                     <span class="author"><%= format_time(e.event_datetime) %></span></dd>
                   <% end %>
                 </dl>
             <% end %>
             <p class="pagination">
             <% if @pagination_previous_date %>
             <%= link_to_content_update("\xc2\xab " + l(:label_previous),
                   params.merge(:previous => 1,
                                :offset => @pagination_previous_date.strftime("%Y%m%d%H%M%S"))) %>&nbsp;
             <% end %>
             <% if @pagination_next_date %>
             <%= link_to_content_update(l(:label_next) + " \xc2\xbb",
                   params.merge(:previous => nil,
                                :offset => @pagination_next_date.strftime("%Y%m%d%H%M%S"))) %>
             <% end %>
             </p>
             <% html_title(l(:label_search)) -%>
             <%= javascript_tag do %>
             $("#search-types a").click(function(e){
               e.preventDefault();
-              $("#search-types input[type=checkbox]").attr('checked', false);
+              $("#search-types input[type=checkbox]").prop('checked', false);
-              $(this).siblings("input[type=checkbox]").attr('checked', true);
+              $(this).siblings("input[type=checkbox]").prop('checked', true);
               if ($("#search-input").val() != "") {
                 $("#search-form").submit();
               }
             });
             <% end %>

app/views/wiki/destroy.html.erb +1 -1

             <%= wiki_page_breadcrumb(@page) %>
             <h2><%=h @page.pretty_title %></h2>
             <%= form_tag({}, :method => :delete) do %>
             <div class="box">
             <p><strong><%= l(:text_wiki_page_destroy_question, :descendants => @descendants_count) %></strong></p>
             <p><label><%= radio_button_tag 'todo', 'nullify', true %> <%= l(:text_wiki_page_nullify_children) %></label><br />
             <label><%= radio_button_tag 'todo', 'destroy', false %> <%= l(:text_wiki_page_destroy_children) %></label>
             <% if @reassignable_to.any? %>
             <br />
             <label><%= radio_button_tag 'todo', 'reassign', false %> <%= l(:text_wiki_page_reassign_children) %></label>:
             <%= label_tag "reassign_to_id", l(:description_wiki_subpages_reassign), :class => "hidden-for-sighted" %>
             <%= select_tag 'reassign_to_id', wiki_page_options_for_select(@reassignable_to),
-                                             :onclick => "$('#todo_reassign').attr('checked', true);" %>
+                                             :onclick => "$('#todo_reassign').prop('checked', true);" %>
             <% end %>
             </p>
             </div>
             <%= submit_tag l(:button_apply) %>
             <%= link_to l(:button_cancel), :controller => 'wiki', :action => 'show', :project_id => @project, :id => @page.title %>
             <% end %>

app/views/wiki/history.html.erb +1 -1

             <%= wiki_page_breadcrumb(@page) %>
             <%= title [@page.pretty_title, project_wiki_page_path(@page.project, @page.title, :version => nil)], l(:label_history) %>
             <%= form_tag({:controller => 'wiki', :action => 'diff',
                           :project_id => @page.project, :id => @page.title},
                           :method => :get) do %>
             <table class="list wiki-page-versions">
             <thead><tr>
                 <th>#</th>
                 <th></th>
                 <th></th>
                 <th><%= l(:field_updated_on) %></th>
                 <th><%= l(:field_author) %></th>
                 <th><%= l(:field_comments) %></th>
                 <th></th>
             </tr></thead>
             <tbody>
             <% show_diff = @versions.size > 1 %>
             <% line_num = 1 %>
             <% @versions.each do |ver| %>
             <tr class="wiki-page-version <%= cycle("odd", "even") %>">
                 <td class="id"><%= link_to h(ver.version), :action => 'show', :id => @page.title, :project_id => @page.project, :version => ver.version %></td>
-                <td class="checkbox"><%= radio_button_tag('version', ver.version, (line_num==1), :id => "cb-#{line_num}", :onclick => "$('#cbto-#{line_num+1}').attr('checked', true);") if show_diff && (line_num < @versions.size) %></td>
+                <td class="checkbox"><%= radio_button_tag('version', ver.version, (line_num==1), :id => "cb-#{line_num}", :onclick => "$('#cbto-#{line_num+1}').prop('checked', true);") if show_diff && (line_num < @versions.size) %></td>
                 <td class="checkbox"><%= radio_button_tag('version_from', ver.version, (line_num==2), :id => "cbto-#{line_num}") if show_diff && (line_num > 1) %></td>
                 <td class="updated_on"><%= format_time(ver.updated_on) %></td>
                 <td class="author"><%= link_to_user ver.author %></td>
                 <td class="comments"><%=h ver.comments %></td>
                 <td class="buttons">
                   <%= link_to l(:button_annotate), :action => 'annotate', :id => @page.title, :version => ver.version %>
                   <%= delete_link wiki_page_path(@page, :version => ver.version) if User.current.allowed_to?(:delete_wiki_pages, @page.project) && @version_count > 1 %>
                 </td>
             </tr>
             <% line_num += 1 %>
             <% end %>
             </tbody>
             </table>
             <%= submit_tag l(:label_view_diff), :class => 'small' if show_diff %>
             <span class="pagination"><%= pagination_links_full @version_pages, @version_count %></span>
             <% end %>

public/javascripts/application.js +5 -5

             /* Redmine - project management software
                Copyright (C) 2006-2014  Jean-Philippe Lang */
             function checkAll(id, checked) {
-              $('#'+id).find('input[type=checkbox]:enabled').attr('checked', checked);
+              $('#'+id).find('input[type=checkbox]:enabled').prop('checked', checked);
             }
             function toggleCheckboxesBySelector(selector) {
               var all_checked = true;
               $(selector).each(function(index) {
                 if (!$(this).is(':checked')) { all_checked = false; }
               });
-              $(selector).attr('checked', !all_checked);
+              $(selector).prop('checked', !all_checked);
             }
             function showAndScrollTo(id, focus) {
               $('#'+id).show();
               if (focus !== null) {
                 $('#'+focus).focus();
               }
               $('html, body').animate({scrollTop: $('#'+id).offset().top}, 100);
             }
             function toggleRowGroup(el) {
               var tr = $(el).parents('tr').first();
               var n = tr.next();
               tr.toggleClass('open');
               while (n.length && !n.hasClass('group')) {
                 n.toggle();
                 n = n.next('tr');
               }
             }
             function collapseAllRowGroups(el) {
               var tbody = $(el).parents('tbody').first();
               tbody.children('tr').each(function(index) {
                 if ($(this).hasClass('group')) {
                   $(this).removeClass('open');
                 } else {
                   $(this).hide();
                 }
               });
             }
             function expandAllRowGroups(el) {
               var tbody = $(el).parents('tbody').first();
               tbody.children('tr').each(function(index) {
                 if ($(this).hasClass('group')) {
                   $(this).addClass('open');
                 } else {
                   $(this).show();
                 }
               });
             }
             function toggleAllRowGroups(el) {
               var tr = $(el).parents('tr').first();
               if (tr.hasClass('open')) {
                 collapseAllRowGroups(el);
               } else {
                 expandAllRowGroups(el);
               }
             }
             function toggleFieldset(el) {
               var fieldset = $(el).parents('fieldset').first();
               fieldset.toggleClass('collapsed');
               fieldset.children('div').toggle();
             }
             function hideFieldset(el) {
               var fieldset = $(el).parents('fieldset').first();
               fieldset.toggleClass('collapsed');
               fieldset.children('div').hide();
             }
             function initFilters() {
               $('#add_filter_select').change(function() {
                 addFilter($(this).val(), '', []);
               });
               $('#filters-table td.field input[type=checkbox]').each(function() {
                 toggleFilter($(this).val());
               });
               $('#filters-table').on('click', 'td.field input[type=checkbox]', function() {
                 toggleFilter($(this).val());
               });
               $('#filters-table').on('click', '.toggle-multiselect', function() {
                 toggleMultiSelect($(this).siblings('select'));
               });
               $('#filters-table').on('keypress', 'input[type=text]', function(e) {
                 if (e.keyCode == 13) submit_query_form("query_form");
               });
             }
             function addFilter(field, operator, values) {
               var fieldId = field.replace('.', '_');
               var tr = $('#tr_'+fieldId);
               if (tr.length > 0) {
                 tr.show();
               } else {
                 buildFilterRow(field, operator, values);
               }
-              $('#cb_'+fieldId).attr('checked', true);
+              $('#cb_'+fieldId).prop('checked', true);
               toggleFilter(field);
               $('#add_filter_select').val('').children('option').each(function() {
                 if ($(this).attr('value') == field) {
                   $(this).attr('disabled', true);
                 }
               });
             }
             function buildFilterRow(field, operator, values) {
               var fieldId = field.replace('.', '_');
               var filterTable = $("#filters-table");
               var filterOptions = availableFilters[field];
               if (!filterOptions) return;
               var operators = operatorByType[filterOptions['type']];
               var filterValues = filterOptions['values'];
               var i, select;
               var tr = $('<tr class="filter">').attr('id', 'tr_'+fieldId).html(
                 '<td class="field"><input checked="checked" id="cb_'+fieldId+'" name="f[]" value="'+field+'" type="checkbox"><label for="cb_'+fieldId+'"> '+filterOptions['name']+'</label></td>' +
                 '<td class="operator"><select id="operators_'+fieldId+'" name="op['+field+']"></td>' +
                 '<td class="values"></td>'
               );
               filterTable.append(tr);
               select = tr.find('td.operator select');
               for (i = 0; i < operators.length; i++) {
                 var option = $('<option>').val(operators[i]).text(operatorLabels[operators[i]]);
                 if (operators[i] == operator) { option.attr('selected', true); }
                 select.append(option);
               }
               select.change(function(){ toggleOperator(field); });
               switch (filterOptions['type']) {
               case "list":
               case "list_optional":
               case "list_status":
               case "list_subprojects":
                 tr.find('td.values').append(
                   '<span style="display:none;"><select class="value" id="values_'+fieldId+'_1" name="v['+field+'][]"></select>' +
                   ' <span class="toggle-multiselect">&nbsp;</span></span>'
                 );
                 select = tr.find('td.values select');
                 if (values.length > 1) { select.attr('multiple', true); }
                 for (i = 0; i < filterValues.length; i++) {
                   var filterValue = filterValues[i];
                   var option = $('<option>');
                   if ($.isArray(filterValue)) {
                     option.val(filterValue[1]).text(filterValue[0]);
                     if ($.inArray(filterValue[1], values) > -1) {option.attr('selected', true);}
                   } else {
                     option.val(filterValue).text(filterValue);
                     if ($.inArray(filterValue, values) > -1) {option.attr('selected', true);}
                   }
                   select.append(option);
                 }
                 break;
               case "date":
               case "date_past":
                 tr.find('td.values').append(
                   '<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_1" size="10" class="value date_value" /></span>' +
                   ' <span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_2" size="10" class="value date_value" /></span>' +
                   ' <span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'" size="3" class="value" /> '+labelDayPlural+'</span>'
                 );
                 $('#values_'+fieldId+'_1').val(values[0]).datepicker(datepickerOptions);
                 $('#values_'+fieldId+'_2').val(values[1]).datepicker(datepickerOptions);
                 $('#values_'+fieldId).val(values[0]);
                 break;
               case "string":
               case "text":
                 tr.find('td.values').append(
                   '<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'" size="30" class="value" /></span>'
                 );
                 $('#values_'+fieldId).val(values[0]);
                 break;
               case "relation":
                 tr.find('td.values').append(
                   '<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'" size="6" class="value" /></span>' +
                   '<span style="display:none;"><select class="value" name="v['+field+'][]" id="values_'+fieldId+'_1"></select></span>'
                 );
                 $('#values_'+fieldId).val(values[0]);
                 select = tr.find('td.values select');
                 for (i = 0; i < allProjects.length; i++) {
                   var filterValue = allProjects[i];
                   var option = $('<option>');
                   option.val(filterValue[1]).text(filterValue[0]);
                   if (values[0] == filterValue[1]) { option.attr('selected', true); }
                   select.append(option);
                 }
               case "integer":
               case "float":
                 tr.find('td.values').append(
                   '<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_1" size="6" class="value" /></span>' +
                   ' <span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_2" size="6" class="value" /></span>'
                 );
                 $('#values_'+fieldId+'_1').val(values[0]);
                 $('#values_'+fieldId+'_2').val(values[1]);
                 break;
               }
             }
             function toggleFilter(field) {
               var fieldId = field.replace('.', '_');
               if ($('#cb_' + fieldId).is(':checked')) {
                 $("#operators_" + fieldId).show().removeAttr('disabled');
                 toggleOperator(field);
               } else {
                 $("#operators_" + fieldId).hide().attr('disabled', true);
                 enableValues(field, []);
               }
             }
             function enableValues(field, indexes) {
               var fieldId = field.replace('.', '_');
               $('#tr_'+fieldId+' td.values .value').each(function(index) {
                 if ($.inArray(index, indexes) >= 0) {
                   $(this).removeAttr('disabled');
                   $(this).parents('span').first().show();
                 } else {
                   $(this).val('');
                   $(this).attr('disabled', true);
                   $(this).parents('span').first().hide();
                 }
                 if ($(this).hasClass('group')) {
                   $(this).addClass('open');
                 } else {
                   $(this).show();
                 }
               });
             }
             function toggleOperator(field) {
               var fieldId = field.replace('.', '_');
               var operator = $("#operators_" + fieldId);
               switch (operator.val()) {
                 case "!*":
                 case "*":
                 case "t":
                 case "ld":
                 case "w":
                 case "lw":
                 case "l2w":
                 case "m":
                 case "lm":
                 case "y":
                 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-":
                 case "><t-":
                 case "t-":
                   enableValues(field, [2]);
                   break;
                 case "=p":
                 case "=!p":
                 case "!p":
                   enableValues(field, [1]);
                   break;
                 default:
                   enableValues(field, [0]);
                   break;
               }
             }
             function toggleMultiSelect(el) {
               if (el.attr('multiple')) {
                 el.removeAttr('multiple');
                 el.attr('size', 1);
               } else {
                 el.attr('multiple', true);
                 if (el.children().length > 10)
                   el.attr('size', 10);
                 else
                   el.attr('size', 4);
               }
             }
             function submit_query_form(id) {
               selectAllOptions("selected_columns");
               $('#'+id).submit();
             }
             function showTab(name, url) {
               $('div#content .tab-content').hide();
               $('div.tabs a').removeClass('selected');
               $('#tab-content-' + name).show();
               $('#tab-' + name).addClass('selected');
               //replaces current URL with the "href" attribute of the current link
               //(only triggered if supported by browser)
               if ("replaceState" in window.history) {
                 window.history.replaceState(null, document.title, url);
               }
               return false;
             }
             function moveTabRight(el) {
               var lis = $(el).parents('div.tabs').first().find('ul').children();
               var tabsWidth = 0;
               var i = 0;
               lis.each(function() {
                 if ($(this).is(':visible')) {
                   tabsWidth += $(this).width() + 6;
                 }
               });
               if (tabsWidth < $(el).parents('div.tabs').first().width() - 60) { return; }
               while (i<lis.length && !lis.eq(i).is(':visible')) { i++; }
               lis.eq(i).hide();
             }
             function moveTabLeft(el) {
               var lis = $(el).parents('div.tabs').first().find('ul').children();
               var i = 0;
               while (i < lis.length && !lis.eq(i).is(':visible')) { i++; }
               if (i > 0) {
                 lis.eq(i-1).show();
               }
             }
             function displayTabsButtons() {
               var lis;
               var tabsWidth = 0;
               var el;
               $('div.tabs').each(function() {
                 el = $(this);
                 lis = el.find('ul').children();
                 lis.each(function(){
                   if ($(this).is(':visible')) {
                     tabsWidth += $(this).width() + 6;
                   }
                 });
                 if ((tabsWidth < el.width() - 60) && (lis.first().is(':visible'))) {
                   el.find('div.tabs-buttons').hide();
                 } else {
                   el.find('div.tabs-buttons').show();
                 }
               });
             }
             function setPredecessorFieldsVisibility() {
               var relationType = $('#relation_relation_type');
               if (relationType.val() == "precedes" || relationType.val() == "follows") {
                 $('#predecessor_fields').show();
               } else {
                 $('#predecessor_fields').hide();
               }
             }
             function showModal(id, width) {
               var el = $('#'+id).first();
               if (el.length === 0 || el.is(':visible')) {return;}
               var title = el.find('h3.title').text();
               el.dialog({
                 width: width,
                 modal: true,
                 resizable: false,
                 dialogClass: 'modal',
                 title: title
               });
               el.find("input[type=text], input[type=submit]").first().focus();
             }
             function hideModal(el) {
               var modal;
               if (el) {
                 modal = $(el).parents('.ui-dialog-content');
               } else {
                 modal = $('#ajax-modal');
               }
               modal.dialog("close");
             }
             function submitPreview(url, form, target) {
               $.ajax({
                 url: url,
                 type: 'post',
                 data: $('#'+form).serialize(),
                 success: function(data){
                   $('#'+target).html(data);
                 }
               });
             }
             function collapseScmEntry(id) {
               $('.'+id).each(function() {
                 if ($(this).hasClass('open')) {
                   collapseScmEntry($(this).attr('id'));
                 }
                 $(this).hide();
               });
               $('#'+id).removeClass('open');
             }
             function expandScmEntry(id) {
               $('.'+id).each(function() {
                 $(this).show();
                 if ($(this).hasClass('loaded') && !$(this).hasClass('collapsed')) {
                   expandScmEntry($(this).attr('id'));
                 }
               });
               $('#'+id).addClass('open');
             }
             function scmEntryClick(id, url) {
                 var el = $('#'+id);
                 if (el.hasClass('open')) {
                     collapseScmEntry(id);
                     el.addClass('collapsed');
                     return false;
                 } else if (el.hasClass('loaded')) {
                     expandScmEntry(id);
                     el.removeClass('collapsed');
                     return false;
                 }
                 if (el.hasClass('loading')) {
                     return false;
                 }
                 el.addClass('loading');
                 $.ajax({
                   url: url,
                   success: function(data) {
                     el.after(data);
                     el.addClass('open').addClass('loaded').removeClass('loading');
                   }
                 });
                 return true;
             }
             function randomKey(size) {
               var chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
               var key = '';
               for (var i = 0; i < size; i++) {
                 key += chars.charAt(Math.floor(Math.random() * chars.length));
               }
               return key;
             }
             function updateIssueFrom(url) {
               $('#all_attributes input, #all_attributes textarea, #all_attributes select').each(function(){
                 $(this).data('valuebeforeupdate', $(this).val());
               });
               $.ajax({
                 url: url,
                 type: 'post',
                 data: $('#issue-form').serialize()
               });
             }
             function replaceIssueFormWith(html){
               var replacement = $(html);
               $('#all_attributes input, #all_attributes textarea, #all_attributes select').each(function(){
                 var object_id = $(this).attr('id');
                 if (object_id && $(this).data('valuebeforeupdate')!=$(this).val()) {
                   replacement.find('#'+object_id).val($(this).val());
                 }
               });
               $('#all_attributes').empty();
               $('#all_attributes').prepend(replacement);
             }
             function updateBulkEditFrom(url) {
               $.ajax({
                 url: url,
                 type: 'post',
                 data: $('#bulk_edit_form').serialize()
               });
             }
             function observeAutocompleteField(fieldId, url, options) {
               $(document).ready(function() {
                 $('#'+fieldId).autocomplete($.extend({
                   source: url,
                   minLength: 2,
                   search: function(){$('#'+fieldId).addClass('ajax-loading');},
                   response: function(){$('#'+fieldId).removeClass('ajax-loading');}
                 }, options));
                 $('#'+fieldId).addClass('autocomplete');
               });
             }
             function observeSearchfield(fieldId, targetId, url) {
               $('#'+fieldId).each(function() {
                 var $this = $(this);
                 $this.addClass('autocomplete');
                 $this.attr('data-value-was', $this.val());
                 var check = function() {
                   var val = $this.val();
                   if ($this.attr('data-value-was') != val){
                     $this.attr('data-value-was', val);
                     $.ajax({
                       url: url,
                       type: 'get',
                       data: {q: $this.val()},
                       success: function(data){ if(targetId) $('#'+targetId).html(data); },
                       beforeSend: function(){ $this.addClass('ajax-loading'); },
                       complete: function(){ $this.removeClass('ajax-loading'); }
                     });
                   }
                 };
                 var reset = function() {
                   if (timer) {
                     clearInterval(timer);
                     timer = setInterval(check, 300);
                   }
                 };
                 var timer = setInterval(check, 300);
                 $this.bind('keyup click mousemove', reset);
               });
             }
             function initMyPageSortable(list, url) {
               $('#list-'+list).sortable({
                 connectWith: '.block-receiver',
                 tolerance: 'pointer',
                 update: function(){
                   $.ajax({
                     url: url,
                     type: 'post',
                     data: {'blocks': $.map($('#list-'+list).children(), function(el){return $(el).attr('id');})}
                   });
                 }
               });
               $("#list-top, #list-left, #list-right").disableSelection();
             }
             var warnLeavingUnsavedMessage;
             function warnLeavingUnsaved(message) {
               warnLeavingUnsavedMessage = message;
               $(document).on('submit', 'form', function(){
                 $('textarea').removeData('changed');
               });
               $(document).on('change', 'textarea', function(){
                 $(this).data('changed', 'changed');
               });
               window.onbeforeunload = function(){
                 var warn = false;
                 $('textarea').blur().each(function(){
                   if ($(this).data('changed')) {
                     warn = true;
                   }
                 });
                 if (warn) {return warnLeavingUnsavedMessage;}
               };
             }
             function setupAjaxIndicator() {
-              $('#ajax-indicator').bind('ajaxSend', function(event, xhr, settings) {
+              $(document).bind('ajaxSend', function(event, xhr, settings) {
                 if ($('.ajax-loading').length === 0 && settings.contentType != 'application/octet-stream') {
                   $('#ajax-indicator').show();
                 }
               });
-              $('#ajax-indicator').bind('ajaxStop', function() {
+              $(document).bind('ajaxStop', function() {
                 $('#ajax-indicator').hide();
               });
             }
             function hideOnLoad() {
               $('.hol').hide();
             }
             function addFormObserversForDoubleSubmit() {
               $('form[method=post]').each(function() {
                 if (!$(this).hasClass('multiple-submit')) {
                   $(this).submit(function(form_submission) {
                     if ($(form_submission.target).attr('data-submitted')) {
                       form_submission.preventDefault();
                     } else {
                       $(form_submission.target).attr('data-submitted', true);
                     }
                   });
                 }
               });
             }
             function defaultFocus(){
               if ($('#content :focus').length == 0) {
                 $('#content input[type=text], #content textarea').first().focus();
               }
             }
             function blockEventPropagation(event) {
               event.stopPropagation();
               event.preventDefault();
             }
             function toggleDisabledOnChange() {
               var checked = $(this).is(':checked');
               $($(this).data('disables')).attr('disabled', checked);
               $($(this).data('enables')).attr('disabled', !checked);
             }
             function toggleDisabledInit() {
               $('input[data-disables], input[data-enables]').each(toggleDisabledOnChange);
             }
             $(document).ready(function(){
               $('#content').on('change', 'input[data-disables], input[data-enables]', toggleDisabledOnChange);
               toggleDisabledInit();
             });
             $(document).ready(setupAjaxIndicator);
             $(document).ready(hideOnLoad);
             $(document).ready(addFormObserversForDoubleSubmit);
             $(document).ready(defaultFocus);

public/javascripts/context_menu.js +5 -5

             var contextMenuObserving;
             var contextMenuUrl;
             function contextMenuRightClick(event) {
               var target = $(event.target);
               if (target.is('a')) {return;}
               var tr = target.parents('tr').first();
               if (!tr.hasClass('hascontextmenu')) {return;}
               event.preventDefault();
               if (!contextMenuIsSelected(tr)) {
                 contextMenuUnselectAll();
                 contextMenuAddSelection(tr);
                 contextMenuSetLastSelected(tr);
               }
               contextMenuShow(event);
             }
             function contextMenuClick(event) {
               var target = $(event.target);
               var lastSelected;
               if (target.is('a') && target.hasClass('submenu')) {
                 event.preventDefault();
                 return;
               }
               contextMenuHide();
               if (target.is('a') || target.is('img')) { return; }
               if (event.which == 1 || (navigator.appVersion.match(/\bMSIE\b/))) {
                 var tr = target.parents('tr').first();
                 if (tr.length && tr.hasClass('hascontextmenu')) {
                   // a row was clicked, check if the click was on checkbox
                   if (target.is('input')) {
                     // a checkbox may be clicked
-                    if (target.attr('checked')) {
+                    if (target.prop('checked')) {
                       tr.addClass('context-menu-selection');
                     } else {
                       tr.removeClass('context-menu-selection');
                     }
                   } else {
                     if (event.ctrlKey || event.metaKey) {
                       contextMenuToggleSelection(tr);
                     } else if (event.shiftKey) {
                       lastSelected = contextMenuLastSelected();
                       if (lastSelected.length) {
                         var toggling = false;
                         $('.hascontextmenu').each(function(){
                           if (toggling || $(this).is(tr)) {
                             contextMenuAddSelection($(this));
                           }
                           if ($(this).is(tr) || $(this).is(lastSelected)) {
                             toggling = !toggling;
                           }
                         });
                       } else {
                         contextMenuAddSelection(tr);
                       }
                     } else {
                       contextMenuUnselectAll();
                       contextMenuAddSelection(tr);
                     }
                     contextMenuSetLastSelected(tr);
                   }
                 } else {
                   // click is outside the rows
                   if (target.is('a') && (target.hasClass('disabled') || target.hasClass('submenu'))) {
                     event.preventDefault();
                   } else {
                     contextMenuUnselectAll();
                   }
                 }
               }
             }
             function contextMenuCreate() {
               if ($('#context-menu').length < 1) {
                 var menu = document.createElement("div");
                 menu.setAttribute("id", "context-menu");
                 menu.setAttribute("style", "display:none;");
                 document.getElementById("content").appendChild(menu);
               }
             }
             function contextMenuShow(event) {
               var mouse_x = event.pageX;
               var mouse_y = event.pageY;
               var render_x = mouse_x;
               var render_y = mouse_y;
               var dims;
               var menu_width;
               var menu_height;
               var window_width;
               var window_height;
               var max_width;
               var max_height;
               $('#context-menu').css('left', (render_x + 'px'));
               $('#context-menu').css('top', (render_y + 'px'));
               $('#context-menu').html('');
               $.ajax({
                 url: contextMenuUrl,
                 data: $(event.target).parents('form').first().serialize(),
                 success: function(data, textStatus, jqXHR) {
                   $('#context-menu').html(data);
                   menu_width = $('#context-menu').width();
                   menu_height = $('#context-menu').height();
                   max_width = mouse_x + 2*menu_width;
                   max_height = mouse_y + menu_height;
                   var ws = window_size();
                   window_width = ws.width;
                   window_height = ws.height;
                   /* display the menu above and/or to the left of the click if needed */
                   if (max_width > window_width) {
                    render_x -= menu_width;
                    $('#context-menu').addClass('reverse-x');
                   } else {
                    $('#context-menu').removeClass('reverse-x');
                   }
                   if (max_height > window_height) {
                    render_y -= menu_height;
                    $('#context-menu').addClass('reverse-y');
                   } else {
                    $('#context-menu').removeClass('reverse-y');
                   }
                   if (render_x <= 0) render_x = 1;
                   if (render_y <= 0) render_y = 1;
                   $('#context-menu').css('left', (render_x + 'px'));
                   $('#context-menu').css('top', (render_y + 'px'));
                   $('#context-menu').show();
                   //if (window.parseStylesheets) { window.parseStylesheets(); } // IE
                 }
               });
             }
             function contextMenuSetLastSelected(tr) {
               $('.cm-last').removeClass('cm-last');
               tr.addClass('cm-last');
             }
             function contextMenuLastSelected() {
               return $('.cm-last').first();
             }
             function contextMenuUnselectAll() {
               $('.hascontextmenu').each(function(){
                 contextMenuRemoveSelection($(this));
               });
               $('.cm-last').removeClass('cm-last');
             }
             function contextMenuHide() {
               $('#context-menu').hide();
             }
             function contextMenuToggleSelection(tr) {
               if (contextMenuIsSelected(tr)) {
                 contextMenuRemoveSelection(tr);
               } else {
                 contextMenuAddSelection(tr);
               }
             }
             function contextMenuAddSelection(tr) {
               tr.addClass('context-menu-selection');
               contextMenuCheckSelectionBox(tr, true);
               contextMenuClearDocumentSelection();
             }
             function contextMenuRemoveSelection(tr) {
               tr.removeClass('context-menu-selection');
               contextMenuCheckSelectionBox(tr, false);
             }
             function contextMenuIsSelected(tr) {
               return tr.hasClass('context-menu-selection');
             }
             function contextMenuCheckSelectionBox(tr, checked) {
-              tr.find('input[type=checkbox]').attr('checked', checked);
+              tr.find('input[type=checkbox]').prop('checked', checked);
             }
             function contextMenuClearDocumentSelection() {
               // TODO
               if (document.selection) {
                 document.selection.empty(); // IE
               } else {
                 window.getSelection().removeAllRanges();
               }
             }
             function contextMenuInit(url) {
               contextMenuUrl = url;
               contextMenuCreate();
               contextMenuUnselectAll();
               if (!contextMenuObserving) {
                 $(document).click(contextMenuClick);
                 $(document).contextmenu(contextMenuRightClick);
                 contextMenuObserving = true;
               }
             }
             function toggleIssuesSelection(el) {
               var boxes = $(el).parents('form').find('input[type=checkbox]');
               var all_checked = true;
-              boxes.each(function(){ if (!$(this).attr('checked')) { all_checked = false; } });
+              boxes.each(function(){ if (!$(this).prop('checked')) { all_checked = false; } });
               boxes.each(function(){
                 if (all_checked) {
                   $(this).removeAttr('checked');
                   $(this).parents('tr').removeClass('context-menu-selection');
-                } else if (!$(this).attr('checked')) {
+                } else if (!$(this).prop('checked')) {
-                  $(this).attr('checked', true);
+                  $(this).prop('checked', true);
                   $(this).parents('tr').addClass('context-menu-selection');
                 }
               });
             }
             function window_size() {
               var w;
               var h;
               if (window.innerWidth) {
                 w = window.innerWidth;
                 h = window.innerHeight;
               } else if (document.documentElement) {
                 w = document.documentElement.clientWidth;
                 h = document.documentElement.clientHeight;
               } else {
                 w = document.body.clientWidth;
                 h = document.body.clientHeight;
               }
               return {width: w, height: h};
             }

public/javascripts/gantt.js +2 -2

             var draw_gantt = null;
             var draw_top;
             var draw_right;
             var draw_left;
             var rels_stroke_width = 2;
             function setDrawArea() {
               draw_top   = $("#gantt_draw_area").position().top;
               draw_right = $("#gantt_draw_area").width();
               draw_left  = $("#gantt_area").scrollLeft();
             }
             function getRelationsArray() {
               var arr = new Array();
               $.each($('div.task_todo[data-rels]'), function(index_div, element) {
                 var element_id = $(element).attr("id");
                 if (element_id != null) {
                   var issue_id = element_id.replace("task-todo-issue-", "");
                   var data_rels = $(element).data("rels");
                   for (rel_type_key in data_rels) {
                     $.each(data_rels[rel_type_key], function(index_issue, element_issue) {
                       arr.push({issue_from: issue_id, issue_to: element_issue,
                                 rel_type: rel_type_key});
                     });
                   }
                 }
               });
               return arr;
             }
             function drawRelations() {
               var arr = getRelationsArray();
               $.each(arr, function(index_issue, element_issue) {
                 var issue_from = $("#task-todo-issue-" + element_issue["issue_from"]);
                 var issue_to   = $("#task-todo-issue-" + element_issue["issue_to"]);
                 if (issue_from.size() == 0 || issue_to.size() == 0) {
                   return;
                 }
                 var issue_height = issue_from.height();
                 var issue_from_top   = issue_from.position().top  + (issue_height / 2) - draw_top;
                 var issue_from_right = issue_from.position().left + issue_from.width();
                 var issue_to_top   = issue_to.position().top  + (issue_height / 2) - draw_top;
                 var issue_to_left  = issue_to.position().left;
                 var color = issue_relation_type[element_issue["rel_type"]]["color"];
                 var landscape_margin = issue_relation_type[element_issue["rel_type"]]["landscape_margin"];
                 var issue_from_right_rel = issue_from_right + landscape_margin;
                 var issue_to_left_rel    = issue_to_left    - landscape_margin;
                 draw_gantt.path(["M", issue_from_right + draw_left,     issue_from_top,
                                  "L", issue_from_right_rel + draw_left, issue_from_top])
                                .attr({stroke: color,
                                       "stroke-width": rels_stroke_width
                                       });
                 if (issue_from_right_rel < issue_to_left_rel) {
                   draw_gantt.path(["M", issue_from_right_rel + draw_left, issue_from_top,
                                    "L", issue_from_right_rel + draw_left, issue_to_top])
                                  .attr({stroke: color,
                                       "stroke-width": rels_stroke_width
                                       });
                   draw_gantt.path(["M", issue_from_right_rel + draw_left, issue_to_top,
                                    "L", issue_to_left + draw_left,        issue_to_top])
                                  .attr({stroke: color,
                                       "stroke-width": rels_stroke_width
                                       });
                 } else {
                   var issue_middle_top = issue_to_top +
                                             (issue_height *
                                                ((issue_from_top > issue_to_top) ? 1 : -1));
                   draw_gantt.path(["M", issue_from_right_rel + draw_left, issue_from_top,
                                    "L", issue_from_right_rel + draw_left, issue_middle_top])
                                  .attr({stroke: color,
                                       "stroke-width": rels_stroke_width
                                       });
                   draw_gantt.path(["M", issue_from_right_rel + draw_left, issue_middle_top,
                                    "L", issue_to_left_rel + draw_left,    issue_middle_top])
                                  .attr({stroke: color,
                                       "stroke-width": rels_stroke_width
                                       });
                   draw_gantt.path(["M", issue_to_left_rel + draw_left, issue_middle_top,
                                    "L", issue_to_left_rel + draw_left, issue_to_top])
                                  .attr({stroke: color,
                                       "stroke-width": rels_stroke_width
                                       });
                   draw_gantt.path(["M", issue_to_left_rel + draw_left, issue_to_top,
                                    "L", issue_to_left + draw_left,     issue_to_top])
                                  .attr({stroke: color,
                                       "stroke-width": rels_stroke_width
                                       });
                 }
                 draw_gantt.path(["M", issue_to_left + draw_left, issue_to_top,
                                  "l", -4 * rels_stroke_width, -2 * rels_stroke_width,
                                  "l", 0, 4 * rels_stroke_width, "z"])
                                .attr({stroke: "none",
                                       fill: color,
                                       "stroke-linecap": "butt",
                                       "stroke-linejoin": "miter"
                                       });
               });
             }
             function getProgressLinesArray() {
               var arr = new Array();
               var today_left = $('#today_line').position().left;
               arr.push({left: today_left, top: 0});
               $.each($('div.issue-subject, div.version-name'), function(index, element) {
                 var t = $(element).position().top - draw_top ;
                 var h = ($(element).height() / 9);
                 var element_top_upper  = t - h;
                 var element_top_center = t + (h * 3);
                 var element_top_lower  = t + (h * 8);
                 var issue_closed   = $(element).children('span').hasClass('issue-closed');
                 var version_closed = $(element).children('span').hasClass('version-closed');
                 if (issue_closed || version_closed) {
                   arr.push({left: today_left, top: element_top_center});
                 } else {
                   var issue_done = $("#task-done-" + $(element).attr("id"));
                   var is_behind_start = $(element).children('span').hasClass('behind-start-date');
                   var is_over_end     = $(element).children('span').hasClass('over-end-date');
                   if (is_over_end) {
                     arr.push({left: draw_right, top: element_top_upper, is_right_edge: true});
                     arr.push({left: draw_right, top: element_top_lower, is_right_edge: true, none_stroke: true});
                   } else if (issue_done.size() > 0) {
                     var done_left = issue_done.first().position().left +
                                        issue_done.first().width();
                     arr.push({left: done_left, top: element_top_center});
                   } else if (is_behind_start) {
                     arr.push({left: 0 , top: element_top_upper, is_left_edge: true});
                     arr.push({left: 0 , top: element_top_lower, is_left_edge: true, none_stroke: true});
                   } else {
                     var todo_left = today_left;
                     var issue_todo = $("#task-todo-" + $(element).attr("id"));
                     if (issue_todo.size() > 0){
                       todo_left = issue_todo.first().position().left;
                     }
                     arr.push({left: Math.min(today_left, todo_left), top: element_top_center});
                   }
                 }
               });
               return arr;
             }
             function drawGanttProgressLines() {
               var arr = getProgressLinesArray();
               var color = $("#today_line")
                                 .css("border-left-color");
               var i;
               for(i = 1 ; i < arr.length ; i++) {
                 if (!("none_stroke" in arr[i]) &&
                     (!("is_right_edge" in arr[i - 1] && "is_right_edge" in arr[i]) &&
                      !("is_left_edge"  in arr[i - 1] && "is_left_edge"  in arr[i]))
                     ) {
                   var x1 = (arr[i - 1].left == 0) ? 0 : arr[i - 1].left + draw_left;
                   var x2 = (arr[i].left == 0)     ? 0 : arr[i].left     + draw_left;
                   draw_gantt.path(["M", x1, arr[i - 1].top,
                                    "L", x2, arr[i].top])
                                .attr({stroke: color, "stroke-width": 2});
                 }
               }
             }
             function drawGanttHandler() {
               var folder = document.getElementById('gantt_draw_area');
               if(draw_gantt != null)
                 draw_gantt.clear();
               else
                 draw_gantt = Raphael(folder);
               setDrawArea();
-              if ($("#draw_progress_line").attr('checked'))
+              if ($("#draw_progress_line").prop('checked'))
                 drawGanttProgressLines();
-              if ($("#draw_relations").attr('checked'))
+              if ($("#draw_relations").prop('checked'))
                 drawRelations();
             }

public/stylesheets/jquery/images/ui-bg_diagonals-thick_18_b81900_40x40.png binary modified 0 0