jro_apps/redmine Commit - r10748:ef25210aca92

Merged ajax_upload branch (#3957)....

Jean-Philippe Lang -

r10748:ef25210aca92

parent child

Context file:

r10748:ef25210aca92

Expand all files

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

app/views/attachments/destroy.js.erb created 644 +1 0

	@@ -0,0 +1,1
				1	$('#attachments_<%= j params[:attachment_id] %>').remove();

app/views/attachments/upload.js.erb created 644 +9 0

@@ -0,0 +1,9
	1	var fileSpan = $('#attachments_<%= j params[:attachment_id] %>');
	2	$('<input>', { type: 'hidden', name: 'attachments[<%= j params[:attachment_id] %>][token]' } ).val('<%= j @attachment.token %>').appendTo(fileSpan);
	3	fileSpan.find('a.remove-upload')
	4	.attr({
	5	"data-remote": true,
	6	"data-method": 'delete',
	7	href: '<%= j attachment_path(@attachment, :attachment_id => params[:attachment_id], :format => 'js') %>'
	8	})
	9	.off('click');

public/images/hourglass.png created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

public/javascripts/attachments.js created 644 +189 0

@@ -0,0 +1,189
	1	/* Redmine - project management software
	2	Copyright (C) 2006-2012 Jean-Philippe Lang */
	3
	4	function addFile(inputEl, file, eagerUpload) {
	5
	6	if ($('#attachments_fields').children().length < 10) {
	7
	8	var attachmentId = addFile.nextAttachmentId++;
	9
	10	var fileSpan = $('<span>', { id: 'attachments_' + attachmentId });
	11
	12	fileSpan.append(
	13	$('<input>', { type: 'text', 'class': 'filename readonly', name: 'attachments[' + attachmentId + '][filename]', readonly: 'readonly'} ).val(file.name),
	14	$('<input>', { type: 'text', 'class': 'description', name: 'attachments[' + attachmentId + '][description]', maxlength: 255, placeholder: $(inputEl).data('description-placeholder') } ).toggle(!eagerUpload),
	15	$('<a>&nbsp</a>').attr({ href: "#", 'class': 'remove-upload' }).click(removeFile).toggle(!eagerUpload)
	16	).appendTo('#attachments_fields');
	17
	18	if(eagerUpload) {
	19	ajaxUpload(file, attachmentId, fileSpan, inputEl);
	20	}
	21
	22	return attachmentId;
	23	}
	24	return null;
	25	}
	26
	27	addFile.nextAttachmentId = 1;
	28
	29	function ajaxUpload(file, attachmentId, fileSpan, inputEl) {
	30
	31	function onLoadstart(e) {
	32	fileSpan.removeClass('ajax-waiting');
	33	fileSpan.addClass('ajax-loading');
	34	$('input:submit', $(this).parents('form')).attr('disabled', 'disabled');
	35	}
	36
	37	function onProgress(e) {
	38	if(e.lengthComputable) {
	39	this.progressbar( 'value', e.loaded * 100 / e.total );
	40	}
	41	}
	42
	43	function actualUpload(file, attachmentId, fileSpan, inputEl) {
	44
	45	ajaxUpload.uploading++;
	46
	47	uploadBlob(file, $(inputEl).data('upload-path'), attachmentId, {
	48	loadstartEventHandler: onLoadstart.bind(progressSpan),
	49	progressEventHandler: onProgress.bind(progressSpan)
	50	})
	51	.done(function(result) {
	52	progressSpan.progressbar( 'value', 100 ).remove();
	53	fileSpan.find('input.description, a').css('display', 'inline-block');
	54	})
	55	.fail(function(result) {
	56	progressSpan.text(result.statusText);
	57	}).always(function() {
	58	ajaxUpload.uploading--;
	59	fileSpan.removeClass('ajax-loading');
	60	var form = fileSpan.parents('form');
	61	if (form.queue('upload').length == 0 && ajaxUpload.uploading == 0) {
	62	$('input:submit', form).removeAttr('disabled');
	63	}
	64	form.dequeue('upload');
	65	});
	66	}
	67
	68	var progressSpan = $('<div>').insertAfter(fileSpan.find('input.filename'));
	69	progressSpan.progressbar();
	70	fileSpan.addClass('ajax-waiting');
	71
	72	var maxSyncUpload = $(inputEl).data('max-concurrent-uploads');
	73
	74	if(maxSyncUpload == null \|\| maxSyncUpload <= 0 \|\| ajaxUpload.uploading < maxSyncUpload)
	75	actualUpload(file, attachmentId, fileSpan, inputEl);
	76	else
	77	$(inputEl).parents('form').queue('upload', actualUpload.bind(this, file, attachmentId, fileSpan, inputEl));
	78	}
	79
	80	ajaxUpload.uploading = 0;
	81
	82	function removeFile() {
	83	$(this).parent('span').remove();
	84	return false;
	85	}
	86
	87	function uploadBlob(blob, uploadUrl, attachmentId, options) {
	88
	89	var actualOptions = $.extend({
	90	loadstartEventHandler: $.noop,
	91	progressEventHandler: $.noop
	92	}, options);
	93
	94	uploadUrl = uploadUrl + '?attachment_id=' + attachmentId;
	95	if (blob instanceof window.File) {
	96	uploadUrl += '&filename=' + encodeURIComponent(blob.name);
	97	}
	98
	99	return $.ajax(uploadUrl, {
	100	type: 'POST',
	101	contentType: 'application/octet-stream',
	102	beforeSend: function(jqXhr) {
	103	jqXhr.setRequestHeader('Accept', 'application/js');
	104	},
	105	xhr: function() {
	106	var xhr = $.ajaxSettings.xhr();
	107	xhr.upload.onloadstart = actualOptions.loadstartEventHandler;
	108	xhr.upload.onprogress = actualOptions.progressEventHandler;
	109	return xhr;
	110	},
	111	data: blob,
	112	cache: false,
	113	processData: false
	114	});
	115	}
	116
	117	function addInputFiles(inputEl) {
	118	var clearedFileInput = $(inputEl).clone().val('');
	119
	120	if (inputEl.files) {
	121	// upload files using ajax
	122	uploadAndAttachFiles(inputEl.files, inputEl);
	123	$(inputEl).remove();
	124	} else {
	125	// browser not supporting the file API, upload on form submission
	126	var attachmentId;
	127	var aFilename = inputEl.value.split(/\/\|\\/);
	128	attachmentId = addFile(inputEl, { name: aFilename[ aFilename.length - 1 ] }, false);
	129	if (attachmentId) {
	130	$(inputEl).attr({ name: 'attachments[' + attachmentId + '][file]', style: 'display:none;' }).appendTo('#attachments_' + attachmentId);
	131	}
	132	}
	133
	134	clearedFileInput.insertAfter('#attachments_fields');
	135	}
	136
	137	function uploadAndAttachFiles(files, inputEl) {
	138
	139	var maxFileSize = $(inputEl).data('max-file-size');
	140	var maxFileSizeExceeded = $(inputEl).data('max-file-size-message');
	141
	142	var sizeExceeded = false;
	143	$.each(files, function() {
	144	if (this.size && maxFileSize && this.size > parseInt(maxFileSize)) {sizeExceeded=true;}
	145	});
	146	if (sizeExceeded) {
	147	window.alert(maxFileSizeExceeded);
	148	} else {
	149	$.each(files, function() {addFile(inputEl, this, true);});
	150	}
	151	}
	152
	153	function handleFileDropEvent(e) {
	154
	155	$(this).removeClass('fileover');
	156	blockEventPropagation(e);
	157
	158	if ($.inArray('Files', e.dataTransfer.types) > -1) {
	159
	160	uploadAndAttachFiles(e.dataTransfer.files, $('input:file[name=attachments_files]'));
	161	}
	162	}
	163
	164	function dragOverHandler(e) {
	165	$(this).addClass('fileover');
	166	blockEventPropagation(e);
	167	}
	168
	169	function dragOutHandler(e) {
	170	$(this).removeClass('fileover');
	171	blockEventPropagation(e);
	172	}
	173
	174	function setupFileDrop() {
	175	if (window.File && window.FileList && window.ProgressEvent && window.FormData) {
	176
	177	$.event.fixHooks.drop = { props: [ 'dataTransfer' ] };
	178
	179	$('form div.box').has('input:file').each(function() {
	180	$(this).on({
	181	dragover: dragOverHandler,
	182	dragleave: dragOutHandler,
	183	drop: handleFileDropEvent
	184	});
	185	});
	186	}
	187	}
	188
	189	$(document).ready(setupFileDrop);

test/integration/attachments_test.rb created 644 +132 0

@@ -0,0 +1,132
	1	# Redmine - project management software
	2	# Copyright (C) 2006-2012 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	require File.expand_path('../../test_helper', __FILE__)
	19
	20	class AttachmentsTest < ActionController::IntegrationTest
	21	fixtures :projects, :enabled_modules,
	22	:users, :roles, :members, :member_roles,
	23	:trackers, :projects_trackers,
	24	:issue_statuses, :enumerations
	25
	26	def test_upload_as_js_and_attach_to_an_issue
	27	log_user('jsmith', 'jsmith')
	28
	29	token = ajax_upload('myupload.txt', 'File content')
	30
	31	assert_difference 'Issue.count' do
	32	post '/projects/ecookbook/issues', {
	33	:issue => {:tracker_id => 1, :subject => 'Issue with upload'},
	34	:attachments => {'1' => {:filename => 'myupload.txt', :description => 'My uploaded file', :token => token}}
	35	}
	36	assert_response 302
	37	end
	38
	39	issue = Issue.order('id DESC').first
	40	assert_equal 'Issue with upload', issue.subject
	41	assert_equal 1, issue.attachments.count
	42
	43	attachment = issue.attachments.first
	44	assert_equal 'myupload.txt', attachment.filename
	45	assert_equal 'My uploaded file', attachment.description
	46	assert_equal 'File content'.length, attachment.filesize
	47	end
	48
	49	def test_upload_as_js_and_preview_as_inline_attachment
	50	log_user('jsmith', 'jsmith')
	51
	52	token = ajax_upload('myupload.jpg', 'JPEG content')
	53
	54	post '/issues/preview/new/ecookbook', {
	55	:issue => {:tracker_id => 1, :description => 'Inline upload: !myupload.jpg!'},
	56	:attachments => {'1' => {:filename => 'myupload.jpg', :description => 'My uploaded file', :token => token}}
	57	}
	58	assert_response :success
	59
	60	attachment_path = response.body.match(%r{<img src="(/attachments/download/\d+)"})[1]
	61	assert_not_nil token, "No attachment path found in response:\n#{response.body}"
	62
	63	get attachment_path
	64	assert_response :success
	65	assert_equal 'JPEG content', response.body
	66	end
	67
	68	def test_upload_and_resubmit_after_validation_failure
	69	log_user('jsmith', 'jsmith')
	70
	71	token = ajax_upload('myupload.txt', 'File content')
	72
	73	assert_no_difference 'Issue.count' do
	74	post '/projects/ecookbook/issues', {
	75	:issue => {:tracker_id => 1, :subject => ''},
	76	:attachments => {'1' => {:filename => 'myupload.txt', :description => 'My uploaded file', :token => token}}
	77	}
	78	assert_response :success
	79	end
	80	assert_select 'input[type=hidden][name=?][value=?]', 'attachments[p0][token]', token
	81	assert_select 'input[name=?][value=?]', 'attachments[p0][filename]', 'myupload.txt'
	82	assert_select 'input[name=?][value=?]', 'attachments[p0][description]', 'My uploaded file'
	83
	84	assert_difference 'Issue.count' do
	85	post '/projects/ecookbook/issues', {
	86	:issue => {:tracker_id => 1, :subject => 'Issue with upload'},
	87	:attachments => {'p0' => {:filename => 'myupload.txt', :description => 'My uploaded file', :token => token}}
	88	}
	89	assert_response 302
	90	end
	91
	92	issue = Issue.order('id DESC').first
	93	assert_equal 'Issue with upload', issue.subject
	94	assert_equal 1, issue.attachments.count
	95
	96	attachment = issue.attachments.first
	97	assert_equal 'myupload.txt', attachment.filename
	98	assert_equal 'My uploaded file', attachment.description
	99	assert_equal 'File content'.length, attachment.filesize
	100	end
	101
	102	def test_upload_as_js_and_destroy
	103	log_user('jsmith', 'jsmith')
	104
	105	token = ajax_upload('myupload.txt', 'File content')
	106
	107	attachment = Attachment.order('id DESC').first
	108	attachment_path = "/attachments/#{attachment.id}.js?attachment_id=1"
	109	assert_include "href: '#{attachment_path}'", response.body, "Path to attachment: #{attachment_path} not found in response:\n#{response.body}"
	110
	111	assert_difference 'Attachment.count', -1 do
	112	delete attachment_path
	113	assert_response :success
	114	end
	115
	116	assert_include "$('#attachments_1').remove();", response.body
	117	end
	118
	119	private
	120
	121	def ajax_upload(filename, content, attachment_id=1)
	122	assert_difference 'Attachment.count' do
	123	post "/uploads.js?attachment_id=#{attachment_id}&filename=#{filename}", content, {"CONTENT_TYPE" => 'application/octet-stream'}
	124	assert_response :success
	125	assert_equal 'text/javascript', response.content_type
	126	end
	127
	128	token = response.body.match(/\.val$'(\d+\.[0-9a-f]+)'$/)[1]
	129	assert_not_nil token, "No upload token found in response:\n#{response.body}"
	130	token
	131	end
	132	end

app/controllers/application_controller.rb +10 0

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'uri'
             require 'cgi'
             class Unauthorized < Exception; end
             class ApplicationController < ActionController::Base
               include Redmine::I18n
               class_attribute :accept_api_auth_actions
               class_attribute :accept_rss_auth_actions
               class_attribute :model_object
               layout 'base'
               protect_from_forgery
               def handle_unverified_request
                 super
                 cookies.delete(:autologin)
               end
               before_filter :session_expiration, :user_setup, :check_if_login_required, :set_localization
               rescue_from ActionController::InvalidAuthenticityToken, :with => :invalid_authenticity_token
               rescue_from ::Unauthorized, :with => :deny_access
               rescue_from ::ActionView::MissingTemplate, :with => :missing_template
               include Redmine::Search::Controller
               include Redmine::MenuManager::MenuController
               helper Redmine::MenuManager::MenuHelper
               def session_expiration
                 if session[:user_id]
                   if session_expired? && !try_to_autologin
                     reset_session
                     flash[:error] = l(:error_session_expired)
                     redirect_to signin_url
                   else
                     session[:atime] = Time.now.utc.to_i
                   end
                 end
               end
               def session_expired?
                 if Setting.session_lifetime?
                   unless session[:ctime] && (Time.now.utc.to_i - session[:ctime].to_i <= Setting.session_lifetime.to_i * 60)
                     return true
                   end
                 end
                 if Setting.session_timeout?
                   unless session[:atime] && (Time.now.utc.to_i - session[:atime].to_i <= Setting.session_timeout.to_i * 60)
                     return true
                   end
                 end
                 false
               end
               def start_user_session(user)
                 session[:user_id] = user.id
                 session[:ctime] = Time.now.utc.to_i
                 session[:atime] = Time.now.utc.to_i
               end
               def user_setup
                 # Check the settings cache for each request
                 Setting.check_cache
                 # Find the current user
                 User.current = find_current_user
                 logger.info("  Current user: " + (User.current.logged? ? "#{User.current.login} (id=#{User.current.id})" : "anonymous")) if logger
               end
               # Returns the current user or nil if no user is logged in
               # and starts a session if needed
               def find_current_user
                 user = nil
                 unless api_request?
                   if session[:user_id]
                     # existing session
                     user = (User.active.find(session[:user_id]) rescue nil)
                   elsif autologin_user = try_to_autologin
                     user = autologin_user
                   elsif params[:format] == 'atom' && params[:key] && request.get? && accept_rss_auth?
                     # RSS key authentication does not start a session
                     user = User.find_by_rss_key(params[:key])
                   end
                 end
                 if user.nil? && Setting.rest_api_enabled? && accept_api_auth?
                   if (key = api_key_from_request)
                     # Use API key
                     user = User.find_by_api_key(key)
                   else
                     # HTTP Basic, either username/password or API key/random
                     authenticate_with_http_basic do |username, password|
                       user = User.try_to_login(username, password) || User.find_by_api_key(username)
                     end
                   end
                   # Switch user if requested by an admin user
                   if user && user.admin? && (username = api_switch_user_from_request)
                     su = User.find_by_login(username)
                     if su && su.active?
                       logger.info("  User switched by: #{user.login} (id=#{user.id})") if logger
                       user = su
                     else
                       render_error :message => 'Invalid X-Redmine-Switch-User header', :status => 412
                     end
                   end
                 end
                 user
               end
               def try_to_autologin
                 if cookies[:autologin] && Setting.autologin?
                   # auto-login feature starts a new session
                   user = User.try_to_autologin(cookies[:autologin])
                   if user
                     reset_session
                     start_user_session(user)
                   end
                   user
                 end
               end
               # Sets the logged in user
               def logged_user=(user)
                 reset_session
                 if user && user.is_a?(User)
                   User.current = user
                   start_user_session(user)
                 else
                   User.current = User.anonymous
                 end
               end
               # Logs out current user
               def logout_user
                 if User.current.logged?
                   cookies.delete :autologin
                   Token.delete_all(["user_id = ? AND action = ?", User.current.id, 'autologin'])
                   self.logged_user = nil
                 end
               end
               # check if login is globally required to access the application
               def check_if_login_required
                 # no check needed if user is already logged in
                 return true if User.current.logged?
                 require_login if Setting.login_required?
               end
               def set_localization
                 lang = nil
                 if User.current.logged?
                   lang = find_language(User.current.language)
                 end
                 if lang.nil? && request.env['HTTP_ACCEPT_LANGUAGE']
                   accept_lang = parse_qvalues(request.env['HTTP_ACCEPT_LANGUAGE']).first
                   if !accept_lang.blank?
                     accept_lang = accept_lang.downcase
                     lang = find_language(accept_lang) || find_language(accept_lang.split('-').first)
                   end
                 end
                 lang ||= Setting.default_language
                 set_language_if_valid(lang)
               end
               def require_login
                 if !User.current.logged?
                   # Extract only the basic url parameters on non-GET requests
                   if request.get?
                     url = url_for(params)
                   else
                     url = url_for(:controller => params[:controller], :action => params[:action], :id => params[:id], :project_id => params[:project_id])
                   end
                   respond_to do |format|
                     format.html { redirect_to :controller => "account", :action => "login", :back_url => url }
                     format.atom { redirect_to :controller => "account", :action => "login", :back_url => url }
                     format.xml  { head :unauthorized, 'WWW-Authenticate' => 'Basic realm="Redmine API"' }
                     format.js   { head :unauthorized, 'WWW-Authenticate' => 'Basic realm="Redmine API"' }
                     format.json { head :unauthorized, 'WWW-Authenticate' => 'Basic realm="Redmine API"' }
                   end
                   return false
                 end
                 true
               end
               def require_admin
                 return unless require_login
                 if !User.current.admin?
                   render_403
                   return false
                 end
                 true
               end
               def deny_access
                 User.current.logged? ? render_403 : require_login
               end
               # Authorize the user for the requested action
               def authorize(ctrl = params[:controller], action = params[:action], global = false)
                 allowed = User.current.allowed_to?({:controller => ctrl, :action => action}, @project || @projects, :global => global)
                 if allowed
                   true
                 else
                   if @project && @project.archived?
                     render_403 :message => :notice_not_authorized_archived_project
                   else
                     deny_access
                   end
                 end
               end
               # Authorize the user for the requested action outside a project
               def authorize_global(ctrl = params[:controller], action = params[:action], global = true)
                 authorize(ctrl, action, global)
               end
               # Find project of id params[:id]
               def find_project
                 @project = Project.find(params[:id])
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Find project of id params[:project_id]
               def find_project_by_project_id
                 @project = Project.find(params[:project_id])
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Find a project based on params[:project_id]
               # TODO: some subclasses override this, see about merging their logic
               def find_optional_project
                 @project = Project.find(params[:project_id]) unless params[:project_id].blank?
                 allowed = User.current.allowed_to?({:controller => params[:controller], :action => params[:action]}, @project, :global => true)
                 allowed ? true : deny_access
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Finds and sets @project based on @object.project
               def find_project_from_association
                 render_404 unless @object.present?
                 @project = @object.project
               end
               def find_model_object
                 model = self.class.model_object
                 if model
                   @object = model.find(params[:id])
                   self.instance_variable_set('@' + controller_name.singularize, @object) if @object
                 end
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def self.model_object(model)
                 self.model_object = model
               end
               # Find the issue whose id is the :id parameter
               # Raises a Unauthorized exception if the issue is not visible
               def find_issue
                 # Issue.visible.find(...) can not be used to redirect user to the login form
                 # if the issue actually exists but requires authentication
                 @issue = Issue.find(params[:id])
                 raise Unauthorized unless @issue.visible?
                 @project = @issue.project
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Find issues with a single :id param or :ids array param
               # Raises a Unauthorized exception if one of the issues is not visible
               def find_issues
                 @issues = Issue.find_all_by_id(params[:id] || params[:ids])
                 raise ActiveRecord::RecordNotFound if @issues.empty?
                 raise Unauthorized unless @issues.all?(&:visible?)
                 @projects = @issues.collect(&:project).compact.uniq
                 @project = @projects.first if @projects.size == 1
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
+              def find_attachments
+                if (attachments = params[:attachments]).present?
+                  att = attachments.values.collect do |attachment|
+                    Attachment.find_by_token( attachment[:token] ) if attachment[:token].present?
+                  end
+                  att.compact!
+                end
+                @attachments = att || []
+              end
               # make sure that the user is a member of the project (or admin) if project is private
               # used as a before_filter for actions that do not require any particular permission on the project
               def check_project_privacy
                 if @project && !@project.archived?
                   if @project.visible?
                     true
                   else
                     deny_access
                   end
                 else
                   @project = nil
                   render_404
                   false
                 end
               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 redirect_back_or_default(default)
                 back_url = params[:back_url].to_s
                 if back_url.present?
                   begin
                     uri = URI.parse(back_url)
                     # do not redirect user to another host or to the login or register page
                     if (uri.relative? || (uri.host == request.host)) && !uri.path.match(%r{/(login|account/register)})
                       redirect_to(back_url)
                       return
                     end
                   rescue URI::InvalidURIError
                     logger.warn("Could not redirect to invalid URL #{back_url}")
                     # redirect to default
                   end
                 end
                 redirect_to default
                 false
               end
               # Redirects to the request referer if present, redirects to args or call block otherwise.
               def redirect_to_referer_or(*args, &block)
                 redirect_to :back
               rescue ::ActionController::RedirectBackError
                 if args.any?
                   redirect_to *args
                 elsif block_given?
                   block.call
                 else
                   raise "#redirect_to_referer_or takes arguments or a block"
                 end
               end
               def render_403(options={})
                 @project = nil
                 render_error({:message => :notice_not_authorized, :status => 403}.merge(options))
                 return false
               end
               def render_404(options={})
                 render_error({:message => :notice_file_not_found, :status => 404}.merge(options))
                 return false
               end
               # Renders an error response
               def render_error(arg)
                 arg = {:message => arg} unless arg.is_a?(Hash)
                 @message = arg[:message]
                 @message = l(@message) if @message.is_a?(Symbol)
                 @status = arg[:status] || 500
                 respond_to do |format|
                   format.html {
                     render :template => 'common/error', :layout => use_layout, :status => @status
                   }
                   format.any { head @status }
                 end
               end
               # Handler for ActionView::MissingTemplate exception
               def missing_template
                 logger.warn "Missing template, responding with 404"
                 @project = nil
                 render_404
               end
               # Filter for actions that provide an API response
               # but have no HTML representation for non admin users
               def require_admin_or_api_request
                 return true if api_request?
                 if User.current.admin?
                   true
                 elsif User.current.logged?
                   render_error(:status => 406)
                 else
                   deny_access
                 end
               end
               # Picks which layout to use based on the request
               #
               # @return [boolean, string] name of the layout to use or false for no layout
               def use_layout
                 request.xhr? ? false : 'base'
               end
               def invalid_authenticity_token
                 if api_request?
                   logger.error "Form authenticity token is missing or is invalid. API calls must include a proper Content-type header (text/xml or text/json)."
                 end
                 render_error "Invalid form authenticity token."
               end
               def render_feed(items, options={})
                 @items = items || []
                 @items.sort! {|x,y| y.event_datetime <=> x.event_datetime }
                 @items = @items.slice(0, Setting.feeds_limit.to_i)
                 @title = options[:title] || Setting.app_title
                 render :template => "common/feed", :formats => [:atom], :layout => false,
                        :content_type => 'application/atom+xml'
               end
               def self.accept_rss_auth(*actions)
                 if actions.any?
                   self.accept_rss_auth_actions = actions
                 else
                   self.accept_rss_auth_actions || []
                 end
               end
               def accept_rss_auth?(action=action_name)
                 self.class.accept_rss_auth.include?(action.to_sym)
               end
               def self.accept_api_auth(*actions)
                 if actions.any?
                   self.accept_api_auth_actions = actions
                 else
                   self.accept_api_auth_actions || []
                 end
               end
               def accept_api_auth?(action=action_name)
                 self.class.accept_api_auth.include?(action.to_sym)
               end
               # Returns the number of objects that should be displayed
               # on the paginated list
               def per_page_option
                 per_page = nil
                 if params[:per_page] && Setting.per_page_options_array.include?(params[:per_page].to_s.to_i)
                   per_page = params[:per_page].to_s.to_i
                   session[:per_page] = per_page
                 elsif session[:per_page]
                   per_page = session[:per_page]
                 else
                   per_page = Setting.per_page_options_array.first || 25
                 end
                 per_page
               end
               # Returns offset and limit used to retrieve objects
               # for an API response based on offset, limit and page parameters
               def api_offset_and_limit(options=params)
                 if options[:offset].present?
                   offset = options[:offset].to_i
                   if offset < 0
                     offset = 0
                   end
                 end
                 limit = options[:limit].to_i
                 if limit < 1
                   limit = 25
                 elsif limit > 100
                   limit = 100
                 end
                 if offset.nil? && options[:page].present?
                   offset = (options[:page].to_i - 1) * limit
                   offset = 0 if offset < 0
                 end
                 offset ||= 0
                 [offset, limit]
               end
               # qvalues http header parser
               # code taken from webrick
               def parse_qvalues(value)
                 tmp = []
                 if value
                   parts = value.split(/,\s*/)
                   parts.each {|part|
                     if m = %r{^([^\s,]+?)(?:;\s*q=(\d+(?:\.\d+)?))?$}.match(part)
                       val = m[1]
                       q = (m[2] or 1).to_f
                       tmp.push([val, q])
                     end
                   }
                   tmp = tmp.sort_by{|val, q| -q}
                   tmp.collect!{|val, q| val}
                 end
                 return tmp
               rescue
                 nil
               end
               # Returns a string that can be used as filename value in Content-Disposition header
               def filename_for_content_disposition(name)
                 request.env['HTTP_USER_AGENT'] =~ %r{MSIE} ? ERB::Util.url_encode(name) : name
               end
               def api_request?
                 %w(xml json).include? params[:format]
               end
               # Returns the API key present in the request
               def api_key_from_request
                 if params[:key].present?
                   params[:key].to_s
                 elsif request.headers["X-Redmine-API-Key"].present?
                   request.headers["X-Redmine-API-Key"].to_s
                 end
               end
               # Returns the API 'switch user' value if present
               def api_switch_user_from_request
                 request.headers["X-Redmine-Switch-User"].to_s.presence
               end
               # Renders a warning flash if obj has unsaved attachments
               def render_attachment_warning_if_needed(obj)
                 flash[:warning] = l(:warning_attachments_not_saved, obj.unsaved_attachments.size) if obj.unsaved_attachments.present?
               end
               # Sets the `flash` notice or error based the number of issues that did not save
               #
               # @param [Array, Issue] issues all of the saved and unsaved Issues
               # @param [Array, Integer] unsaved_issue_ids the issue ids that were not saved
               def set_flash_from_bulk_issue_save(issues, unsaved_issue_ids)
                 if unsaved_issue_ids.empty?
                   flash[:notice] = l(:notice_successful_update) unless issues.empty?
                 else
                   flash[:error] = l(:notice_failed_to_save_issues,
                                     :count => unsaved_issue_ids.size,
                                     :total => issues.size,
                                     :ids => '#' + unsaved_issue_ids.join(', #'))
                 end
               end
               # Rescues an invalid query statement. Just in case...
               def query_statement_invalid(exception)
                 logger.error "Query::StatementInvalid: #{exception.message}" if logger
                 session.delete(:query)
                 sort_clear if respond_to?(:sort_clear)
                 render_error "An error occurred while executing the query and has been logged. Please report this error to your Redmine administrator."
               end
               # Renders a 200 response for successfull updates or deletions via the API
               def render_api_ok
                 render_api_head :ok
               end
               # Renders a head API response
               def render_api_head(status)
                 # #head would return a response body with one space
                 render :text => '', :status => status, :layout => nil
               end
               # Renders API response on validation failure
               def render_validation_errors(objects)
                 if objects.is_a?(Array)
                   @error_messages = objects.map {|object| object.errors.full_messages}.flatten
                 else
                   @error_messages = objects.errors.full_messages
                 end
                 render :template => 'common/error_messages.api', :status => :unprocessable_entity, :layout => nil
               end
               # Overrides #_include_layout? so that #render with no arguments
               # doesn't use the layout for api requests
               def _include_layout?(*args)
                 api_request? ? false : super
               end
             end

app/controllers/attachments_controller.rb +16 -6

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class AttachmentsController < ApplicationController
               before_filter :find_project, :except => :upload
               before_filter :file_readable, :read_authorize, :only => [:show, :download, :thumbnail]
               before_filter :delete_authorize, :only => :destroy
               before_filter :authorize_global, :only => :upload
               accept_api_auth :show, :download, :upload
               def show
                 respond_to do |format|
                   format.html {
                     if @attachment.is_diff?
                       @diff = File.new(@attachment.diskfile, "rb").read
                       @diff_type = params[:type] || User.current.pref[:diff_type] || 'inline'
                       @diff_type = 'inline' unless %w(inline sbs).include?(@diff_type)
                       # Save diff type as user preference
                       if User.current.logged? && @diff_type != User.current.pref[:diff_type]
                         User.current.pref[:diff_type] = @diff_type
                         User.current.preference.save
                       end
                       render :action => 'diff'
                     elsif @attachment.is_text? && @attachment.filesize <= Setting.file_max_size_displayed.to_i.kilobyte
                       @content = File.new(@attachment.diskfile, "rb").read
                       render :action => 'file'
                     else
                       download
                     end
                   }
                   format.api
                 end
               end
               def download
                 if @attachment.container.is_a?(Version) || @attachment.container.is_a?(Project)
                   @attachment.increment_download
                 end
                 if stale?(:etag => @attachment.digest)
                   # images are sent inline
                   send_file @attachment.diskfile, :filename => filename_for_content_disposition(@attachment.filename),
                                                   :type => detect_content_type(@attachment),
                                                   :disposition => (@attachment.image? ? 'inline' : 'attachment')
                 end
               end
               def thumbnail
                 if @attachment.thumbnailable? && thumbnail = @attachment.thumbnail(:size => params[:size])
                   if stale?(:etag => thumbnail)
                     send_file thumbnail,
                       :filename => filename_for_content_disposition(@attachment.filename),
                       :type => detect_content_type(@attachment),
                       :disposition => 'inline'
                   end
                 else
                   # No thumbnail for the attachment or thumbnail could not be created
                   render :nothing => true, :status => 404
                 end
               end
               def upload
                 # Make sure that API users get used to set this content type
                 # as it won't trigger Rails' automatic parsing of the request body for parameters
                 unless request.content_type == 'application/octet-stream'
                   render :nothing => true, :status => 406
                   return
                 end
                 @attachment = Attachment.new(:file => request.raw_post)
                 @attachment.author = User.current
                 @attachment.filename = params[:filename].presence || Redmine::Utils.random_hex(16)
+                saved = @attachment.save
-                if @attachment.save
                 respond_to do |format|
-                    format.api { render :action => 'upload', :status => :created }
+                  format.js
-                  end
+                  format.api {
+                    if saved
+                      render :action => 'upload', :status => :created
                     else
-                  respond_to do |format|
+                      render_validation_errors(@attachment)
-                    format.api { render_validation_errors(@attachment) }
                     end
+                  }
                 end
               end
               def destroy
                 if @attachment.container.respond_to?(:init_journal)
                   @attachment.container.init_journal(User.current)
                 end
+                if @attachment.container
                   # Make sure association callbacks are called
                   @attachment.container.attachments.delete(@attachment)
-                redirect_to_referer_or project_path(@project)
+                else
+                  @attachment.destroy
+                end
+                respond_to do |format|
+                  format.html { redirect_to_referer_or project_path(@project) }
+                  format.js
+                end
               end
             private
               def find_project
                 @attachment = Attachment.find(params[:id])
                 # Show 404 if the filename in the url is wrong
                 raise ActiveRecord::RecordNotFound if params[:filename] && params[:filename] != @attachment.filename
                 @project = @attachment.project
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Checks that the file exists and is readable
               def file_readable
                 @attachment.readable? ? true : render_404
               end
               def read_authorize
                 @attachment.visible? ? true : deny_access
               end
               def delete_authorize
                 @attachment.deletable? ? true : deny_access
               end
               def detect_content_type(attachment)
                 content_type = attachment.content_type
                 if content_type.blank?
                   content_type = Redmine::MimeType.of(attachment.filename)
                 end
                 content_type.to_s
               end
             end

app/controllers/messages_controller.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class MessagesController < ApplicationController
               menu_item :boards
               default_search_scope :messages
               before_filter :find_board, :only => [:new, :preview]
+              before_filter :find_attachments, :only => [:preview]
               before_filter :find_message, :except => [:new, :preview]
               before_filter :authorize, :except => [:preview, :edit, :destroy]
               helper :boards
               helper :watchers
               helper :attachments
               include AttachmentsHelper
               REPLIES_PER_PAGE = 25 unless const_defined?(:REPLIES_PER_PAGE)
               # Show a topic and its replies
               def show
                 page = params[:page]
                 # Find the page of the requested reply
                 if params[:r] && page.nil?
                   offset = @topic.children.count(:conditions => ["#{Message.table_name}.id < ?", params[:r].to_i])
                   page = 1 + offset / REPLIES_PER_PAGE
                 end
                 @reply_count = @topic.children.count
                 @reply_pages = Paginator.new self, @reply_count, REPLIES_PER_PAGE, page
                 @replies =  @topic.children.
                   includes(:author, :attachments, {:board => :project}).
                   reorder("#{Message.table_name}.created_on ASC").
                   limit(@reply_pages.items_per_page).
                   offset(@reply_pages.current.offset).
                   all
                 @reply = Message.new(:subject => "RE: #{@message.subject}")
                 render :action => "show", :layout => false if request.xhr?
               end
               # Create a new topic
               def new
                 @message = Message.new
                 @message.author = User.current
                 @message.board = @board
                 @message.safe_attributes = params[:message]
                 if request.post?
                   @message.save_attachments(params[:attachments])
                   if @message.save
                     call_hook(:controller_messages_new_after_save, { :params => params, :message => @message})
                     render_attachment_warning_if_needed(@message)
                     redirect_to board_message_path(@board, @message)
                   end
                 end
               end
               # Reply to a topic
               def reply
                 @reply = Message.new
                 @reply.author = User.current
                 @reply.board = @board
                 @reply.safe_attributes = params[:reply]
                 @topic.children << @reply
                 if !@reply.new_record?
                   call_hook(:controller_messages_reply_after_save, { :params => params, :message => @reply})
                   attachments = Attachment.attach_files(@reply, params[:attachments])
                   render_attachment_warning_if_needed(@reply)
                 end
                 redirect_to board_message_path(@board, @topic, :r => @reply)
               end
               # Edit a message
               def edit
                 (render_403; return false) unless @message.editable_by?(User.current)
                 @message.safe_attributes = params[:message]
                 if request.post? && @message.save
                   attachments = Attachment.attach_files(@message, params[:attachments])
                   render_attachment_warning_if_needed(@message)
                   flash[:notice] = l(:notice_successful_update)
                   @message.reload
                   redirect_to board_message_path(@message.board, @message.root, :r => (@message.parent_id && @message.id))
                 end
               end
               # Delete a messages
               def destroy
                 (render_403; return false) unless @message.destroyable_by?(User.current)
                 r = @message.to_param
                 @message.destroy
                 if @message.parent
                   redirect_to board_message_path(@board, @message.parent, :r => r)
                 else
                   redirect_to project_board_path(@project, @board)
                 end
               end
               def quote
                 @subject = @message.subject
                 @subject = "RE: #{@subject}" unless @subject.starts_with?('RE:')
                 @content = "#{ll(Setting.default_language, :text_user_wrote, @message.author)}\n> "
                 @content << @message.content.to_s.strip.gsub(%r{<pre>((.|\s)*?)</pre>}m, '[...]').gsub(/(\r?\n|\r\n?)/, "\n> ") + "\n\n"
               end
               def preview
                 message = @board.messages.find_by_id(params[:id])
-                @attachements = message.attachments if message
                 @text = (params[:message] || params[:reply])[:content]
                 @previewed = message
                 render :partial => 'common/preview'
               end
             private
               def find_message
                 find_board
                 @message = @board.messages.find(params[:id], :include => :parent)
                 @topic = @message.root
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def find_board
                 @board = Board.find(params[:board_id], :include => :project)
                 @project = @board.project
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
             end

app/controllers/previews_controller.rb +1 -3

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class PreviewsController < ApplicationController
-              before_filter :find_project
+              before_filter :find_project, :find_attachments
               def issue
                 @issue = @project.issues.find_by_id(params[:id]) unless params[:id].blank?
                 if @issue
-                  @attachements = @issue.attachments
                   @description = params[:issue] && params[:issue][:description]
                   if @description && @description.gsub(/(\r?\n|\n\r?)/, "\n") == @issue.description.to_s.gsub(/(\r?\n|\n\r?)/, "\n")
                     @description = nil
                   end
                   # params[:notes] is useful for preview of notes in issue history
                   @notes = params[:notes] || (params[:issue] ? params[:issue][:notes] : nil)
                 else
                   @description = (params[:issue] ? params[:issue][:description] : nil)
                 end
                 render :layout => false
               end
               def news
                 if params[:id].present? && news = News.visible.find_by_id(params[:id])
                   @previewed = news
-                  @attachments = news.attachments
                 end
                 @text = (params[:news] ? params[:news][:description] : nil)
                 render :partial => 'common/preview'
               end
               private
               def find_project
                 project_id = (params[:issue] && params[:issue][:project_id]) || params[:project_id]
                 @project = Project.find(project_id)
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
             end

app/controllers/wiki_controller.rb +2 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'diff'
             # The WikiController follows the Rails REST controller pattern but with
             # a few differences
             #
             # * index - shows a list of WikiPages grouped by page or date
             # * new - not used
             # * create - not used
             # * show - will also show the form for creating a new wiki page
             # * edit - used to edit an existing or new page
             # * update - used to save a wiki page update to the database, including new pages
             # * destroy - normal
             #
             # Other member and collection methods are also used
             #
             # TODO: still being worked on
             class WikiController < ApplicationController
               default_search_scope :wiki_pages
               before_filter :find_wiki, :authorize
               before_filter :find_existing_or_new_page, :only => [:show, :edit, :update]
               before_filter :find_existing_page, :only => [:rename, :protect, :history, :diff, :annotate, :add_attachment, :destroy, :destroy_version]
               accept_api_auth :index, :show, :update, :destroy
+              before_filter :find_attachments, :only => [:preview]
               helper :attachments
               include AttachmentsHelper
               helper :watchers
               include Redmine::Export::PDF
               # List of pages, sorted alphabetically and by parent (hierarchy)
               def index
                 load_pages_for_index
                 respond_to do |format|
                   format.html {
                     @pages_by_parent_id = @pages.group_by(&:parent_id)
                   }
                   format.api
                 end
               end
               # List of page, by last update
               def date_index
                 load_pages_for_index
                 @pages_by_date = @pages.group_by {|p| p.updated_on.to_date}
               end
               # display a page (in editing mode if it doesn't exist)
               def show
                 if @page.new_record?
                   if User.current.allowed_to?(:edit_wiki_pages, @project) && editable? && !api_request?
                     edit
                     render :action => 'edit'
                   else
                     render_404
                   end
                   return
                 end
                 if params[:version] && !User.current.allowed_to?(:view_wiki_edits, @project)
                   deny_access
                   return
                 end
                 @content = @page.content_for_version(params[:version])
                 if User.current.allowed_to?(:export_wiki_pages, @project)
                   if params[:format] == 'pdf'
                     send_data(wiki_page_to_pdf(@page, @project), :type => 'application/pdf', :filename => "#{@page.title}.pdf")
                     return
                   elsif params[:format] == 'html'
                     export = render_to_string :action => 'export', :layout => false
                     send_data(export, :type => 'text/html', :filename => "#{@page.title}.html")
                     return
                   elsif params[:format] == 'txt'
                     send_data(@content.text, :type => 'text/plain', :filename => "#{@page.title}.txt")
                     return
                   end
                 end
                 @editable = editable?
                 @sections_editable = @editable && User.current.allowed_to?(:edit_wiki_pages, @page.project) &&
                   @content.current_version? &&
                   Redmine::WikiFormatting.supports_section_edit?
                 respond_to do |format|
                   format.html
                   format.api
                 end
               end
               # edit an existing page or a new one
               def edit
                 return render_403 unless editable?
                 if @page.new_record?
                   @page.content = WikiContent.new(:page => @page)
                   if params[:parent].present?
                     @page.parent = @page.wiki.find_page(params[:parent].to_s)
                   end
                 end
                 @content = @page.content_for_version(params[:version])
                 @content.text = initial_page_content(@page) if @content.text.blank?
                 # don't keep previous comment
                 @content.comments = nil
                 # To prevent StaleObjectError exception when reverting to a previous version
                 @content.version = @page.content.version
                 @text = @content.text
                 if params[:section].present? && Redmine::WikiFormatting.supports_section_edit?
                   @section = params[:section].to_i
                   @text, @section_hash = Redmine::WikiFormatting.formatter.new(@text).get_section(@section)
                   render_404 if @text.blank?
                 end
               end
               # Creates a new page or updates an existing one
               def update
                 return render_403 unless editable?
                 was_new_page = @page.new_record?
                 @page.content = WikiContent.new(:page => @page) if @page.new_record?
                 @page.safe_attributes = params[:wiki_page]
                 @content = @page.content
                 content_params = params[:content]
                 if content_params.nil? && params[:wiki_page].is_a?(Hash)
                   content_params = params[:wiki_page].slice(:text, :comments, :version)
                 end
                 content_params ||= {}
                 @content.comments = content_params[:comments]
                 @text = content_params[:text]
                 if params[:section].present? && Redmine::WikiFormatting.supports_section_edit?
                   @section = params[:section].to_i
                   @section_hash = params[:section_hash]
                   @content.text = Redmine::WikiFormatting.formatter.new(@content.text).update_section(params[:section].to_i, @text, @section_hash)
                 else
                   @content.version = content_params[:version] if content_params[:version]
                   @content.text = @text
                 end
                 @content.author = User.current
                 if @page.save_with_content
                   attachments = Attachment.attach_files(@page, params[:attachments])
                   render_attachment_warning_if_needed(@page)
                   call_hook(:controller_wiki_edit_after_save, { :params => params, :page => @page})
                   respond_to do |format|
                     format.html { redirect_to :action => 'show', :project_id => @project, :id => @page.title }
                     format.api {
                       if was_new_page
                         render :action => 'show', :status => :created, :location => url_for(:controller => 'wiki', :action => 'show', :project_id => @project, :id => @page.title)
                       else
                         render_api_ok
                       end
                     }
                   end
                 else
                   respond_to do |format|
                     format.html { render :action => 'edit' }
                     format.api { render_validation_errors(@content) }
                   end
                 end
               rescue ActiveRecord::StaleObjectError, Redmine::WikiFormatting::StaleSectionError
                 # Optimistic locking exception
                 respond_to do |format|
                   format.html {
                     flash.now[:error] = l(:notice_locking_conflict)
                     render :action => 'edit'
                   }
                   format.api { render_api_head :conflict }
                 end
               rescue ActiveRecord::RecordNotSaved
                 respond_to do |format|
                   format.html { render :action => 'edit' }
                   format.api { render_validation_errors(@content) }
                 end
               end
               # rename a page
               def rename
                 return render_403 unless editable?
                 @page.redirect_existing_links = true
                 # used to display the *original* title if some AR validation errors occur
                 @original_title = @page.pretty_title
                 if request.post? && @page.update_attributes(params[:wiki_page])
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to :action => 'show', :project_id => @project, :id => @page.title
                 end
               end
               def protect
                 @page.update_attribute :protected, params[:protected]
                 redirect_to :action => 'show', :project_id => @project, :id => @page.title
               end
               # show page history
               def history
                 @version_count = @page.content.versions.count
                 @version_pages = Paginator.new self, @version_count, per_page_option, params['page']
                 # don't load text
                 @versions = @page.content.versions.
                   select("id, author_id, comments, updated_on, version").
                   reorder('version DESC').
                   limit(@version_pages.items_per_page + 1).
                   offset(@version_pages.current.offset).
                   all
                 render :layout => false if request.xhr?
               end
               def diff
                 @diff = @page.diff(params[:version], params[:version_from])
                 render_404 unless @diff
               end
               def annotate
                 @annotate = @page.annotate(params[:version])
                 render_404 unless @annotate
               end
               # Removes a wiki page and its history
               # Children can be either set as root pages, removed or reassigned to another parent page
               def destroy
                 return render_403 unless editable?
                 @descendants_count = @page.descendants.size
                 if @descendants_count > 0
                   case params[:todo]
                   when 'nullify'
                     # Nothing to do
                   when 'destroy'
                     # Removes all its descendants
                     @page.descendants.each(&:destroy)
                   when 'reassign'
                     # Reassign children to another parent page
                     reassign_to = @wiki.pages.find_by_id(params[:reassign_to_id].to_i)
                     return unless reassign_to
                     @page.children.each do |child|
                       child.update_attribute(:parent, reassign_to)
                     end
                   else
                     @reassignable_to = @wiki.pages - @page.self_and_descendants
                     # display the destroy form if it's a user request
                     return unless api_request?
                   end
                 end
                 @page.destroy
                 respond_to do |format|
                   format.html { redirect_to :action => 'index', :project_id => @project }
                   format.api { render_api_ok }
                 end
               end
               def destroy_version
                 return render_403 unless editable?
                 @content = @page.content_for_version(params[:version])
                 @content.destroy
                 redirect_to_referer_or :action => 'history', :id => @page.title, :project_id => @project
               end
               # Export wiki to a single pdf or html file
               def export
                 @pages = @wiki.pages.all(:order => 'title', :include => [:content, {:attachments => :author}])
                 respond_to do |format|
                   format.html {
                     export = render_to_string :action => 'export_multiple', :layout => false
                     send_data(export, :type => 'text/html', :filename => "wiki.html")
                   }
                   format.pdf {
                     send_data(wiki_pages_to_pdf(@pages, @project), :type => 'application/pdf', :filename => "#{@project.identifier}.pdf")
                   }
                 end
               end
               def preview
                 page = @wiki.find_page(params[:id])
                 # page is nil when previewing a new page
                 return render_403 unless page.nil? || editable?(page)
                 if page
-                  @attachements = page.attachments
+                  @attachments += page.attachments
                   @previewed = page.content
                 end
                 @text = params[:content][:text]
                 render :partial => 'common/preview'
               end
               def add_attachment
                 return render_403 unless editable?
                 attachments = Attachment.attach_files(@page, params[:attachments])
                 render_attachment_warning_if_needed(@page)
                 redirect_to :action => 'show', :id => @page.title, :project_id => @project
               end
             private
               def find_wiki
                 @project = Project.find(params[:project_id])
                 @wiki = @project.wiki
                 render_404 unless @wiki
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Finds the requested page or a new page if it doesn't exist
               def find_existing_or_new_page
                 @page = @wiki.find_or_new_page(params[:id])
                 if @wiki.page_found_with_redirect?
                   redirect_to params.update(:id => @page.title)
                 end
               end
               # Finds the requested page and returns a 404 error if it doesn't exist
               def find_existing_page
                 @page = @wiki.find_page(params[:id])
                 if @page.nil?
                   render_404
                   return
                 end
                 if @wiki.page_found_with_redirect?
                   redirect_to params.update(:id => @page.title)
                 end
               end
               # Returns true if the current user is allowed to edit the page, otherwise false
               def editable?(page = @page)
                 page.editable_by?(User.current)
               end
               # Returns the default content of a new wiki page
               def initial_page_content(page)
                 helper = Redmine::WikiFormatting.helper_for(Setting.text_formatting)
                 extend helper unless self.instance_of?(helper)
                 helper.instance_method(:initial_page_content).bind(self).call(page)
               end
               def load_pages_for_index
                 @pages = @wiki.pages.with_updated_on.order("#{WikiPage.table_name}.title").includes(:wiki => :project).includes(:parent).all
               end
             end

app/helpers/application_helper.rb +3 -2

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'forwardable'
             require 'cgi'
             module ApplicationHelper
               include Redmine::WikiFormatting::Macros::Definitions
               include Redmine::I18n
               include GravatarHelper::PublicMethods
               extend Forwardable
               def_delegators :wiki_helper, :wikitoolbar_for, :heads_for_wiki_formatter
               # Return true if user is authorized for controller/action, otherwise false
               def authorize_for(controller, action)
                 User.current.allowed_to?({:controller => controller, :action => action}, @project)
               end
               # Display a link if user is authorized
               #
               # @param [String] name Anchor text (passed to link_to)
               # @param [Hash] options Hash params. This will checked by authorize_for to see if the user is authorized
               # @param [optional, Hash] html_options Options passed to link_to
               # @param [optional, Hash] parameters_for_method_reference Extra parameters for link_to
               def link_to_if_authorized(name, options = {}, html_options = nil, *parameters_for_method_reference)
                 link_to(name, options, html_options, *parameters_for_method_reference) if authorize_for(options[:controller] || params[:controller], options[:action])
               end
               # 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 = truncate(issue.subject, :length => 60)
                 else
                   subject = issue.subject
                   if options[:truncate]
                     subject = truncate(subject, :length => options[:truncate])
                   end
                 end
                 s = link_to text, issue_path(issue), :class => issue.css_classes, :title => title
                 s << h(": #{subject}") if subject
                 s = h("#{issue.project} - ") + s if options[:project]
                 s
               end
               # Generates a link to an attachment.
               # Options:
               # * :text - Link text (default to attachment filename)
               # * :download - Force download (default: false)
               def link_to_attachment(attachment, options={})
                 text = options.delete(:text) || attachment.filename
                 action = options.delete(:download) ? 'download' : 'show'
                 opt_only_path = {}
                 opt_only_path[:only_path] = (options[:only_path] == false ? false : true)
                 options.delete(:only_path)
                 link_to(h(text),
                        {:controller => 'attachments', :action => action,
                         :id => attachment, :filename => attachment.filename}.merge(opt_only_path),
                        options)
               end
               # Generates a link to a SCM revision
               # Options:
               # * :text - Link text (default to the formatted revision)
               def link_to_revision(revision, repository, options={})
                 if repository.is_a?(Project)
                   repository = repository.repository
                 end
                 text = options.delete(:text) || format_revision(revision)
                 rev = revision.respond_to?(:identifier) ? revision.identifier : revision
                 link_to(
                     h(text),
                     {:controller => 'repositories', :action => 'revision', :id => repository.project, :repository_id => repository.identifier_param, :rev => rev},
                     :title => l(:label_revision_id, format_revision(revision))
                   )
               end
               # Generates a link to a message
               def link_to_message(message, options={}, html_options = nil)
                 link_to(
                   h(truncate(message.subject, :length => 60)),
                   { :controller => 'messages', :action => 'show',
                     :board_id => message.board_id,
                     :id => (message.parent_id || message.id),
                     :r => (message.parent_id && message.id),
                     :anchor => (message.parent_id ? "message-#{message.id}" : nil)
                   }.merge(options),
                   html_options
                 )
               end
               # Generates a link to a project if active
               # Examples:
               #
               #   link_to_project(project)                          # => link to the specified project overview
               #   link_to_project(project, :action=>'settings')     # => link to project settings
               #   link_to_project(project, {:only_path => false}, :class => "project") # => 3rd arg adds html options
               #   link_to_project(project, {}, :class => "project") # => html options with default url (project overview)
               #
               def link_to_project(project, options={}, html_options = nil)
                 if project.archived?
                   h(project)
                 else
                   url = {:controller => 'projects', :action => 'show', :id => project}.merge(options)
                   link_to(h(project), url, html_options)
                 end
               end
               def 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(url_for(:controller => 'attachments', :action => 'thumbnail', :id => attachment)),
                   {:controller => 'attachments', :action => 'show', :id => attachment, :filename => attachment.filename},
                   :title => attachment.filename
               end
               def toggle_link(name, id, options={})
                 onclick = "$('##{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(text, :length => 100))
               end
               def format_activity_day(date)
                 date == User.current.today ? l(:label_today).titleize : format_date(date)
               end
               def format_activity_description(text)
                 h(truncate(text.to_s, :length => 120).gsub(%r{[\r\n]*<(pre|code)>.*$}m, '...')
                    ).gsub(/[\r\n]+/, "<br />").html_safe
               end
               def format_version_name(version)
                 if version.project == @project
                 	h(version)
                 else
                   h("#{version.project} - #{version}")
                 end
               end
               def due_date_distance_in_words(date)
                 if date
                   l((date < Date.today ? :label_roadmap_overdue : :label_roadmap_due_in), distance_of_date_in_words(Date.today, date))
                 end
               end
               # 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)
                 if tabs.any?
                   render :partial => 'common/tabs', :locals => {:tabs => tabs}
                 else
                   content_tag 'p', l(:label_no_data), :class => "nodata"
                 end
               end
               # Renders the project quick-jump box
               def render_project_jump_box
                 return unless User.current.logged?
                 projects = User.current.memberships.collect(&:project).compact.select(&:active?).uniq
                 if projects.any?
                   options =
                     ("<option value=''>#{ l(:label_jump_to_a_project) }</option>" +
                      '<option value="" disabled="disabled">---</option>').html_safe
                   options << project_tree_options_for_select(projects, :selected => @project) do |p|
                     { :value => project_path(:id => p, :jump => current_menu_item) }
                   end
                   select_tag('project_quick_jump_box', options, :onchange => 'if (this.value != \'\') { window.location = this.value; }')
                 end
               end
               def project_tree_options_for_select(projects, options = {})
                 s = ''
                 project_tree(projects) do |project, level|
                   name_prefix = (level > 0 ? '&nbsp;' * 2 * level + '&#187; ' : '').html_safe
                   tag_options = {:value => project.id}
                   if project == options[:selected] || (options[:selected].respond_to?(:include?) && options[:selected].include?(project))
                     tag_options[:selected] = 'selected'
                   else
                     tag_options[:selected] = nil
                   end
                   tag_options.merge!(yield(project)) if block_given?
                   s << content_tag('option', name_prefix + h(project), tag_options)
                 end
                 s.html_safe
               end
               # Yields the given block for each project with its level in the tree
               #
               # Wrapper for Project#project_tree
               def project_tree(projects, &block)
                 Project.project_tree(projects, &block)
               end
               def principals_check_box_tags(name, principals)
                 s = ''
                 principals.sort.each do |principal|
                   s << "<label>#{ check_box_tag name, principal.id, false } #{h principal}</label>\n"
                 end
                 s.html_safe
               end
               # Returns a string for users/groups option tags
               def principals_options_for_select(collection, selected=nil)
                 s = ''
                 if collection.include?(User.current)
                   s << content_tag('option', "<< #{l(:label_me)} >>", :value => User.current.id)
                 end
                 groups = ''
                 collection.sort.each do |element|
                   selected_attribute = ' selected="selected"' if option_value_selected?(element, selected)
                   (element.is_a?(Group) ? groups : s) << %(<option value="#{element.id}"#{selected_attribute}>#{h element.name}</option>)
                 end
                 unless groups.empty?
                   s << %(<optgroup label="#{h(l(:label_group_plural))}">#{groups}</optgroup>)
                 end
                 s.html_safe
               end
               # 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.include?(p)}
                 end
                 options
               end
               # Truncates and returns the string as a single line
               def truncate_single_line(string, *args)
                 truncate(string.to_s, *args).gsub(%r{[\r\n]+}m, ' ')
               end
               # Truncates at line break after 250 characters or options[:length]
               def truncate_lines(string, options={})
                 length = options[:length] || 250
                 if string.to_s =~ /\A(.{#{length}}.*?)$/m
                   "#{$1}..."
                 else
                   string
                 end
               end
               def anchor(text)
                 text.to_s.gsub(' ', '_')
               end
               def html_hours(text)
                 text.gsub(%r{(\d+)\.(\d+)}, '<span class="hours hours-int">\1</span><span class="hours hours-dec">.\2</span>').html_safe
               end
               def authoring(created, author, options={})
                 l(options[:label] || :label_added_time_by, :author => link_to_user(author), :age => time_tag(created)).html_safe
               end
               def time_tag(time)
                 text = distance_of_time_in_words(Time.now, time)
                 if @project
                   link_to(text, {:controller => 'activities', :action => 'index', :id => @project, :from => User.current.time_to_date(time)}, :title => format_time(time))
                 else
                   content_tag('acronym', text, :title => format_time(time))
                 end
               end
               def syntax_highlight_lines(name, content)
                 lines = []
                 syntax_highlight(name, content).each_line { |line| lines << line }
                 lines
               end
               def syntax_highlight(name, content)
                 Redmine::SyntaxHighlighting.highlight_by_filename(content, name)
               end
               def to_path_param(path)
                 str = path.to_s.split(%r{[/\\]}).select{|p| !p.blank?}.join("/")
                 str.blank? ? nil : str
               end
               def pagination_links_full(paginator, count=nil, options={})
                 page_param = options.delete(:page_param) || :page
                 per_page_links = options.delete(:per_page_links)
                 url_param = params.dup
                 html = ''
                 if paginator.current.previous
                   # \xc2\xab(utf-8) = &#171;
                   html << link_to_content_update(
                                "\xc2\xab " + l(:label_previous),
                                url_param.merge(page_param => paginator.current.previous)) + ' '
                 end
                 html << (pagination_links_each(paginator, options) do |n|
                   link_to_content_update(n.to_s, url_param.merge(page_param => n))
                 end || '')
                 if paginator.current.next
                   # \xc2\xbb(utf-8) = &#187;
                   html << ' ' + link_to_content_update(
                                   (l(:label_next) + " \xc2\xbb"),
                                   url_param.merge(page_param => paginator.current.next))
                 end
                 unless count.nil?
                   html << " (#{paginator.current.first_item}-#{paginator.current.last_item}/#{count})"
                   if per_page_links != false && links = per_page_links(paginator.items_per_page, count)
             	      html << " | #{links}"
                   end
                 end
                 html.html_safe
               end
               def per_page_links(selected=nil, item_count=nil)
                 values = Setting.per_page_options_array
                 if item_count && values.any?
                   if item_count > values.first
                     max = values.detect {|value| value >= item_count} || item_count
                   else
                     max = item_count
                   end
                   values = values.select {|value| value <= max || value == selected}
                 end
                 if values.empty? || (values.size == 1 && values.first == selected)
                   return nil
                 end
                 links = values.collect do |n|
                   n == selected ? n : link_to_content_update(n, params.merge(:per_page => n))
                 end
                 l(:label_display_per_page, links.join(', '))
               end
               def reorder_links(name, url, method = :post)
                 link_to(image_tag('2uparrow.png', :alt => l(:label_sort_highest)),
                         url.merge({"#{name}[move_to]" => 'highest'}),
                         :method => method, :title => l(:label_sort_highest)) +
                 link_to(image_tag('1uparrow.png',   :alt => l(:label_sort_higher)),
                         url.merge({"#{name}[move_to]" => 'higher'}),
                        :method => method, :title => l(:label_sort_higher)) +
                 link_to(image_tag('1downarrow.png', :alt => l(:label_sort_lower)),
                         url.merge({"#{name}[move_to]" => 'lower'}),
                         :method => method, :title => l(:label_sort_lower)) +
                 link_to(image_tag('2downarrow.png', :alt => l(:label_sort_lowest)),
                         url.merge({"#{name}[move_to]" => 'lowest'}),
                        :method => method, :title => l(:label_sort_lowest))
               end
               def breadcrumb(*args)
                 elements = args.flatten
                 elements.any? ? content_tag('p', (args.join(" \xc2\xbb ") + " \xc2\xbb ").html_safe, :class => 'breadcrumb') : nil
               end
               def other_formats_links(&block)
                 concat('<p class="other-formats">'.html_safe + l(:label_export_to))
                 yield Redmine::Views::OtherFormatsBuilder.new(self)
                 concat('</p>'.html_safe)
               end
               def page_header_title
                 if @project.nil? || @project.new_record?
                   h(Setting.app_title)
                 else
                   b = []
                   ancestors = (@project.root? ? [] : @project.ancestors.visible.all)
                   if ancestors.any?
                     root = ancestors.shift
                     b << link_to_project(root, {:jump => current_menu_item}, :class => 'root')
                     if ancestors.size > 2
                       b << "\xe2\x80\xa6"
                       ancestors = ancestors[-2, 2]
                     end
                     b += ancestors.collect {|p| link_to_project(p, {:jump => current_menu_item}, :class => 'ancestor') }
                   end
                   b << h(@project)
                   b.join(" \xc2\xbb ").html_safe
                 end
               end
               def html_title(*args)
                 if args.empty?
                   title = @html_title || []
                   title << @project.name if @project
                   title << Setting.app_title unless Setting.app_title == title.last
                   title.select {|t| !t.blank? }.join(' - ')
                 else
                   @html_title ||= []
                   @html_title += args
                 end
               end
               # Returns the theme, controller name, and action as css classes for the
               # HTML body.
               def body_css_classes
                 css = []
                 if theme = Redmine::Themes.theme(Setting.ui_theme)
                   css << 'theme-' + theme.name
                 end
                 css << 'controller-' + controller_name
                 css << 'action-' + action_name
                 css.join(' ')
               end
               def accesskey(s)
                 Redmine::AccessKeys.key_for s
               end
               # Formats text according to system settings.
               # 2 ways to call this method:
               # * with a String: textilizable(text, options)
               # * with an object and one of its attribute: textilizable(issue, :description, options)
               def textilizable(*args)
                 options = args.last.is_a?(Hash) ? args.pop : {}
                 case args.size
                 when 1
                   obj = options[:object]
                   text = args.shift
                 when 2
                   obj = args.shift
                   attr = args.shift
                   text = obj.send(attr).to_s
                 else
                   raise ArgumentError, 'invalid arguments to textilizable'
                 end
                 return '' if text.blank?
                 project = options[:project] || @project || (obj && obj.respond_to?(:project) ? obj.project : nil)
                 only_path = options.delete(:only_path) == false ? false : true
                 text = 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
-                if options[:attachments] || (obj && obj.respond_to?(:attachments))
+                if options[:attachments].present? || (obj && obj.respond_to?(:attachments))
-                  attachments = options[:attachments] || obj.attachments
+                  attachments = options[:attachments] || []
+                  attachments += obj.attachments if obj
                   text.gsub!(/src="([^\/"]+\.(bmp|gif|jpg|jpe|jpeg|png))"(\s+alt="([^"]*)")?/i) do |m|
                     filename, ext, alt, alttext = $1.downcase, $2, $3, $4
                     # search for the picture in attachments
                     if found = Attachment.latest_attach(attachments, filename)
                       image_url = url_for :only_path => only_path, :controller => 'attachments',
                                           :action => 'download', :id => found
                       desc = found.description.to_s.gsub('"', '')
                       if !desc.blank? && alttext.blank?
                         alt = " title=\"#{desc}\" alt=\"#{desc}\""
                       end
                       "src=\"#{image_url}\"#{alt}"
                     else
                       m
                     end
                   end
                 end
               end
               # Wiki links
               #
               # Examples:
               #   [[mypage]]
               #   [[mypage|mytext]]
               # wiki links can refer other project wikis, using project name or identifier:
               #   [[project:]] -> wiki starting page
               #   [[project:|mytext]]
               #   [[project:mypage]]
               #   [[project:mypage|mytext]]
               def parse_wiki_links(text, project, obj, attr, only_path, options)
                 text.gsub!(/(!)?(\[\[([^\]\n\|]+)(\|([^\]\n\|]+))?\]\])/) do |m|
                   link_project = project
                   esc, all, page, title = $1, $2, $3, $5
                   if esc.nil?
                     if page =~ /^([^\:]+)\:(.*)$/
                       link_project = Project.find_by_identifier($1) || Project.find_by_name($1)
                       page = $2
                       title ||= $1 if page.blank?
                     end
                     if link_project && link_project.wiki
                       # extract anchor
                       anchor = nil
                       if page =~ /^(.+?)\#(.+)$/
                         page, anchor = $1, $2
                       end
                       anchor = sanitize_anchor_name(anchor) if anchor.present?
                       # check if page exists
                       wiki_page = link_project.wiki.find_page(page)
                       url = if anchor.present? && wiki_page.present? && (obj.is_a?(WikiContent) || obj.is_a?(WikiContent::Version)) && obj.page == wiki_page
                         "##{anchor}"
                       else
                         case options[:wiki_links]
                         when :local; "#{page.present? ? Wiki.titleize(page) : ''}.html" + (anchor.present? ? "##{anchor}" : '')
                         when :anchor; "##{page.present? ? Wiki.titleize(page) : title}" + (anchor.present? ? "_#{anchor}" : '') # used for single-file wiki export
                         else
                           wiki_page_id = page.present? ? Wiki.titleize(page) : nil
                           parent = wiki_page.nil? && obj.is_a?(WikiContent) && obj.page && project == link_project ? obj.page.title : nil
                           url_for(:only_path => only_path, :controller => 'wiki', :action => 'show', :project_id => link_project,
                            :id => wiki_page_id, :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
               #
               #   Links can refer other objects from other projects, using project identifier:
               #     identifier:r52
               #     identifier:document:"Some document"
               #     identifier:version:1.0.0
               #     identifier:source:some/file
               def parse_redmine_links(text, project, obj, attr, only_path, options)
                 text.gsub!(%r{([\s\(,\-\[\>]|^)(!)?(([a-z0-9\-_]+):)?(attachment|document|version|forum|news|message|project|commit|source|export)?(((#)|((([a-z0-9\-]+)\|)?(r)))((\d+)((#note)?-(\d+))?)|(:)([^"\s<>][^\s<>]*?|"[^"]+?"))(?=(?=[[:punct:]][^A-Za-z0-9_/])|,|\s|\]|<|$)}) do |m|
                   leading, esc, project_prefix, project_identifier, prefix, repo_prefix, repo_identifier, sep, identifier, comment_suffix, comment_id = $1, $2, $3, $4, $5, $10, $11, $8 || $12 || $18, $14 || $19, $15, $17
                   link = nil
                   if project_identifier
                     project = Project.visible.find_by_identifier(project_identifier)
                   end
                   if esc.nil?
                     if prefix.nil? && sep == 'r'
                       if project
                         repository = nil
                         if repo_identifier
                           repository = project.repositories.detect {|repo| repo.identifier == repo_identifier}
                         else
                           repository = project.repository
                         end
                         # project.changesets.visible raises an SQL error because of a double join on repositories
                         if repository && (changeset = Changeset.visible.find_by_repository_id_and_revision(repository.id, identifier))
                           link = link_to(h("#{project_prefix}#{repo_prefix}r#{identifier}"), {:only_path => only_path, :controller => 'repositories', :action => 'revision', :id => project, :repository_id => repository.identifier_param, :rev => changeset.revision},
                                                     :class => 'changeset',
                                                     :title => truncate_single_line(changeset.comments, :length => 100))
                         end
                       end
                     elsif sep == '#'
                       oid = identifier.to_i
                       case prefix
                       when nil
                         if oid.to_s == identifier && issue = Issue.visible.find_by_id(oid, :include => :status)
                           anchor = comment_id ? "note-#{comment_id}" : nil
                           link = link_to("##{oid}", {:only_path => only_path, :controller => 'issues', :action => 'show', :id => oid, :anchor => anchor},
                                                     :class => issue.css_classes,
                                                     :title => "#{truncate(issue.subject, :length => 100)} (#{issue.status.name})")
                         end
                       when 'document'
                         if document = Document.visible.find_by_id(oid)
                           link = link_to h(document.title), {:only_path => only_path, :controller => 'documents', :action => 'show', :id => document},
                                                             :class => 'document'
                         end
                       when 'version'
                         if version = Version.visible.find_by_id(oid)
                           link = link_to h(version.name), {:only_path => only_path, :controller => 'versions', :action => 'show', :id => version},
                                                           :class => 'version'
                         end
                       when 'message'
                         if message = Message.visible.find_by_id(oid, :include => :parent)
                           link = link_to_message(message, {:only_path => only_path}, :class => 'message')
                         end
                       when 'forum'
                         if board = Board.visible.find_by_id(oid)
                           link = link_to h(board.name), {:only_path => only_path, :controller => 'boards', :action => 'show', :id => board, :project_id => board.project},
                                                          :class => 'board'
                         end
                       when 'news'
                         if news = News.visible.find_by_id(oid)
                           link = link_to h(news.title), {:only_path => only_path, :controller => 'news', :action => 'show', :id => news},
                                                         :class => 'news'
                         end
                       when 'project'
                         if p = Project.visible.find_by_id(oid)
                           link = link_to_project(p, {:only_path => only_path}, :class => 'project')
                         end
                       end
                     elsif sep == ':'
                       # removes the double quotes if any
                       name = identifier.gsub(%r{^"(.*)"$}, "\\1")
                       case prefix
                       when 'document'
                         if project && document = project.documents.visible.find_by_title(name)
                           link = link_to h(document.title), {:only_path => only_path, :controller => 'documents', :action => 'show', :id => document},
                                                             :class => 'document'
                         end
                       when 'version'
                         if project && version = project.versions.visible.find_by_name(name)
                           link = link_to h(version.name), {:only_path => only_path, :controller => 'versions', :action => 'show', :id => version},
                                                           :class => 'version'
                         end
                       when 'forum'
                         if project && board = project.boards.visible.find_by_name(name)
                           link = link_to h(board.name), {:only_path => only_path, :controller => 'boards', :action => 'show', :id => board, :project_id => board.project},
                                                          :class => 'board'
                         end
                       when 'news'
                         if project && news = project.news.visible.find_by_title(name)
                           link = link_to h(news.title), {:only_path => only_path, :controller => 'news', :action => 'show', :id => news},
                                                         :class => 'news'
                         end
                       when 'commit', 'source', 'export'
                         if project
                           repository = nil
                           if name =~ %r{^(([a-z0-9\-]+)\|)(.+)$}
                             repo_prefix, repo_identifier, name = $1, $2, $3
                             repository = project.repositories.detect {|repo| repo.identifier == repo_identifier}
                           else
                             repository = project.repository
                           end
                           if prefix == 'commit'
                             if repository && (changeset = Changeset.visible.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(h(changeset.comments), :length => 100)
                             end
                           else
                             if repository && User.current.allowed_to?(:browse_repository, project)
                               name =~ %r{^[/\\]*(.*?)(@([0-9a-f]+))?(#(L\d+))?$}
                               path, rev, anchor = $1, $3, $5
                               link = link_to h("#{project_prefix}#{prefix}:#{repo_prefix}#{name}"), {:controller => 'repositories', :action => (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] || (obj && obj.respond_to?(:attachments) ? obj.attachments : nil)
                         if attachments && attachment = attachments.detect {|a| a.filename == name }
                           link = link_to h(attachment.filename), {:only_path => only_path, :controller => 'attachments', :action => 'download', :id => attachment},
                                                                  :class => 'attachment'
                         end
                       when 'project'
                         if p = Project.visible.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)) + 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>\{\{([<>]?)toc\}\}<\/p>/i unless const_defined?(:TOC_RE)
               # Renders the TOC with given headings
               def replace_toc(text, headings)
                 text.gsub!(TOC_RE) do
                   # 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 $1 == '>'
                     div_class << ' left' if $1 == '<'
                     out = "<ul class=\"#{div_class}\"><li>"
                     root = headings.map(&:first).min
                     current = root
                     started = false
                     headings.each do |level, anchor, item|
                       if level > current
                         out << '<ul><li>' * (level - current)
                       elsif level < current
                         out << "</li></ul>\n" * (current - level) + "</li><li>"
                       elsif started
                         out << '</li><li>'
                       end
                       out << "<a href=\"##{anchor}\">#{item}</a>"
                       current = level
                       started = true
                     end
                     out << '</li></ul>' * (current - root)
                     out << '</li></ul>'
                   end
                 end
               end
               # Same as Rails' simple_format helper without using paragraphs
               def simple_format_without_paragraph(text)
                 text.to_s.
                   gsub(/\r\n?/, "\n").                    # \r\n and \r -> \n
                   gsub(/\n\n+/, "<br /><br />").          # 2+ newline  -> 2 br
                   gsub(/([^\n]\n)(?=[^\n])/, '\1<br />'). # 1 newline   -> br
                   html_safe
               end
               def lang_options_for_select(blank=true)
                 (blank ? [["(auto)", ""]] : []) + 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', :style => "width: #{width};").html_safe +
                   content_tag('p', legend, :class => 'pourcent').html_safe
               end
               def checked_image(checked=true)
                 if checked
                   image_tag 'toggle_check.png'
                 end
               end
               def context_menu(url)
                 unless @context_menu_included
                   content_for :header_tags do
                     javascript_include_tag('context_menu') +
                       stylesheet_link_tag('context_menu')
                   end
                   if l(:direction) == 'rtl'
                     content_for :header_tags do
                       stylesheet_link_tag('context_menu_rtl')
                     end
                   end
                   @context_menu_included = true
                 end
                 javascript_tag "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
                   @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};")
                     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
               def content_for(name, content = nil, &block)
                 @has_content ||= {}
                 @has_content[name] = true
                 super(name, content, &block)
               end
               def has_content?(name)
                 (@has_content && @has_content[name]) || false
               end
               def sidebar_content?
                 has_content?(:sidebar) || view_layouts_base_sidebar_hook_response.present?
               end
               def view_layouts_base_sidebar_hook_response
                 @view_layouts_base_sidebar_hook_response ||= call_hook(:view_layouts_base_sidebar)
               end
               def email_delivery_enabled?
                 !!ActionMailer::Base.perform_deliveries
               end
               # Returns the avatar image tag for the given +user+ if avatars are enabled
               # +user+ can be a User or a string that will be scanned for an email address (eg. 'joe <joe@foo.bar>')
               def avatar(user, options = { })
                 if Setting.gravatar_enabled?
                   options.merge!({:ssl => (request && request.ssl?), :default => Setting.gravatar_default})
                   email = nil
                   if user.respond_to?(:mail)
                     email = user.mail
                   elsif user.to_s =~ %r{<(.+?)>}
                     email = $1
                   end
                   return gravatar(email.to_s.downcase, options) unless email.blank? rescue nil
                 else
                   ''
                 end
               end
               def sanitize_anchor_name(anchor)
                 if ''.respond_to?(:encoding) || RUBY_PLATFORM == 'java'
                   anchor.gsub(%r{[^\p{Word}\s\-]}, '').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.7.2-ui-1.8.21-ujs-2.0.3', '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='#{image_path('/favicon.ico')}' />".html_safe
               end
               def robot_exclusion_tag
                 '<meta name="robots" content="noindex,follow,noarchive" />'.html_safe
               end
               # Returns true if arg is expected in the API response
               def include_in_api_response?(arg)
                 unless @included_in_api_response
                   param = params[:include]
                   @included_in_api_response = param.is_a?(Array) ? param.collect(&:to_s) : param.to_s.split(',')
                   @included_in_api_response.collect!(&:strip)
                 end
                 @included_in_api_response.include?(arg.to_s)
               end
               # Returns options or nil if nometa param or X-Redmine-Nometa header
               # was set in the request
               def api_meta(options)
                 if params[:nometa].present? || request.headers['X-Redmine-Nometa']
                   # compatibility mode for activeresource clients that raise
                   # an error when unserializing an array with attributes
                   nil
                 else
                   options
                 end
               end
               private
               def wiki_helper
                 helper = Redmine::WikiFormatting.helper_for(Setting.text_formatting)
                 extend helper
                 return self
               end
               def link_to_content_update(text, url_params = {}, html_options = {})
                 link_to(text, url_params, html_options)
               end
             end

app/models/attachment.rb +8 0

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require "digest/md5"
             class Attachment < ActiveRecord::Base
               belongs_to :container, :polymorphic => true
               belongs_to :author, :class_name => "User", :foreign_key => "author_id"
               validates_presence_of :filename, :author
               validates_length_of :filename, :maximum => 255
               validates_length_of :disk_filename, :maximum => 255
               validates_length_of :description, :maximum => 255
               validate :validate_max_file_size
               acts_as_event :title => :filename,
                             :url => Proc.new {|o| {:controller => 'attachments', :action => 'download', :id => o.id, :filename => o.filename}}
               acts_as_activity_provider :type => 'files',
                                         :permission => :view_files,
                                         :author_key => :author_id,
                                         :find_options => {:select => "#{Attachment.table_name}.*",
                                                           :joins => "LEFT JOIN #{Version.table_name} ON #{Attachment.table_name}.container_type='Version' AND #{Version.table_name}.id = #{Attachment.table_name}.container_id " +
                                                                     "LEFT JOIN #{Project.table_name} ON #{Version.table_name}.project_id = #{Project.table_name}.id OR ( #{Attachment.table_name}.container_type='Project' AND #{Attachment.table_name}.container_id = #{Project.table_name}.id )"}
               acts_as_activity_provider :type => 'documents',
                                         :permission => :view_documents,
                                         :author_key => :author_id,
                                         :find_options => {:select => "#{Attachment.table_name}.*",
                                                           :joins => "LEFT JOIN #{Document.table_name} ON #{Attachment.table_name}.container_type='Document' AND #{Document.table_name}.id = #{Attachment.table_name}.container_id " +
                                                                     "LEFT JOIN #{Project.table_name} ON #{Document.table_name}.project_id = #{Project.table_name}.id"}
               cattr_accessor :storage_path
               @@storage_path = Redmine::Configuration['attachments_storage_path'] || File.join(Rails.root, "files")
               cattr_accessor :thumbnails_storage_path
               @@thumbnails_storage_path = File.join(Rails.root, "tmp", "thumbnails")
               before_save :files_to_final_location
               after_destroy :delete_from_disk
               # Returns an unsaved copy of the attachment
               def copy(attributes=nil)
                 copy = self.class.new
                 copy.attributes = self.attributes.dup.except("id", "downloads")
                 copy.attributes = attributes if attributes
                 copy
               end
               def validate_max_file_size
                 if @temp_file && self.filesize > Setting.attachment_max_size.to_i.kilobytes
                   errors.add(:base, l(:error_attachment_too_big, :max_size => Setting.attachment_max_size.to_i.kilobytes))
                 end
               end
               def file=(incoming_file)
                 unless incoming_file.nil?
                   @temp_file = incoming_file
                   if @temp_file.size > 0
                     if @temp_file.respond_to?(:original_filename)
                       self.filename = @temp_file.original_filename
                       self.filename.force_encoding("UTF-8") if filename.respond_to?(:force_encoding)
                     end
                     if @temp_file.respond_to?(:content_type)
                       self.content_type = @temp_file.content_type.to_s.chomp
                     end
                     if content_type.blank? && filename.present?
                       self.content_type = Redmine::MimeType.of(filename)
                     end
                     self.filesize = @temp_file.size
                   end
                 end
               end
               def file
                 nil
               end
               def filename=(arg)
                 write_attribute :filename, sanitize_filename(arg.to_s)
                 if new_record? && disk_filename.blank?
                   self.disk_filename = Attachment.disk_filename(filename)
                 end
                 filename
               end
               # Copies the temporary file to its final location
               # and computes its MD5 hash
               def files_to_final_location
                 if @temp_file && (@temp_file.size > 0)
                   logger.info("Saving attachment '#{self.diskfile}' (#{@temp_file.size} bytes)")
                   md5 = Digest::MD5.new
                   File.open(diskfile, "wb") do |f|
                     if @temp_file.respond_to?(:read)
                       buffer = ""
                       while (buffer = @temp_file.read(8192))
                         f.write(buffer)
                         md5.update(buffer)
                       end
                     else
                       f.write(@temp_file)
                       md5.update(@temp_file)
                     end
                   end
                   self.digest = md5.hexdigest
                 end
                 @temp_file = nil
                 # Don't save the content type if it's longer than the authorized length
                 if self.content_type && self.content_type.length > 255
                   self.content_type = nil
                 end
               end
               # Deletes the file from the file system if it's not referenced by other attachments
               def delete_from_disk
                 if Attachment.where("disk_filename = ? AND id <> ?", disk_filename, id).empty?
                   delete_from_disk!
                 end
               end
               # Returns file's location on disk
               def diskfile
                 File.join(self.class.storage_path, disk_filename.to_s)
               end
               def title
                 title = filename.to_s
                 if description.present?
                   title << " (#{description})"
                 end
                 title
               end
               def increment_download
                 increment!(:downloads)
               end
               def project
                 container.try(:project)
               end
               def visible?(user=User.current)
+                if container_id
                   container && container.attachments_visible?(user)
+                else
+                  author == user
+                end
               end
               def deletable?(user=User.current)
+                if container_id
                   container && container.attachments_deletable?(user)
+                else
+                  author == user
+                end
               end
               def image?
                 !!(self.filename =~ /\.(bmp|gif|jpg|jpe|jpeg|png)$/i)
               end
               def thumbnailable?
                 image?
               end
               # Returns the full path the attachment thumbnail, or nil
               # if the thumbnail cannot be generated.
               def thumbnail(options={})
                 if thumbnailable? && readable?
                   size = options[:size].to_i
                   if size > 0
                     # Limit the number of thumbnails per image
                     size = (size / 50) * 50
                     # Maximum thumbnail size
                     size = 800 if size > 800
                   else
                     size = Setting.thumbnails_size.to_i
                   end
                   size = 100 unless size > 0
                   target = File.join(self.class.thumbnails_storage_path, "#{id}_#{digest}_#{size}.thumb")
                   begin
                     Redmine::Thumbnail.generate(self.diskfile, target, size)
                   rescue => e
                     logger.error "An error occured while generating thumbnail for #{disk_filename} to #{target}\nException was: #{e.message}" if logger
                     return nil
                   end
                 end
               end
               # Deletes all thumbnails
               def self.clear_thumbnails
                 Dir.glob(File.join(thumbnails_storage_path, "*.thumb")).each do |file|
                   File.delete file
                 end
               end
               def is_text?
                 Redmine::MimeType.is_type?('text', filename)
               end
               def is_diff?
                 self.filename =~ /\.(patch|diff)$/i
               end
               # Returns true if the file is readable
               def readable?
                 File.readable?(diskfile)
               end
               # Returns the attachment token
               def token
                 "#{id}.#{digest}"
               end
               # Finds an attachment that matches the given token and that has no container
               def self.find_by_token(token)
                 if token.to_s =~ /^(\d+)\.([0-9a-f]+)$/
                   attachment_id, attachment_digest = $1, $2
                   attachment = Attachment.where(:id => attachment_id, :digest => attachment_digest).first
                   if attachment && attachment.container.nil?
                     attachment
                   end
                 end
               end
               # Bulk attaches a set of files to an object
               #
               # Returns a Hash of the results:
               # :files => array of the attached files
               # :unsaved => array of the files that could not be attached
               def self.attach_files(obj, attachments)
                 result = obj.save_attachments(attachments, User.current)
                 obj.attach_saved_attachments
                 result
               end
               def self.latest_attach(attachments, filename)
                 attachments.sort_by(&:created_on).reverse.detect {
                   |att| att.filename.downcase == filename.downcase
                  }
               end
               def self.prune(age=1.day)
                 Attachment.where("created_on < ? AND (container_type IS NULL OR container_type = '')", Time.now - age).destroy_all
               end
               private
               # Physically deletes the file from the file system
               def delete_from_disk!
                 if disk_filename.present? && File.exist?(diskfile)
                   File.delete(diskfile)
                 end
               end
               def sanitize_filename(value)
                 # get only the filename, not the whole path
                 just_filename = value.gsub(/^.*(\\|\/)/, '')
                 # Finally, replace invalid characters with underscore
                 @filename = just_filename.gsub(/[\/\?\%\*\:\|\"\'<>]+/, '_')
               end
               # Returns an ASCII or hashed filename
               def self.disk_filename(filename)
                 timestamp = DateTime.now.strftime("%y%m%d%H%M%S")
                 ascii = ''
                 if filename =~ %r{^[a-zA-Z0-9_\.\-]*$}
                   ascii = filename
                 else
                   ascii = Digest::MD5.hexdigest(filename)
                   # keep the extension if any
                   ascii << $1 if filename =~ %r{(\.[a-zA-Z0-9]+)$}
                 end
                 while File.exist?(File.join(@@storage_path, "#{timestamp}_#{ascii}"))
                   timestamp.succ!
                 end
                 "#{timestamp}_#{ascii}"
               end
             end

app/views/attachments/_form.html.erb +21 -11

@@ -1,18 +1,28
		1	<span id="attachments_fields">
1	<% if defined?(container) && container && container.saved_attachments %>	2	<% if defined?(container) && container && container.saved_attachments %>
2	<% container.saved_attachments.each_with_index do \|attachment, i\| %>	3	<% container.saved_attachments.each_with_index do \|attachment, i\| %>
3	<span class="icon icon-attachment" style="display:block; line-height:1.5em;">	4	<span id="attachments_p<%= i %>">
4	<%= h(attachment.filename) %> (<%= number_to_human_size(attachment.filesize) %>)	5	<%= text_field_tag("attachments[p#{i}][filename]", attachment.filename, :class => 'filename') +
5	<%= hidden_field_tag "attachments[p#{i}][token]", "#{attachment.id}.#{attachment.digest}" %>	6	text_field_tag("attachments[p#{i}][description]", attachment.description, :maxlength => 255, :placeholder => l(:label_optional_description), :class => 'description') +
		7	link_to(' '.html_safe, attachment_path(attachment, :attachment_id => "p#{i}", :format => 'js'), :method => 'delete', :remote => true, :class => 'remove-upload') %>
		8	<%= hidden_field_tag "attachments[p#{i}][token]", "#{attachment.token}" %>
6	</span>	9	</span>
7	<% end %>	10	<% end %>
8	<% end %>	11	<% end %>
9	<span id="attachments_fields">
10	<span>
11	<%= file_field_tag 'attachments[1][file]', :id => nil, :class => 'file',
12	:onchange => "checkFileSize(this, #{Setting.attachment_max_size.to_i.kilobytes}, '#{escape_javascript(l(:error_attachment_too_big, :max_size => number_to_human_size(Setting.attachment_max_size.to_i.kilobytes)))}');" -%>
13	<%= text_field_tag 'attachments[1][description]', '', :id => nil, :class => 'description', :maxlength => 255, :placeholder => l(:label_optional_description) %>
14	<%= link_to_function(image_tag('delete.png'), 'removeFileField(this)', :title => (l(:button_delete))) %>
15	</span>	12	</span>
		13	<span class="add_attachment">
		14	<%= file_field_tag 'attachments_files',
		15	:id => nil,
		16	:multiple => true,
		17	:onchange => 'addInputFiles(this);',
		18	:data => {
		19	:max_file_size => Setting.attachment_max_size.to_i.kilobytes,
		20	:max_file_size_message => l(:error_attachment_too_big, :max_size => number_to_human_size(Setting.attachment_max_size.to_i.kilobytes)),
		21	:max_concurrent_uploads => Redmine::Configuration['max_concurrent_ajax_uploads'].to_i,
		22	:upload_path => uploads_path(:format => 'js'),
		23	:description_placeholder => l(:label_optional_description)
		24	} %>
		25	(<%= l(:label_max_size) %>: <%= number_to_human_size(Setting.attachment_max_size.to_i.kilobytes) %>)
16	</span>	26	</span>
17	<span class="add_attachment"><%= link_to l(:label_add_another_file), '#', :onclick => 'addFileField(); return false;', :class => 'add_attachment' %>	27
18	(<%= l(:label_max_size) %>: <%= number_to_human_size(Setting.attachment_max_size.to_i.kilobytes) %>)</span>	28	<%= javascript_include_tag 'attachments' %>

app/views/common/_preview.html.erb +1 -1

             <fieldset class="preview"><legend><%= l(:label_preview) %></legend>
-            <%= textilizable @text, :attachments => @attachements, :object => @previewed %>
+            <%= textilizable @text, :attachments => @attachments, :object => @previewed %>
             </fieldset>

app/views/previews/issue.html.erb +2 -2

             <% if @notes %>
               <fieldset class="preview"><legend><%= l(:field_notes) %></legend>
-                <%= textilizable @notes, :attachments => @attachements, :object => @issue %>
+                <%= textilizable @notes, :attachments => @attachments, :object => @issue %>
               </fieldset>
             <% end %>
             <% if @description %>
               <fieldset class="preview"><legend><%= l(:field_description) %></legend>
-                <%= textilizable @description, :attachments => @attachements, :object => @issue %>
+                <%= textilizable @description, :attachments => @attachments, :object => @issue %>
               </fieldset>
             <% end %>

config/configuration.yml.example +3 0

             # = Redmine configuration file
             #
             # Each environment has it's own configuration options.  If you are only
             # running in production, only the production block needs to be configured.
             # Environment specific configuration options override the default ones.
             #
             # Note that this file needs to be a valid YAML file.
             # DO NOT USE TABS! Use 2 spaces instead of tabs for identation.
             #
             # == Outgoing email settings (email_delivery setting)
             #
             # === Common configurations
             #
             # ==== Sendmail command
             #
             # production:
             #   email_delivery:
             #     delivery_method: :sendmail
             #
             # ==== Simple SMTP server at localhost
             #
             # production:
             #   email_delivery:
             #     delivery_method: :smtp
             #     smtp_settings:
             #       address: "localhost"
             #       port: 25
             #
             # ==== SMTP server at example.com using LOGIN authentication and checking HELO for foo.com
             #
             # production:
             #   email_delivery:
             #     delivery_method: :smtp
             #     smtp_settings:
             #       address: "example.com"
             #       port: 25
             #       authentication: :login
             #       domain: 'foo.com'
             #       user_name: 'myaccount'
             #       password: 'password'
             #
             # ==== SMTP server at example.com using PLAIN authentication
             #
             # production:
             #   email_delivery:
             #     delivery_method: :smtp
             #     smtp_settings:
             #       address: "example.com"
             #       port: 25
             #       authentication: :plain
             #       domain: 'example.com'
             #       user_name: 'myaccount'
             #       password: 'password'
             #
             # ==== SMTP server at using TLS (GMail)
             #
             # This might require some additional configuration. See the guides at:
             # http://www.redmine.org/projects/redmine/wiki/EmailConfiguration
             #
             # production:
             #   email_delivery:
             #     delivery_method: :smtp
             #     smtp_settings:
             #       enable_starttls_auto: true
             #       address: "smtp.gmail.com"
             #       port: 587
             #       domain: "smtp.gmail.com" # 'your.domain.com' for GoogleApps
             #       authentication: :plain
             #       user_name: "your_email@gmail.com"
             #       password: "your_password"
             #
             #
             # === More configuration options
             #
             # See the "Configuration options" at the following website for a list of the
             # full options allowed:
             #
             # http://wiki.rubyonrails.org/rails/pages/HowToSendEmailsWithActionMailer
             # default configuration options for all environments
             default:
               # Outgoing emails configuration (see examples above)
               email_delivery:
                 delivery_method: :smtp
                 smtp_settings:
                   address: smtp.example.net
                   port: 25
                   domain: example.net
                   authentication: :login
                   user_name: "redmine@example.net"
                   password: "redmine"
               # Absolute path to the directory where attachments are stored.
               # The default is the 'files' directory in your Redmine instance.
               # Your Redmine instance needs to have write permission on this
               # directory.
               # Examples:
               # attachments_storage_path: /var/redmine/files
               # attachments_storage_path: D:/redmine/files
               attachments_storage_path:
               # Configuration of the autologin cookie.
               # autologin_cookie_name: the name of the cookie (default: autologin)
               # autologin_cookie_path: the cookie path (default: /)
               # autologin_cookie_secure: true sets the cookie secure flag (default: false)
               autologin_cookie_name:
               autologin_cookie_path:
               autologin_cookie_secure:
               # Configuration of SCM executable command.
               #
               # Absolute path (e.g. /usr/local/bin/hg) or command name (e.g. hg.exe, bzr.exe)
               # On Windows + CRuby, *.cmd, *.bat (e.g. hg.cmd, bzr.bat) does not work.
               #
               # On Windows + JRuby 1.6.2, path which contains spaces does not work.
               # For example, "C:\Program Files\TortoiseHg\hg.exe".
               # If you want to this feature, you need to install to the path which does not contains spaces.
               # For example, "C:\TortoiseHg\hg.exe".
               #
               # Examples:
               # scm_subversion_command: svn                                       # (default: svn)
               # scm_mercurial_command:  C:\Program Files\TortoiseHg\hg.exe        # (default: hg)
               # scm_git_command:        /usr/local/bin/git                        # (default: git)
               # scm_cvs_command:        cvs                                       # (default: cvs)
               # scm_bazaar_command:     bzr.exe                                   # (default: bzr)
               # scm_darcs_command:      darcs-1.0.9-i386-linux                    # (default: darcs)
               #
               scm_subversion_command:
               scm_mercurial_command:
               scm_git_command:
               scm_cvs_command:
               scm_bazaar_command:
               scm_darcs_command:
               # Key used to encrypt sensitive data in the database (SCM and LDAP passwords).
               # If you don't want to enable data encryption, just leave it blank.
               # WARNING: losing/changing this key will make encrypted data unreadable.
               #
               # If you want to encrypt existing passwords in your database:
               # * set the cipher key here in your configuration file
               # * encrypt data using 'rake db:encrypt RAILS_ENV=production'
               #
               # If you have encrypted data and want to change this key, you have to:
               # * decrypt data using 'rake db:decrypt RAILS_ENV=production' first
               # * change the cipher key here in your configuration file
               # * encrypt data using 'rake db:encrypt RAILS_ENV=production'
               database_cipher_key:
               # Set this to false to disable plugins' assets mirroring on startup.
               # You can use `rake redmine:plugins:assets` to manually mirror assets
               # to public/plugin_assets when you install/upgrade a Redmine plugin.
               #
               #mirror_plugins_assets_on_startup: false
               # Your secret key for verifying cookie session data integrity. If you
               # change this key, all old sessions will become invalid! Make sure the
               # secret is at least 30 characters and all random, no regular words or
               # you'll be exposed to dictionary attacks.
               #
               # If you have a load-balancing Redmine cluster, you have to use the
               # same secret token on each machine.
               #secret_token: 'change it to a long random string'
               # Absolute path (e.g. /usr/bin/convert, c:/im/convert.exe) to
               # the ImageMagick's `convert` binary. Used to generate attachment thumbnails.
               #imagemagick_convert_command:
               # Configuration of RMagcik font.
               #
               # Redmine uses RMagcik in order to export gantt png.
               # You don't need this setting if you don't install RMagcik.
               #
               # In CJK (Chinese, Japanese and Korean),
               # in order to show CJK characters correctly,
               # you need to set this configuration.
               #
               # Because there is no standard font across platforms in CJK,
               # you need to set a font installed in your server.
               #
               # This setting is not necessary in non CJK.
               #
               # Examples for Japanese:
               #   Windows:
               #     rmagick_font_path: C:\windows\fonts\msgothic.ttc
               #   Linux:
               #     rmagick_font_path: /usr/share/fonts/ipa-mincho/ipam.ttf
               #
               rmagick_font_path:
+              # Maximum number of simultaneous AJAX uploads
+              #max_concurrent_ajax_uploads: 2
             # specific configuration options for production environment
             # that overrides the default ones
             production:
             # specific configuration options for development environment
             # that overrides the default ones
             development:

lib/redmine/configuration.rb +2 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             module Redmine
               module Configuration
                 # Configuration default values
                 @defaults = {
-                  'email_delivery' => nil
+                  'email_delivery' => nil,
+                  'max_concurrent_ajax_uploads' => 2
                 }
                 @config = nil
                 class << self
                   # Loads the Redmine configuration file
                   # Valid options:
                   # * <tt>:file</tt>: the configuration file to load (default: config/configuration.yml)
                   # * <tt>:env</tt>: the environment to load the configuration for (default: Rails.env)
                   def load(options={})
                     filename = options[:file] || File.join(Rails.root, 'config', 'configuration.yml')
                     env = options[:env] || Rails.env
                     @config = @defaults.dup
                     load_deprecated_email_configuration(env)
                     if File.file?(filename)
                       @config.merge!(load_from_yaml(filename, env))
                     end
                     # Compatibility mode for those who copy email.yml over configuration.yml
                     %w(delivery_method smtp_settings sendmail_settings).each do |key|
                       if value = @config.delete(key)
                         @config['email_delivery'] ||= {}
                         @config['email_delivery'][key] = value
                       end
                     end
                     if @config['email_delivery']
                       ActionMailer::Base.perform_deliveries = true
                       @config['email_delivery'].each do |k, v|
                         v.symbolize_keys! if v.respond_to?(:symbolize_keys!)
                         ActionMailer::Base.send("#{k}=", v)
                       end
                     end
                     @config
                   end
                   # Returns a configuration setting
                   def [](name)
                     load unless @config
                     @config[name]
                   end
                   # Yields a block with the specified hash configuration settings
                   def with(settings)
                     settings.stringify_keys!
                     load unless @config
                     was = settings.keys.inject({}) {|h,v| h[v] = @config[v]; h}
                     @config.merge! settings
                     yield if block_given?
                     @config.merge! was
                   end
                   private
                   def load_from_yaml(filename, env)
                     yaml = nil
                     begin
                       yaml = YAML::load_file(filename)
                     rescue ArgumentError
                       $stderr.puts "Your Redmine configuration file located at #{filename} is not a valid YAML file and could not be loaded."
                       exit 1
                     end
                     conf = {}
                     if yaml.is_a?(Hash)
                       if yaml['default']
                         conf.merge!(yaml['default'])
                       end
                       if yaml[env]
                         conf.merge!(yaml[env])
                       end
                     else
                       $stderr.puts "Your Redmine configuration file located at #{filename} is not a valid Redmine configuration file."
                       exit 1
                     end
                     conf
                   end
                   def load_deprecated_email_configuration(env)
                     deprecated_email_conf = File.join(Rails.root, 'config', 'email.yml')
                     if File.file?(deprecated_email_conf)
                       warn "Storing outgoing emails configuration in config/email.yml is deprecated. You should now store it in config/configuration.yml using the email_delivery setting."
                       @config.merge!({'email_delivery' => load_from_yaml(deprecated_email_conf, env)})
                     end
                   end
                 end
               end
             end

public/javascripts/application.js +7 -36

             /* Redmine - project management software
                Copyright (C) 2006-2012  Jean-Philippe Lang */
             function checkAll(id, checked) {
               if (checked) {
                 $('#'+id).find('input[type=checkbox]').attr('checked', true);
               } else {
                 $('#'+id).find('input[type=checkbox]').removeAttr('checked');
               }
             }
             function toggleCheckboxesBySelector(selector) {
               var all_checked = true;
               $(selector).each(function(index) {
                 if (!$(this).is(':checked')) { all_checked = false; }
               });
               $(selector).attr('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 td.field input[type=checkbox]').live('click',function(){
                 toggleFilter($(this).val());
               });
               $('#filters-table .toggle-multiselect').live('click',function(){
                 toggleMultiSelect($(this).siblings('select'));
               });
               $('#filters-table input[type=text]').live('keypress', 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);
               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];
               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');
               } else {
                 el.attr('multiple', true);
               }
             }
             function submit_query_form(id) {
               selectAllOptions("selected_columns");
               $('#'+id).submit();
             }
-            var fileFieldCount = 1;
-            function addFileField() {
-              var fields = $('#attachments_fields');
-              if (fields.children().length >= 10) return false;
-              fileFieldCount++;
-              var s = fields.children('span').first().clone();
-              s.children('input.file').attr('name', "attachments[" + fileFieldCount + "][file]").val('');
-              s.children('input.description').attr('name', "attachments[" + fileFieldCount + "][description]").val('');
-              fields.append(s);
-            function removeFileField(el) {
-              var fields = $('#attachments_fields');
-              var s = $(el).parents('span').first();
-              if (fields.children().length > 1) {
-                s.remove();
-              } else {
-                s.children('input.file').val('');
-                s.children('input.description').val('');
-            function checkFileSize(el, maxSize, message) {
-              var files = el.files;
-              if (files) {
-                for (var i=0; i<files.length; i++) {
-                  if (files[i].size > maxSize) {
-                    alert(message);
-                    el.value = "";
             function showTab(name) {
               $('div#content .tab-content').hide();
               $('div.tabs a').removeClass('selected');
               $('#tab-content-' + name).show();
               $('#tab-' + name).addClass('selected');
               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) {
                 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 = new Array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z');
               var key = '';
               for (i = 0; i < size; i++) {
                 key += chars[Math.floor(Math.random() * chars.length)];
               }
               return key;
             }
             // Can't use Rails' remote select because we need the form data
             function updateIssueFrom(url) {
               $.ajax({
                 url: url,
                 type: 'post',
                 data: $('#issue-form').serialize()
               });
             }
             function updateBulkEditFrom(url) {
               $.ajax({
                 url: url,
                 type: 'post',
                 data: $('#bulk_edit_form').serialize()
               });
             }
             function observeAutocompleteField(fieldId, url) {
               $(document).ready(function() {
                 $('#'+fieldId).autocomplete({
                   source: url,
                   minLength: 2
                 });
               });
             }
             function observeSearchfield(fieldId, targetId, url) {
               $('#'+fieldId).each(function() {
                 var $this = $(this);
                 $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){ $('#'+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 observeProjectModules() {
               var f = function() {
                 /* Hides trackers and issues custom fields on the new project form when issue_tracking module is disabled */
                 if ($('#project_enabled_module_names_issue_tracking').attr('checked')) {
                   $('#project_trackers').show();
                 }else{
                   $('#project_trackers').hide();
                 }
               };
               $(window).load(f);
               $('#project_enabled_module_names_issue_tracking').change(f);
             }
             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;
               $('form').submit(function(){
                 $('textarea').removeData('changed');
               });
               $('textarea').change(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;}
               };
             };
             $(document).ready(function(){
-              $('#ajax-indicator').bind('ajaxSend', function(){
+              $('#ajax-indicator').bind('ajaxSend', function(event, xhr, settings){
-                if ($('.ajax-loading').length == 0) {
+                if ($('.ajax-loading').length == 0 && settings.contentType != 'application/octet-stream') {
                   $('#ajax-indicator').show();
                 }
               });
               $('#ajax-indicator').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 blockEventPropagation(event) {
+              event.stopPropagation();
+              event.preventDefault();
+            }
             $(document).ready(hideOnLoad);
             $(document).ready(addFormObserversForDoubleSubmit);

public/stylesheets/application.css +9 -2

             html {overflow-y:scroll;}
             body { font-family: Verdana, sans-serif; font-size: 12px; color:#484848; margin: 0; padding: 0; min-width: 900px; }
             h1, h2, h3, h4 {font-family: "Trebuchet MS", Verdana, sans-serif;padding: 2px 10px 1px 0px;margin: 0 0 10px 0;}
             #content h1, h2, h3, h4 {color: #555;}
             h2, .wiki h1 {font-size: 20px;}
             h3, .wiki h2 {font-size: 16px;}
             h4, .wiki h3 {font-size: 13px;}
             h4 {border-bottom: 1px dotted #bbb;}
             /***** Layout *****/
             #wrapper {background: white;}
             #top-menu {background: #3E5B76; color: #fff; height:1.8em; font-size: 0.8em; padding: 2px 2px 0px 6px;}
             #top-menu ul {margin: 0;  padding: 0;}
             #top-menu li {
               float:left;
               list-style-type:none;
               margin: 0px 0px 0px 0px;
               padding: 0px 0px 0px 0px;
               white-space:nowrap;
             }
             #top-menu a {color: #fff; margin-right: 8px; font-weight: bold;}
             #top-menu #loggedas { float: right; margin-right: 0.5em; color: #fff; }
             #account {float:right;}
             #header {height:5.3em;margin:0;background-color:#628DB6;color:#f8f8f8; padding: 4px 8px 0px 6px; position:relative;}
             #header a {color:#f8f8f8;}
             #header h1 a.ancestor { font-size: 80%; }
             #quick-search {float:right;}
             #main-menu {position: absolute;  bottom: 0px;  left:6px; margin-right: -500px;}
             #main-menu ul {margin: 0;  padding: 0;}
             #main-menu li {
               float:left;
               list-style-type:none;
               margin: 0px 2px 0px 0px;
               padding: 0px 0px 0px 0px;
               white-space:nowrap;
             }
             #main-menu li a {
               display: block;
               color: #fff;
               text-decoration: none;
               font-weight: bold;
               margin: 0;
               padding: 4px 10px 4px 10px;
             }
             #main-menu li a:hover {background:#759FCF; color:#fff;}
             #main-menu li a.selected, #main-menu li a.selected:hover {background:#fff; color:#555;}
             #admin-menu ul {margin: 0;  padding: 0;}
             #admin-menu li {margin: 0;  padding: 0 0 6px 0; list-style-type:none;}
             #admin-menu a { background-position: 0% 40%; background-repeat: no-repeat; padding-left: 20px; padding-top: 2px; padding-bottom: 3px;}
             #admin-menu a.projects { background-image: url(../images/projects.png); }
             #admin-menu a.users { background-image: url(../images/user.png); }
             #admin-menu a.groups { background-image: url(../images/group.png); }
             #admin-menu a.roles { background-image: url(../images/database_key.png); }
             #admin-menu a.trackers { background-image: url(../images/ticket.png); }
             #admin-menu a.issue_statuses { background-image: url(../images/ticket_edit.png); }
             #admin-menu a.workflows { background-image: url(../images/ticket_go.png); }
             #admin-menu a.custom_fields { background-image: url(../images/textfield.png); }
             #admin-menu a.enumerations { background-image: url(../images/text_list_bullets.png); }
             #admin-menu a.settings { background-image: url(../images/changeset.png); }
             #admin-menu a.plugins { background-image: url(../images/plugin.png); }
             #admin-menu a.info { background-image: url(../images/help.png); }
             #admin-menu a.server_authentication { background-image: url(../images/server_key.png); }
             #main {background-color:#EEEEEE;}
             #sidebar{ float: right; width: 22%; position: relative; z-index: 9; padding: 0; margin: 0;}
             * html #sidebar{ width: 22%; }
             #sidebar h3{ font-size: 14px; margin-top:14px; color: #666;  }
             #sidebar hr{ width: 100%; margin: 0 auto; height: 1px; background: #ccc; border: 0; }
             * html #sidebar hr{ width: 95%; position: relative; left: -6px; color: #ccc; }
             #sidebar .contextual { margin-right: 1em; }
             #content { width: 75%; background-color: #fff; margin: 0px; border-right: 1px solid #ddd; padding: 6px 10px 10px 10px; z-index: 10; }
             * html #content{ width: 75%; padding-left: 0; margin-top: 0px; padding: 6px 10px 10px 10px;}
             html>body #content { min-height: 600px; }
             * html body #content { height: 600px; } /* IE */
             #main.nosidebar #sidebar{ display: none; }
             #main.nosidebar #content{ width: auto; border-right: 0; }
             #footer {clear: both; border-top: 1px solid #bbb; font-size: 0.9em; color: #aaa; padding: 5px; text-align:center; background:#fff;}
             #login-form table {margin-top:5em; padding:1em; margin-left: auto; margin-right: auto; border: 2px solid #FDBF3B; background-color:#FFEBC1; }
             #login-form table td {padding: 6px;}
             #login-form label {font-weight: bold;}
             #login-form input#username, #login-form input#password { width: 300px; }
             div.modal { border-radius:5px; background:#fff; z-index:50; padding:4px;}
             div.modal h3.title {display:none;}
             div.modal p.buttons {text-align:right; margin-bottom:0;}
             input#openid_url { background: url(../images/openid-bg.gif) no-repeat; background-color: #fff; background-position: 0 50%; padding-left: 18px; }
             .clear:after{ content: "."; display: block; height: 0; clear: both; visibility: hidden; }
             /***** Links *****/
             a, a:link, a:visited{ color: #169; text-decoration: none; }
             a:hover, a:active{ color: #c61a1a; text-decoration: underline;}
             a img{ border: 0; }
             a.issue.closed, a.issue.closed:link, a.issue.closed:visited { color: #999; text-decoration: line-through; }
             a.project.closed, a.project.closed:link, a.project.closed:visited { color: #999; }
             a.user.locked, a.user.locked:link, a.user.locked:visited {color: #999;}
             #sidebar a.selected {line-height:1.7em; padding:1px 3px 2px 2px; margin-left:-2px; background-color:#9DB9D5; color:#fff; border-radius:2px;}
             #sidebar a.selected:hover {text-decoration:none;}
             #admin-menu a {line-height:1.7em;}
             #admin-menu a.selected {padding-left: 20px !important; background-position: 2px 40%;}
             a.collapsible {padding-left: 12px; background: url(../images/arrow_expanded.png) no-repeat -3px 40%;}
             a.collapsible.collapsed {background: url(../images/arrow_collapsed.png) no-repeat -5px 40%;}
             a#toggle-completed-versions {color:#999;}
             /***** Tables *****/
             table.list { border: 1px solid #e4e4e4;  border-collapse: collapse; width: 100%; margin-bottom: 4px; }
             table.list th {  background-color:#EEEEEE; padding: 4px; white-space:nowrap; }
             table.list td { vertical-align: top; padding-right:10px; }
             table.list td.id { width: 2%; text-align: center;}
             table.list td.checkbox { width: 15px; padding: 2px 0 0 0; }
             table.list td.checkbox input {padding:0px;}
             table.list td.buttons { width: 15%; white-space:nowrap; text-align: right; }
             table.list td.buttons a { padding-right: 0.6em; }
             table.list caption { text-align: left; padding: 0.5em 0.5em 0.5em 0; }
             tr.project td.name a { white-space:nowrap; }
             tr.project.closed, tr.project.archived { color: #aaa; }
             tr.project.closed a, tr.project.archived a { color: #aaa; }
             tr.project.idnt td.name span {background: url(../images/bullet_arrow_right.png) no-repeat 0 50%; padding-left: 16px;}
             tr.project.idnt-1 td.name {padding-left: 0.5em;}
             tr.project.idnt-2 td.name {padding-left: 2em;}
             tr.project.idnt-3 td.name {padding-left: 3.5em;}
             tr.project.idnt-4 td.name {padding-left: 5em;}
             tr.project.idnt-5 td.name {padding-left: 6.5em;}
             tr.project.idnt-6 td.name {padding-left: 8em;}
             tr.project.idnt-7 td.name {padding-left: 9.5em;}
             tr.project.idnt-8 td.name {padding-left: 11em;}
             tr.project.idnt-9 td.name {padding-left: 12.5em;}
             tr.issue { text-align: center; white-space: nowrap; }
             tr.issue td.subject, tr.issue td.category, td.assigned_to, tr.issue td.string, tr.issue td.text, tr.issue td.relations { white-space: normal; }
             tr.issue td.subject, tr.issue td.relations { text-align: left; }
             tr.issue td.done_ratio table.progress { margin-left:auto; margin-right: auto;}
             tr.issue td.relations span {white-space: nowrap;}
             table.issues td.description {color:#777; font-size:90%; padding:4px 4px 4px 24px; text-align:left; white-space:normal;}
             table.issues td.description pre {white-space:normal;}
             tr.issue.idnt td.subject a {background: url(../images/bullet_arrow_right.png) no-repeat 0 50%; padding-left: 16px;}
             tr.issue.idnt-1 td.subject {padding-left: 0.5em;}
             tr.issue.idnt-2 td.subject {padding-left: 2em;}
             tr.issue.idnt-3 td.subject {padding-left: 3.5em;}
             tr.issue.idnt-4 td.subject {padding-left: 5em;}
             tr.issue.idnt-5 td.subject {padding-left: 6.5em;}
             tr.issue.idnt-6 td.subject {padding-left: 8em;}
             tr.issue.idnt-7 td.subject {padding-left: 9.5em;}
             tr.issue.idnt-8 td.subject {padding-left: 11em;}
             tr.issue.idnt-9 td.subject {padding-left: 12.5em;}
             tr.entry { border: 1px solid #f8f8f8; }
             tr.entry td { white-space: nowrap; }
             tr.entry td.filename { width: 30%; }
             tr.entry td.filename_no_report { width: 70%; }
             tr.entry td.size { text-align: right; font-size: 90%; }
             tr.entry td.revision, tr.entry td.author { text-align: center; }
             tr.entry td.age { text-align: right; }
             tr.entry.file td.filename a { margin-left: 16px; }
             tr.entry.file td.filename_no_report a { margin-left: 16px; }
             tr span.expander {background-image: url(../images/bullet_toggle_plus.png); padding-left: 8px; margin-left: 0; cursor: pointer;}
             tr.open span.expander {background-image: url(../images/bullet_toggle_minus.png);}
             tr.changeset { height: 20px }
             tr.changeset ul, ol { margin-top: 0px; margin-bottom: 0px; }
             tr.changeset td.revision_graph { width: 15%; background-color: #fffffb; }
             tr.changeset td.author { text-align: center; width: 15%; white-space:nowrap;}
             tr.changeset td.committed_on { text-align: center; width: 15%; white-space:nowrap;}
             table.files tr.file td { text-align: center; }
             table.files tr.file td.filename { text-align: left; padding-left: 24px; }
             table.files tr.file td.digest { font-size: 80%; }
             table.members td.roles, table.memberships td.roles { width: 45%; }
             tr.message { height: 2.6em; }
             tr.message td.subject { padding-left: 20px; }
             tr.message td.created_on { white-space: nowrap; }
             tr.message td.last_message { font-size: 80%; white-space: nowrap; }
             tr.message.locked td.subject { background: url(../images/locked.png) no-repeat 0 1px; }
             tr.message.sticky td.subject { background: url(../images/bullet_go.png) no-repeat 0 1px; font-weight: bold; }
             tr.version.closed, tr.version.closed a { color: #999; }
             tr.version td.name { padding-left: 20px; }
             tr.version.shared td.name { background: url(../images/link.png) no-repeat 0% 70%; }
             tr.version td.date, tr.version td.status, tr.version td.sharing { text-align: center; white-space:nowrap; }
             tr.user td { width:13%; }
             tr.user td.email { width:18%; }
             tr.user td { white-space: nowrap; }
             tr.user.locked, tr.user.registered { color: #aaa; }
             tr.user.locked a, tr.user.registered a { color: #aaa; }
             table.permissions td.role {color:#999;font-size:90%;font-weight:normal !important;text-align:center;vertical-align:bottom;}
             tr.wiki-page-version td.updated_on, tr.wiki-page-version td.author {text-align:center;}
             tr.time-entry { text-align: center; white-space: nowrap; }
             tr.time-entry td.issue, tr.time-entry td.comments { text-align: left; white-space: normal; }
             td.hours { text-align: right; font-weight: bold; padding-right: 0.5em; }
             td.hours .hours-dec { font-size: 0.9em; }
             table.plugins td { vertical-align: middle; }
             table.plugins td.configure { text-align: right; padding-right: 1em; }
             table.plugins span.name { font-weight: bold; display: block; margin-bottom: 6px; }
             table.plugins span.description { display: block; font-size: 0.9em; }
             table.plugins span.url { display: block; font-size: 0.9em; }
             table.list tbody tr.group td { padding: 0.8em 0 0.5em 0.3em; font-weight: bold; border-bottom: 1px solid #ccc; }
             table.list tbody tr.group span.count {position:relative; top:-1px; color:#fff; font-size:10px; background:#9DB9D5; padding:0px 6px 1px 6px; border-radius:3px; margin-left:4px;}
             tr.group a.toggle-all { color: #aaa; font-size: 80%; font-weight: normal; display:none;}
             tr.group:hover a.toggle-all { display:inline;}
             a.toggle-all:hover {text-decoration:none;}
             table.list tbody tr:hover { background-color:#ffffdd; }
             table.list tbody tr.group:hover { background-color:inherit; }
             table td {padding:2px;}
             table p {margin:0;}
             .odd {background-color:#f6f7f8;}
             .even {background-color: #fff;}
             a.sort { padding-right: 16px; background-position: 100% 50%; background-repeat: no-repeat; }
             a.sort.asc  { background-image: url(../images/sort_asc.png); }
             a.sort.desc { background-image: url(../images/sort_desc.png); }
             table.attributes { width: 100% }
             table.attributes th { vertical-align: top; text-align: left; }
             table.attributes td { vertical-align: top; }
             table.boards a.board, h3.comments { background: url(../images/comment.png) no-repeat 0% 50%; padding-left: 20px; }
             table.boards td.topic-count, table.boards td.message-count {text-align:center;}
             table.boards td.last-message {font-size:80%;}
             table.messages td.author, table.messages td.created_on, table.messages td.reply-count {text-align:center;}
             table.query-columns {
               border-collapse: collapse;
               border: 0;
             }
             table.query-columns td.buttons {
               vertical-align: middle;
               text-align: center;
             }
             td.center {text-align:center;}
             h3.version { background: url(../images/package.png) no-repeat 0% 50%; padding-left: 20px; }
             div.issues h3 { background: url(../images/ticket.png) no-repeat 0% 50%; padding-left: 20px; }
             div.members h3 { background: url(../images/group.png) no-repeat 0% 50%; padding-left: 20px; }
             div.news h3 { background: url(../images/news.png) no-repeat 0% 50%; padding-left: 20px; }
             div.projects h3 { background: url(../images/projects.png) no-repeat 0% 50%; padding-left: 20px; }
             #watchers ul {margin: 0;  padding: 0;}
             #watchers li {list-style-type:none;margin: 0px 2px 0px 0px; padding: 0px 0px 0px 0px;}
             #watchers select {width: 95%; display: block;}
             #watchers a.delete {opacity: 0.4;}
             #watchers a.delete:hover {opacity: 1;}
             #watchers img.gravatar {margin: 0 4px 2px 0;}
             span#watchers_inputs {overflow:auto; display:block;}
             span.search_for_watchers {display:block;}
             span.search_for_watchers, span.add_attachment {font-size:80%; line-height:2.5em;}
             span.search_for_watchers a, span.add_attachment a {padding-left:16px; background: url(../images/bullet_add.png) no-repeat 0 50%; }
             .highlight { background-color: #FCFD8D;}
             .highlight.token-1 { background-color: #faa;}
             .highlight.token-2 { background-color: #afa;}
             .highlight.token-3 { background-color: #aaf;}
             .box{
               padding:6px;
               margin-bottom: 10px;
               background-color:#f6f6f6;
               color:#505050;
               line-height:1.5em;
               border: 1px solid #e4e4e4;
             }
             div.square {
               border: 1px solid #999;
               float: left;
               margin: .3em .4em 0 .4em;
               overflow: hidden;
               width: .6em; height: .6em;
             }
             .contextual {float:right; white-space: nowrap; line-height:1.4em;margin-top:5px; padding-left: 10px; font-size:0.9em;}
             .contextual input, .contextual select {font-size:0.9em;}
             .message .contextual { margin-top: 0; }
             .splitcontent {overflow:auto;}
             .splitcontentleft{float:left; width:49%;}
             .splitcontentright{float:right; width:49%;}
             form {display: inline;}
             input, select {vertical-align: middle; margin-top: 1px; margin-bottom: 1px;}
             fieldset {border: 1px solid #e4e4e4; margin:0;}
             legend {color: #484848;}
             hr { width: 100%; height: 1px; background: #ccc; border: 0;}
             blockquote { font-style: italic; border-left: 3px solid #e0e0e0; padding-left: 0.6em; margin-left: 2.4em;}
             blockquote blockquote { margin-left: 0;}
             acronym  { border-bottom: 1px dotted; cursor: help; }
             textarea.wiki-edit {width:99%; resize:vertical;}
             li p {margin-top: 0;}
             div.issue {background:#ffffdd; padding:6px; margin-bottom:6px;border: 1px solid #d7d7d7;}
             p.breadcrumb { font-size: 0.9em; margin: 4px 0 4px 0;}
             p.subtitle { font-size: 0.9em; margin: -6px 0 12px 0; font-style: italic; }
             p.footnote { font-size: 0.9em; margin-top: 0px; margin-bottom: 0px; }
             div.issue div.subject div div { padding-left: 16px; }
             div.issue div.subject p {margin: 0; margin-bottom: 0.1em; font-size: 90%; color: #999;}
             div.issue div.subject>div>p { margin-top: 0.5em; }
             div.issue div.subject h3 {margin: 0; margin-bottom: 0.1em;}
             div.issue span.private { position:relative; bottom: 2px; text-transform: uppercase; background: #d22; color: #fff; font-weight:bold; padding: 0px 2px 0px 2px; font-size: 60%; margin-right: 2px; border-radius: 2px;}
             div.issue .next-prev-links {color:#999;}
             div.issue table.attributes th {width:22%;}
             div.issue table.attributes td {width:28%;}
             #issue_tree table.issues, #relations table.issues { border: 0; }
             #issue_tree td.checkbox, #relations td.checkbox {display:none;}
             #relations td.buttons {padding:0;}
             fieldset.collapsible { border-width: 1px 0 0 0; font-size: 0.9em; }
             fieldset.collapsible legend { padding-left: 16px; background: url(../images/arrow_expanded.png) no-repeat 0% 40%; cursor:pointer; }
             fieldset.collapsible.collapsed legend { background-image: url(../images/arrow_collapsed.png); }
             fieldset#date-range p { margin: 2px 0 2px 0; }
             fieldset#filters table { border-collapse: collapse; }
             fieldset#filters table td { padding: 0; vertical-align: middle; }
             fieldset#filters tr.filter { height: 2.1em; }
             fieldset#filters td.field { width:230px; }
             fieldset#filters td.operator { width:180px; }
             fieldset#filters td.operator select {max-width:170px;}
             fieldset#filters td.values { white-space:nowrap; }
             fieldset#filters td.values select {min-width:130px;}
             fieldset#filters td.values input {height:1em;}
             fieldset#filters td.add-filter { text-align: right; vertical-align: top; }
             .toggle-multiselect {background: url(../images/bullet_toggle_plus.png) no-repeat 0% 40%; padding-left:8px; margin-left:0; cursor:pointer;}
             .buttons { font-size: 0.9em; margin-bottom: 1.4em; margin-top: 1em; }
             div#issue-changesets {float:right; width:45%; margin-left: 1em; margin-bottom: 1em; background: #fff; padding-left: 1em; font-size: 90%;}
             div#issue-changesets div.changeset { padding: 4px;}
             div#issue-changesets div.changeset { border-bottom: 1px solid #ddd; }
             div#issue-changesets p { margin-top: 0; margin-bottom: 1em;}
             .journal ul.details img {margin:0 0 -3px 4px;}
             div.journal {overflow:auto;}
             div.journal.private-notes {border-left:2px solid #d22; padding-left:4px; margin-left:-6px;}
             div#activity dl, #search-results { margin-left: 2em; }
             div#activity dd, #search-results dd { margin-bottom: 1em; padding-left: 18px; font-size: 0.9em; }
             div#activity dt, #search-results dt { margin-bottom: 0px; padding-left: 20px; line-height: 18px; background-position: 0 50%; background-repeat: no-repeat; }
             div#activity dt.me .time { border-bottom: 1px solid #999; }
             div#activity dt .time { color: #777; font-size: 80%; }
             div#activity dd .description, #search-results dd .description { font-style: italic; }
             div#activity span.project:after, #search-results span.project:after { content: " -"; }
             div#activity dd span.description, #search-results dd span.description { display:block; color: #808080; }
             div#activity dt.grouped {margin-left:5em;}
             div#activity dd.grouped {margin-left:9em;}
             #search-results dd { margin-bottom: 1em; padding-left: 20px; margin-left:0px; }
             div#search-results-counts {float:right;}
             div#search-results-counts ul { margin-top: 0.5em; }
             div#search-results-counts  li { list-style-type:none; float: left; margin-left: 1em; }
             dt.issue { background-image: url(../images/ticket.png); }
             dt.issue-edit { background-image: url(../images/ticket_edit.png); }
             dt.issue-closed { background-image: url(../images/ticket_checked.png); }
             dt.issue-note { background-image: url(../images/ticket_note.png); }
             dt.changeset { background-image: url(../images/changeset.png); }
             dt.news { background-image: url(../images/news.png); }
             dt.message { background-image: url(../images/message.png); }
             dt.reply { background-image: url(../images/comments.png); }
             dt.wiki-page { background-image: url(../images/wiki_edit.png); }
             dt.attachment { background-image: url(../images/attachment.png); }
             dt.document { background-image: url(../images/document.png); }
             dt.project { background-image: url(../images/projects.png); }
             dt.time-entry { background-image: url(../images/time.png); }
             #search-results dt.issue.closed { background-image: url(../images/ticket_checked.png); }
             div#roadmap .related-issues { margin-bottom: 1em; }
             div#roadmap .related-issues td.checkbox { display: none; }
             div#roadmap .wiki h1:first-child { display: none; }
             div#roadmap .wiki h1 { font-size: 120%; }
             div#roadmap .wiki h2 { font-size: 110%; }
             body.controller-versions.action-show div#roadmap .related-issues {width:70%;}
             div#version-summary { float:right; width:28%; margin-left: 16px; margin-bottom: 16px; background-color: #fff; }
             div#version-summary fieldset { margin-bottom: 1em; }
             div#version-summary fieldset.time-tracking table { width:100%; }
             div#version-summary th, div#version-summary td.total-hours { text-align: right; }
             table#time-report td.hours, table#time-report th.period, table#time-report th.total { text-align: right; padding-right: 0.5em; }
             table#time-report tbody tr.subtotal { font-style: italic; color:#777;}
             table#time-report tbody tr.subtotal td.hours { color:#b0b0b0; }
             table#time-report tbody tr.total { font-weight: bold; background-color:#EEEEEE; border-top:1px solid #e4e4e4;}
             table#time-report .hours-dec { font-size: 0.9em; }
             div.wiki-page .contextual a {opacity: 0.4}
             div.wiki-page .contextual a:hover {opacity: 1}
             form .attributes select { width: 60%; }
             input#issue_subject { width: 99%; }
             select#issue_done_ratio { width: 95px; }
             ul.projects {margin:0; padding-left:1em;}
             ul.projects ul {padding-left:1.6em;}
             ul.projects.root {margin:0; padding:0;}
             ul.projects li {list-style-type:none;}
             #projects-index ul.projects ul.projects { border-left: 3px solid #e0e0e0; padding-left:1em;}
             #projects-index ul.projects li.root {margin-bottom: 1em;}
             #projects-index ul.projects li.child {margin-top: 1em;}
             #projects-index ul.projects div.root a.project { font-family: "Trebuchet MS", Verdana, sans-serif; font-weight: bold; font-size: 16px; margin: 0 0 10px 0; }
             .my-project { padding-left: 18px; background: url(../images/fav.png) no-repeat 0 50%; }
             #notified-projects ul, #tracker_project_ids ul {max-height:250px; overflow-y:auto;}
             #related-issues li img {vertical-align:middle;}
             ul.properties {padding:0; font-size: 0.9em; color: #777;}
             ul.properties li {list-style-type:none;}
             ul.properties li span {font-style:italic;}
             .total-hours { font-size: 110%; font-weight: bold; }
             .total-hours span.hours-int { font-size: 120%; }
             .autoscroll {overflow-x: auto; padding:1px; margin-bottom: 1.2em;}
             #user_login, #user_firstname, #user_lastname, #user_mail, #my_account_form select, #user_form select, #user_identity_url { width: 90%; }
             #workflow_copy_form select { width: 200px; }
             table.transitions td.enabled {background: #bfb;}
             table.fields_permissions select {font-size:90%}
             table.fields_permissions td.readonly {background:#ddd;}
             table.fields_permissions td.required {background:#d88;}
             textarea#custom_field_possible_values {width: 99%}
             input#content_comments {width: 99%}
             .pagination {font-size: 90%}
             p.pagination {margin-top:8px;}
             /***** Tabular forms ******/
             .tabular p{
               margin: 0;
               padding: 3px 0 3px 0;
               padding-left: 180px; /* width of left column containing the label elements */
               min-height: 1.8em;
               clear:left;
             }
             html>body .tabular p {overflow:hidden;}
             .tabular label{
               font-weight: bold;
               float: left;
               text-align: right;
               /* width of left column */
               margin-left: -180px;
               /* width of labels. Should be smaller than left column to create some right margin */
               width: 175px;
             }
             .tabular label.floating{
               font-weight: normal;
               margin-left: 0px;
               text-align: left;
               width: 270px;
             }
             .tabular label.block{
               font-weight: normal;
               margin-left: 0px !important;
               text-align: left;
               float: none;
               display: block;
               width: auto;
             }
             .tabular label.inline{
               font-weight: normal;
               float:none;
               margin-left: 5px !important;
               width: auto;
             }
             label.no-css {
               font-weight: inherit;
               float:none;
               text-align:left;
               margin-left:0px;
               width:auto;
             }
             input#time_entry_comments { width: 90%;}
             #preview fieldset {margin-top: 1em; background: url(../images/draft.png)}
             .tabular.settings p{ padding-left: 300px; }
             .tabular.settings label{ margin-left: -300px; width: 295px; }
             .tabular.settings textarea { width: 99%; }
             .settings.enabled_scm table {width:100%}
             .settings.enabled_scm td.scm_name{ font-weight: bold; }
             fieldset.settings label { display: block; }
             fieldset#notified_events .parent { padding-left: 20px; }
             span.required {color: #bb0000;}
             .summary {font-style: italic;}
-            #attachments_fields input.description {margin-left: 8px; width:340px;}
+            #attachments_fields input.description {margin-left:4px; width:340px;}
             #attachments_fields span {display:block; white-space:nowrap;}
-            #attachments_fields img {vertical-align: middle;}
+            #attachments_fields input.filename {border:0; height:1.8em; width:250px; color:#555; background-color:inherit; background:url(../images/attachment.png) no-repeat 1px 50%; padding-left:18px;}
+            #attachments_fields .ajax-waiting input.filename {background:url(../images/hourglass.png) no-repeat 0px 50%;}
+            #attachments_fields .ajax-loading input.filename {background:url(../images/loading.gif) no-repeat 0px 50%;}
+            #attachments_fields div.ui-progressbar { width: 100px; height:14px; margin: 2px 0 -5px 8px; display: inline-block; }
+            a.remove-upload {background: url(../images/delete.png) no-repeat 1px 50%; width:1px; display:inline-block; padding-left:16px;}
+            a.remove-upload:hover {text-decoration:none !important;}
+            div.fileover { background-color: lavender; }
             div.attachments { margin-top: 12px; }
             div.attachments p { margin:4px 0 2px 0; }
             div.attachments img { vertical-align: middle; }
             div.attachments span.author { font-size: 0.9em; color: #888; }
             div.thumbnails {margin-top:0.6em;}
             div.thumbnails div {background:#fff;border:2px solid #ddd;display:inline-block;margin-right:2px;}
             div.thumbnails img {margin: 3px;}
             p.other-formats { text-align: right; font-size:0.9em; color: #666; }
             .other-formats span + span:before { content: "| "; }
             a.atom { background: url(../images/feed.png) no-repeat 1px 50%; padding: 2px 0px 3px 16px; }
             em.info {font-style:normal;font-size:90%;color:#888;display:block;}
             em.info.error {padding-left:20px; background:url(../images/exclamation.png) no-repeat 0 50%;}
             textarea.text_cf {width:90%;}
             /* Project members tab */
             div#tab-content-members .splitcontentleft, div#tab-content-memberships .splitcontentleft, div#tab-content-users .splitcontentleft { width: 64% }
             div#tab-content-members .splitcontentright, div#tab-content-memberships .splitcontentright, div#tab-content-users .splitcontentright { width: 34% }
             div#tab-content-members fieldset, div#tab-content-memberships fieldset, div#tab-content-users fieldset { padding:1em; margin-bottom: 1em; }
             div#tab-content-members fieldset legend, div#tab-content-memberships fieldset legend, div#tab-content-users fieldset legend { font-weight: bold; }
             div#tab-content-members fieldset label, div#tab-content-memberships fieldset label, div#tab-content-users fieldset label { display: block; }
             div#tab-content-members fieldset div, div#tab-content-users fieldset div { max-height: 400px; overflow:auto; }
             #users_for_watcher {height: 200px; overflow:auto;}
             #users_for_watcher label {display: block;}
             table.members td.group { padding-left: 20px; background: url(../images/group.png) no-repeat 0% 50%; }
             input#principal_search, input#user_search {width:100%}
             input#principal_search, input#user_search {
               background: url(../images/magnifier.png) no-repeat 2px 50%; padding-left:20px;
               border:1px solid #9EB1C2; border-radius:3px; height:1.5em; width:95%;
             }
             input#principal_search.ajax-loading, input#user_search.ajax-loading {
               background-image: url(../images/loading.gif);
             }
             * html div#tab-content-members fieldset div { height: 450px; }
             /***** Flash & error messages ****/
             #errorExplanation, div.flash, .nodata, .warning, .conflict {
               padding: 4px 4px 4px 30px;
               margin-bottom: 12px;
               font-size: 1.1em;
               border: 2px solid;
             }
             div.flash {margin-top: 8px;}
             div.flash.error, #errorExplanation {
               background: url(../images/exclamation.png) 8px 50% no-repeat;
               background-color: #ffe3e3;
               border-color: #dd0000;
               color: #880000;
             }
             div.flash.notice {
               background: url(../images/true.png) 8px 5px no-repeat;
               background-color: #dfffdf;
               border-color: #9fcf9f;
               color: #005f00;
             }
             div.flash.warning, .conflict {
               background: url(../images/warning.png) 8px 5px no-repeat;
               background-color: #FFEBC1;
               border-color: #FDBF3B;
               color: #A6750C;
               text-align: left;
             }
             .nodata, .warning {
               text-align: center;
               background-color: #FFEBC1;
               border-color: #FDBF3B;
               color: #A6750C;
             }
             #errorExplanation ul { font-size: 0.9em;}
             #errorExplanation h2, #errorExplanation p { display: none; }
             .conflict-details {font-size:80%;}
             /***** Ajax indicator ******/
             #ajax-indicator {
             position: absolute; /* fixed not supported by IE */
             background-color:#eee;
             border: 1px solid #bbb;
             top:35%;
             left:40%;
             width:20%;
             font-weight:bold;
             text-align:center;
             padding:0.6em;
             z-index:100;
             opacity: 0.5;
             }
             html>body #ajax-indicator { position: fixed; }
             #ajax-indicator span {
             background-position: 0% 40%;
             background-repeat: no-repeat;
             background-image: url(../images/loading.gif);
             padding-left: 26px;
             vertical-align: bottom;
             }
             /***** Calendar *****/
             table.cal {border-collapse: collapse; width: 100%; margin: 0px 0 6px 0;border: 1px solid #d7d7d7;}
             table.cal thead th {width: 14%; background-color:#EEEEEE; padding: 4px; }
             table.cal thead th.week-number {width: auto;}
             table.cal tbody tr {height: 100px;}
             table.cal td {border: 1px solid #d7d7d7; vertical-align: top; font-size: 0.9em;}
             table.cal td.week-number { background-color:#EEEEEE; padding: 4px; border:none; font-size: 1em;}
             table.cal td p.day-num {font-size: 1.1em; text-align:right;}
             table.cal td.odd p.day-num {color: #bbb;}
             table.cal td.today {background:#ffffdd;}
             table.cal td.today p.day-num {font-weight: bold;}
             table.cal .starting a, p.cal.legend .starting {background: url(../images/bullet_go.png) no-repeat -1px -2px; padding-left:16px;}
             table.cal .ending a, p.cal.legend .ending {background: url(../images/bullet_end.png) no-repeat -1px -2px; padding-left:16px;}
             table.cal .starting.ending a, p.cal.legend .starting.ending {background: url(../images/bullet_diamond.png) no-repeat -1px -2px; padding-left:16px;}
             p.cal.legend span {display:block;}
             /***** Tooltips ******/
             .tooltip{position:relative;z-index:24;}
             .tooltip:hover{z-index:25;color:#000;}
             .tooltip span.tip{display: none; text-align:left;}
             div.tooltip:hover span.tip{
             display:block;
             position:absolute;
             top:12px; left:24px; width:270px;
             border:1px solid #555;
             background-color:#fff;
             padding: 4px;
             font-size: 0.8em;
             color:#505050;
             }
             img.ui-datepicker-trigger {
               cursor: pointer;
               vertical-align: middle;
               margin-left: 4px;
             }
             /***** Progress bar *****/
             table.progress {
               border-collapse: collapse;
               border-spacing: 0pt;
               empty-cells: show;
               text-align: center;
               float:left;
               margin: 1px 6px 1px 0px;
             }
             table.progress td { height: 1em; }
             table.progress td.closed { background: #BAE0BA none repeat scroll 0%; }
             table.progress td.done { background: #D3EDD3 none repeat scroll 0%; }
             table.progress td.todo { background: #eee none repeat scroll 0%; }
             p.pourcent {font-size: 80%;}
             p.progress-info {clear: left; font-size: 80%; margin-top:-4px; color:#777;}
             #roadmap table.progress td { height: 1.2em; }
             /***** Tabs *****/
             #content .tabs {height: 2.6em; margin-bottom:1.2em; position:relative; overflow:hidden;}
             #content .tabs ul {margin:0; position:absolute; bottom:0; padding-left:0.5em; width: 2000px; border-bottom: 1px solid #bbbbbb;}
             #content .tabs ul li {
               float:left;
               list-style-type:none;
               white-space:nowrap;
               margin-right:4px;
               background:#fff;
               position:relative;
               margin-bottom:-1px;
             }
             #content .tabs ul li a{
               display:block;
               font-size: 0.9em;
               text-decoration:none;
               line-height:1.3em;
               padding:4px 6px 4px 6px;
               border: 1px solid #ccc;
               border-bottom: 1px solid #bbbbbb;
               background-color: #f6f6f6;
               color:#999;
               font-weight:bold;
               border-top-left-radius:3px;
               border-top-right-radius:3px;
             }
             #content .tabs ul li a:hover {
               background-color: #ffffdd;
               text-decoration:none;
             }
             #content .tabs ul li a.selected {
               background-color: #fff;
               border: 1px solid #bbbbbb;
               border-bottom: 1px solid #fff;
               color:#444;
             }
             #content .tabs ul li a.selected:hover {background-color: #fff;}
             div.tabs-buttons { position:absolute; right: 0; width: 48px; height: 24px; background: white; bottom: 0; border-bottom: 1px solid #bbbbbb; }
             button.tab-left, button.tab-right {
               font-size: 0.9em;
               cursor: pointer;
               height:24px;
               border: 1px solid #ccc;
               border-bottom: 1px solid #bbbbbb;
               position:absolute;
               padding:4px;
               width: 20px;
               bottom: -1px;
             }
             button.tab-left {
               right: 20px;
               background: #eeeeee url(../images/bullet_arrow_left.png) no-repeat 50% 50%;
               border-top-left-radius:3px;
             }
             button.tab-right {
               right: 0;
               background: #eeeeee url(../images/bullet_arrow_right.png) no-repeat 50% 50%;
               border-top-right-radius:3px;
             }
             /***** Diff *****/
             .diff_out { background: #fcc; }
             .diff_out span { background: #faa; }
             .diff_in { background: #cfc; }
             .diff_in span { background: #afa; }
             .text-diff {
               padding: 1em;
               background-color:#f6f6f6;
               color:#505050;
               border: 1px solid #e4e4e4;
             }
             /***** Wiki *****/
             div.wiki table {
               border-collapse: collapse;
               margin-bottom: 1em;
             }
             div.wiki table, div.wiki td, div.wiki th {
               border: 1px solid #bbb;
               padding: 4px;
             }
             div.wiki .noborder, div.wiki .noborder td, div.wiki .noborder th {border:0;}
             div.wiki .external {
               background-position: 0% 60%;
               background-repeat: no-repeat;
               padding-left: 12px;
               background-image: url(../images/external.png);
             }
             div.wiki a.new {color: #b73535;}
             div.wiki ul, div.wiki ol {margin-bottom:1em;}
             div.wiki pre {
               margin: 1em 1em 1em 1.6em;
               padding: 8px;
               background-color: #fafafa;
               border: 1px solid #e2e2e2;
               width:auto;
               overflow-x: auto;
               overflow-y: hidden;
             }
             div.wiki ul.toc {
               background-color: #ffffdd;
               border: 1px solid #e4e4e4;
               padding: 4px;
               line-height: 1.2em;
               margin-bottom: 12px;
               margin-right: 12px;
               margin-left: 0;
               display: table
             }
             * html div.wiki ul.toc { width: 50%; } /* IE6 doesn't autosize div */
             div.wiki ul.toc.right { float: right; margin-left: 12px; margin-right: 0; width: auto; }
             div.wiki ul.toc.left  { float: left; margin-right: 12px; margin-left: 0; width: auto; }
             div.wiki ul.toc ul { margin: 0; padding: 0; }
             div.wiki ul.toc li {list-style-type:none; margin: 0; font-size:12px;}
             div.wiki ul.toc li li {margin-left: 1.5em; font-size:10px;}
             div.wiki ul.toc a {
               font-size: 0.9em;
               font-weight: normal;
               text-decoration: none;
               color: #606060;
             }
             div.wiki ul.toc a:hover { color: #c61a1a; text-decoration: underline;}
             a.wiki-anchor { display: none; margin-left: 6px; text-decoration: none; }
             a.wiki-anchor:hover { color: #aaa !important; text-decoration: none; }
             h1:hover a.wiki-anchor, h2:hover a.wiki-anchor, h3:hover a.wiki-anchor { display: inline; color: #ddd; }
             div.wiki img { vertical-align: middle; }
             /***** My page layout *****/
             .block-receiver {
               border:1px dashed #c0c0c0;
               margin-bottom: 20px;
               padding: 15px 0 15px 0;
             }
             .mypage-box {
               margin:0 0 20px 0;
               color:#505050;
               line-height:1.5em;
             }
             .handle {cursor: move;}
             a.close-icon {
               display:block;
               margin-top:3px;
               overflow:hidden;
               width:12px;
               height:12px;
               background-repeat: no-repeat;
               cursor:pointer;
               background-image:url('../images/close.png');
             }
             a.close-icon:hover {background-image:url('../images/close_hl.png');}
             /***** Gantt chart *****/
             .gantt_hdr {
               position:absolute;
               top:0;
               height:16px;
               border-top: 1px solid #c0c0c0;
               border-bottom: 1px solid #c0c0c0;
               border-right: 1px solid #c0c0c0;
               text-align: center;
               overflow: hidden;
             }
             .gantt_hdr.nwday {background-color:#f1f1f1;}
             .gantt_subjects { font-size: 0.8em; }
             .gantt_subjects div { line-height:16px;height:16px;overflow:hidden;white-space:nowrap;text-overflow: ellipsis; }
             .task {
               position: absolute;
               height:8px;
               font-size:0.8em;
               color:#888;
               padding:0;
               margin:0;
               line-height:16px;
               white-space:nowrap;
             }
             .task.label {width:100%;}
             .task.label.project, .task.label.version { font-weight: bold; }
             .task_late { background:#f66 url(../images/task_late.png); border: 1px solid #f66; }
             .task_done { background:#00c600 url(../images/task_done.png); border: 1px solid #00c600; }
             .task_todo { background:#aaa url(../images/task_todo.png); border: 1px solid #aaa; }
             .task_todo.parent { background: #888; border: 1px solid #888; height: 3px;}
             .task_late.parent, .task_done.parent { height: 3px;}
             .task.parent.marker.starting  { position: absolute; background: url(../images/task_parent_end.png) no-repeat 0 0; width: 8px; height: 16px; margin-left: -4px; left: 0px; top: -1px;}
             .task.parent.marker.ending { position: absolute; background: url(../images/task_parent_end.png) no-repeat 0 0; width: 8px; height: 16px; margin-left: -4px; right: 0px; top: -1px;}
             .version.task_late { background:#f66 url(../images/milestone_late.png); border: 1px solid #f66; height: 2px; margin-top: 3px;}
             .version.task_done { background:#00c600 url(../images/milestone_done.png); border: 1px solid #00c600; height: 2px; margin-top: 3px;}
             .version.task_todo { background:#fff url(../images/milestone_todo.png); border: 1px solid #fff; height: 2px; margin-top: 3px;}
             .version.marker { background-image:url(../images/version_marker.png); background-repeat: no-repeat; border: 0; margin-left: -4px; margin-top: 1px; }
             .project.task_late { background:#f66 url(../images/milestone_late.png); border: 1px solid #f66; height: 2px; margin-top: 3px;}
             .project.task_done { background:#00c600 url(../images/milestone_done.png); border: 1px solid #00c600; height: 2px; margin-top: 3px;}
             .project.task_todo { background:#fff url(../images/milestone_todo.png); border: 1px solid #fff; height: 2px; margin-top: 3px;}
             .project.marker { background-image:url(../images/project_marker.png); background-repeat: no-repeat; border: 0; margin-left: -4px; margin-top: 1px; }
             .version-behind-schedule a, .issue-behind-schedule a {color: #f66914;}
             .version-overdue a, .issue-overdue a, .project-overdue a {color: #f00;}
             /***** Icons *****/
             .icon {
               background-position: 0% 50%;
               background-repeat: no-repeat;
               padding-left: 20px;
               padding-top: 2px;
               padding-bottom: 3px;
             }
             .icon-add { background-image: url(../images/add.png); }
             .icon-edit { background-image: url(../images/edit.png); }
             .icon-copy { background-image: url(../images/copy.png); }
             .icon-duplicate { background-image: url(../images/duplicate.png); }
             .icon-del { background-image: url(../images/delete.png); }
             .icon-move { background-image: url(../images/move.png); }
             .icon-save { background-image: url(../images/save.png); }
             .icon-cancel { background-image: url(../images/cancel.png); }
             .icon-multiple { background-image: url(../images/table_multiple.png); }
             .icon-folder { background-image: url(../images/folder.png); }
             .open .icon-folder { background-image: url(../images/folder_open.png); }
             .icon-package { background-image: url(../images/package.png); }
             .icon-user { background-image: url(../images/user.png); }
             .icon-projects { background-image: url(../images/projects.png); }
             .icon-help { background-image: url(../images/help.png); }
             .icon-attachment  { background-image: url(../images/attachment.png); }
             .icon-history  { background-image: url(../images/history.png); }
             .icon-time  { background-image: url(../images/time.png); }
             .icon-time-add  { background-image: url(../images/time_add.png); }
             .icon-stats  { background-image: url(../images/stats.png); }
             .icon-warning  { background-image: url(../images/warning.png); }
             .icon-fav  { background-image: url(../images/fav.png); }
             .icon-fav-off  { background-image: url(../images/fav_off.png); }
             .icon-reload  { background-image: url(../images/reload.png); }
             .icon-lock  { background-image: url(../images/locked.png); }
             .icon-unlock  { background-image: url(../images/unlock.png); }
             .icon-checked  { background-image: url(../images/true.png); }
             .icon-details  { background-image: url(../images/zoom_in.png); }
             .icon-report  { background-image: url(../images/report.png); }
             .icon-comment  { background-image: url(../images/comment.png); }
             .icon-summary  { background-image: url(../images/lightning.png); }
             .icon-server-authentication { background-image: url(../images/server_key.png); }
             .icon-issue { background-image: url(../images/ticket.png); }
             .icon-zoom-in { background-image: url(../images/zoom_in.png); }
             .icon-zoom-out { background-image: url(../images/zoom_out.png); }
             .icon-passwd { background-image: url(../images/textfield_key.png); }
             .icon-test { background-image: url(../images/bullet_go.png); }
             .icon-file { background-image: url(../images/files/default.png); }
             .icon-file.text-plain { background-image: url(../images/files/text.png); }
             .icon-file.text-x-c { background-image: url(../images/files/c.png); }
             .icon-file.text-x-csharp { background-image: url(../images/files/csharp.png); }
             .icon-file.text-x-java { background-image: url(../images/files/java.png); }
             .icon-file.text-x-javascript { background-image: url(../images/files/js.png); }
             .icon-file.text-x-php { background-image: url(../images/files/php.png); }
             .icon-file.text-x-ruby { background-image: url(../images/files/ruby.png); }
             .icon-file.text-xml { background-image: url(../images/files/xml.png); }
             .icon-file.text-css { background-image: url(../images/files/css.png); }
             .icon-file.text-html { background-image: url(../images/files/html.png); }
             .icon-file.image-gif { background-image: url(../images/files/image.png); }
             .icon-file.image-jpeg { background-image: url(../images/files/image.png); }
             .icon-file.image-png { background-image: url(../images/files/image.png); }
             .icon-file.image-tiff { background-image: url(../images/files/image.png); }
             .icon-file.application-pdf { background-image: url(../images/files/pdf.png); }
             .icon-file.application-zip { background-image: url(../images/files/zip.png); }
             .icon-file.application-x-gzip { background-image: url(../images/files/zip.png); }
             img.gravatar {
               padding: 2px;
               border: solid 1px #d5d5d5;
               background: #fff;
               vertical-align: middle;
             }
             div.issue img.gravatar {
               float: left;
               margin: 0 6px 0 0;
               padding: 5px;
             }
             div.issue table img.gravatar {
               height: 14px;
               width: 14px;
               padding: 2px;
               float: left;
               margin: 0 0.5em 0 0;
             }
             h2 img.gravatar {margin: -2px 4px -4px 0;}
             h3 img.gravatar {margin: -4px 4px -4px 0;}
             h4 img.gravatar {margin: -6px 4px -4px 0;}
             td.username img.gravatar {margin: 0 0.5em 0 0; vertical-align: top;}
             #activity dt img.gravatar {float: left; margin: 0 1em 1em 0;}
             /* Used on 12px Gravatar img tags without the icon background */
             .icon-gravatar {float: left; margin-right: 4px;}
             #activity dt, .journal {clear: left;}
             .journal-link {float: right;}
             h2 img { vertical-align:middle; }
             .hascontextmenu { cursor: context-menu; }
             /************* CodeRay styles *************/
             .syntaxhl div {display: inline;}
             .syntaxhl .line-numbers {padding: 2px 4px 2px 4px; background-color: #eee; margin:0px 5px 0px 0px;}
             .syntaxhl .code pre { overflow: auto }
             .syntaxhl .debug { color: white !important; background: blue !important; }
             .syntaxhl .annotation { color:#007 }
             .syntaxhl .attribute-name { color:#b48 }
             .syntaxhl .attribute-value { color:#700 }
             .syntaxhl .binary { color:#509 }
             .syntaxhl .char .content { color:#D20 }
             .syntaxhl .char .delimiter { color:#710 }
             .syntaxhl .char { color:#D20 }
             .syntaxhl .class { color:#258; font-weight:bold }
             .syntaxhl .class-variable { color:#369 }
             .syntaxhl .color { color:#0A0 }
             .syntaxhl .comment { color:#385 }
             .syntaxhl .comment .char { color:#385 }
             .syntaxhl .comment .delimiter { color:#385 }
             .syntaxhl .complex { color:#A08 }
             .syntaxhl .constant { color:#258; font-weight:bold }
             .syntaxhl .decorator { color:#B0B }
             .syntaxhl .definition { color:#099; font-weight:bold }
             .syntaxhl .delimiter { color:black }
             .syntaxhl .directive { color:#088; font-weight:bold }
             .syntaxhl .doc { color:#970 }
             .syntaxhl .doc-string { color:#D42; font-weight:bold }
             .syntaxhl .doctype { color:#34b }
             .syntaxhl .entity { color:#800; font-weight:bold }
             .syntaxhl .error { color:#F00; background-color:#FAA }
             .syntaxhl .escape  { color:#666 }
             .syntaxhl .exception { color:#C00; font-weight:bold }
             .syntaxhl .float { color:#06D }
             .syntaxhl .function { color:#06B; font-weight:bold }
             .syntaxhl .global-variable { color:#d70 }
             .syntaxhl .hex { color:#02b }
             .syntaxhl .imaginary { color:#f00 }
             .syntaxhl .include { color:#B44; font-weight:bold }
             .syntaxhl .inline { background-color: hsla(0,0%,0%,0.07); color: black }
             .syntaxhl .inline-delimiter { font-weight: bold; color: #666 }
             .syntaxhl .instance-variable { color:#33B }
             .syntaxhl .integer  { color:#06D }
             .syntaxhl .key .char { color: #60f }
             .syntaxhl .key .delimiter { color: #404 }
             .syntaxhl .key { color: #606 }
             .syntaxhl .keyword { color:#939; font-weight:bold }
             .syntaxhl .label { color:#970; font-weight:bold }
             .syntaxhl .local-variable { color:#963 }
             .syntaxhl .namespace { color:#707; font-weight:bold }
             .syntaxhl .octal { color:#40E }
             .syntaxhl .operator { }
             .syntaxhl .predefined { color:#369; font-weight:bold }
             .syntaxhl .predefined-constant { color:#069 }
             .syntaxhl .predefined-type { color:#0a5; font-weight:bold }
             .syntaxhl .preprocessor { color:#579 }
             .syntaxhl .pseudo-class { color:#00C; font-weight:bold }
             .syntaxhl .regexp .content { color:#808 }
             .syntaxhl .regexp .delimiter { color:#404 }
             .syntaxhl .regexp .modifier { color:#C2C }
             .syntaxhl .regexp { background-color:hsla(300,100%,50%,0.06); }
             .syntaxhl .reserved { color:#080; font-weight:bold }
             .syntaxhl .shell .content { color:#2B2 }
             .syntaxhl .shell .delimiter { color:#161 }
             .syntaxhl .shell { background-color:hsla(120,100%,50%,0.06); }
             .syntaxhl .string .char { color: #46a }
             .syntaxhl .string .content { color: #46a }
             .syntaxhl .string .delimiter { color: #46a }
             .syntaxhl .string .modifier { color: #46a }
             .syntaxhl .symbol .content { color:#d33 }
             .syntaxhl .symbol .delimiter { color:#d33 }
             .syntaxhl .symbol { color:#d33 }
             .syntaxhl .tag { color:#070 }
             .syntaxhl .type { color:#339; font-weight:bold }
             .syntaxhl .value { color: #088; }
             .syntaxhl .variable  { color:#037 }
             .syntaxhl .insert { background: hsla(120,100%,50%,0.12) }
             .syntaxhl .delete { background: hsla(0,100%,50%,0.12) }
             .syntaxhl .change { color: #bbf; background: #007; }
             .syntaxhl .head { color: #f8f; background: #505 }
             .syntaxhl .head .filename { color: white; }
             .syntaxhl .delete .eyecatcher { background-color: hsla(0,100%,50%,0.2); border: 1px solid hsla(0,100%,45%,0.5); margin: -1px; border-bottom: none; border-top-left-radius: 5px; border-top-right-radius: 5px; }
             .syntaxhl .insert .eyecatcher { background-color: hsla(120,100%,50%,0.2); border: 1px solid hsla(120,100%,25%,0.5); margin: -1px; border-top: none; border-bottom-left-radius: 5px; border-bottom-right-radius: 5px; }
             .syntaxhl .insert .insert { color: #0c0; background:transparent; font-weight:bold }
             .syntaxhl .delete .delete { color: #c00; background:transparent; font-weight:bold }
             .syntaxhl .change .change { color: #88f }
             .syntaxhl .head .head { color: #f4f }
             /***** Media print specific styles *****/
             @media print {
               #top-menu, #header, #main-menu, #sidebar, #footer, .contextual, .other-formats { display:none; }
               #main { background: #fff; }
               #content { width: 99%; margin: 0; padding: 0; border: 0; background: #fff; overflow: visible !important;}
               #wiki_add_attachment { display:none; }
               .hide-when-print { display: none; }
               .autoscroll {overflow-x: visible;}
               table.list {margin-top:0.5em;}
               table.list th, table.list td {border: 1px solid #aaa;}
             }
             /* Accessibility specific styles */
             .hidden-for-sighted {
               position:absolute;
               left:-10000px;
               top:auto;
               width:1px;
               height:1px;
               overflow:hidden;
             }

test/functional/attachments_controller_test.rb +10 -1

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class AttachmentsControllerTest < ActionController::TestCase
               fixtures :users, :projects, :roles, :members, :member_roles,
                        :enabled_modules, :issues, :trackers, :attachments,
                        :versions, :wiki_pages, :wikis, :documents
               def setup
                 User.current = nil
                 set_fixtures_attachments_directory
               end
               def teardown
                 set_tmp_attachments_directory
               end
               def test_show_diff
                 ['inline', 'sbs'].each do |dt|
                   # 060719210727_changeset_utf8.diff
                   get :show, :id => 14, :type => dt
                   assert_response :success
                   assert_template 'diff'
                   assert_equal 'text/html', @response.content_type
                   assert_tag 'th',
                     :attributes => {:class => /filename/},
                     :content => /issues_controller.rb\t\(révision 1484\)/
                   assert_tag 'td',
                     :attributes => {:class => /line-code/},
                     :content => /Demande créée avec succès/
                 end
                 set_tmp_attachments_directory
               end
               def test_show_diff_replcace_cannot_convert_content
                 with_settings :repositories_encodings => 'UTF-8' do
                   ['inline', 'sbs'].each do |dt|
                     # 060719210727_changeset_iso8859-1.diff
                     get :show, :id => 5, :type => dt
                     assert_response :success
                     assert_template 'diff'
                     assert_equal 'text/html', @response.content_type
                     assert_tag 'th',
                       :attributes => {:class => "filename"},
                       :content => /issues_controller.rb\t\(r\?vision 1484\)/
                     assert_tag 'td',
                       :attributes => {:class => /line-code/},
                       :content => /Demande cr\?\?e avec succ\?s/
                   end
                 end
                 set_tmp_attachments_directory
               end
               def test_show_diff_latin_1
                 with_settings :repositories_encodings => 'UTF-8,ISO-8859-1' do
                   ['inline', 'sbs'].each do |dt|
                     # 060719210727_changeset_iso8859-1.diff
                     get :show, :id => 5, :type => dt
                     assert_response :success
                     assert_template 'diff'
                     assert_equal 'text/html', @response.content_type
                     assert_tag 'th',
                       :attributes => {:class => "filename"},
                       :content => /issues_controller.rb\t\(révision 1484\)/
                     assert_tag 'td',
                       :attributes => {:class => /line-code/},
                       :content => /Demande créée avec succès/
                   end
                 end
                 set_tmp_attachments_directory
               end
               def test_save_diff_type
                 user1 = User.find(1)
                 user1.pref[:diff_type] = nil
                 user1.preference.save
                 user = User.find(1)
                 assert_nil user.pref[:diff_type]
                 @request.session[:user_id] = 1 # admin
                 get :show, :id => 5
                 assert_response :success
                 assert_template 'diff'
                 user.reload
                 assert_equal "inline", user.pref[:diff_type]
                 get :show, :id => 5, :type => 'sbs'
                 assert_response :success
                 assert_template 'diff'
                 user.reload
                 assert_equal "sbs", user.pref[:diff_type]
               end
               def test_diff_show_filename_in_mercurial_export
                 set_tmp_attachments_directory
                 a = Attachment.new(:container => Issue.find(1),
                                    :file => uploaded_test_file("hg-export.diff", "text/plain"),
                                    :author => User.find(1))
                 assert a.save
                 assert_equal 'hg-export.diff', a.filename
                 get :show, :id => a.id, :type => 'inline'
                 assert_response :success
                 assert_template 'diff'
                 assert_equal 'text/html', @response.content_type
                 assert_select 'th.filename', :text => 'test1.txt'
               end
               def test_show_text_file
                 get :show, :id => 4
                 assert_response :success
                 assert_template 'file'
                 assert_equal 'text/html', @response.content_type
                 set_tmp_attachments_directory
               end
               def test_show_text_file_utf_8
                 set_tmp_attachments_directory
                 a = Attachment.new(:container => Issue.find(1),
                                    :file => uploaded_test_file("japanese-utf-8.txt", "text/plain"),
                                    :author => User.find(1))
                 assert a.save
                 assert_equal 'japanese-utf-8.txt', a.filename
                 str_japanese = "\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e"
                 str_japanese.force_encoding('UTF-8') if str_japanese.respond_to?(:force_encoding)
                 get :show, :id => a.id
                 assert_response :success
                 assert_template 'file'
                 assert_equal 'text/html', @response.content_type
                 assert_tag :tag => 'th',
                            :content => '1',
                            :attributes => { :class => 'line-num' },
                            :sibling => { :tag => 'td', :content => /#{str_japanese}/ }
               end
               def test_show_text_file_replcace_cannot_convert_content
                 set_tmp_attachments_directory
                 with_settings :repositories_encodings => 'UTF-8' do
                   a = Attachment.new(:container => Issue.find(1),
                                      :file => uploaded_test_file("iso8859-1.txt", "text/plain"),
                                      :author => User.find(1))
                   assert a.save
                   assert_equal 'iso8859-1.txt', a.filename
                   get :show, :id => a.id
                   assert_response :success
                   assert_template 'file'
                   assert_equal 'text/html', @response.content_type
                   assert_tag :tag => 'th',
                              :content => '7',
                              :attributes => { :class => 'line-num' },
                              :sibling => { :tag => 'td', :content => /Demande cr\?\?e avec succ\?s/ }
                 end
               end
               def test_show_text_file_latin_1
                 set_tmp_attachments_directory
                 with_settings :repositories_encodings => 'UTF-8,ISO-8859-1' do
                   a = Attachment.new(:container => Issue.find(1),
                                      :file => uploaded_test_file("iso8859-1.txt", "text/plain"),
                                      :author => User.find(1))
                   assert a.save
                   assert_equal 'iso8859-1.txt', a.filename
                   get :show, :id => a.id
                   assert_response :success
                   assert_template 'file'
                   assert_equal 'text/html', @response.content_type
                   assert_tag :tag => 'th',
                              :content => '7',
                              :attributes => { :class => 'line-num' },
                              :sibling => { :tag => 'td', :content => /Demande créée avec succès/ }
                   end
               end
               def test_show_text_file_should_send_if_too_big
                 Setting.file_max_size_displayed = 512
                 Attachment.find(4).update_attribute :filesize, 754.kilobyte
                 get :show, :id => 4
                 assert_response :success
                 assert_equal 'application/x-ruby', @response.content_type
                 set_tmp_attachments_directory
               end
               def test_show_other
                 get :show, :id => 6
                 assert_response :success
                 assert_equal 'application/octet-stream', @response.content_type
                 set_tmp_attachments_directory
               end
               def test_show_file_from_private_issue_without_permission
                 get :show, :id => 15
                 assert_redirected_to '/login?back_url=http%3A%2F%2Ftest.host%2Fattachments%2F15'
                 set_tmp_attachments_directory
               end
               def test_show_file_from_private_issue_with_permission
                 @request.session[:user_id] = 2
                 get :show, :id => 15
                 assert_response :success
                 assert_tag 'h2', :content => /private.diff/
                 set_tmp_attachments_directory
               end
-              def test_show_file_without_container_should_be_denied
+              def test_show_file_without_container_should_be_allowed_to_author
                 set_tmp_attachments_directory
                 attachment = Attachment.create!(:file => uploaded_test_file("testfile.txt", "text/plain"), :author_id => 2)
                 @request.session[:user_id] = 2
                 get :show, :id => attachment.id
+                assert_response 200
+              end
+              def test_show_file_without_container_should_be_allowed_to_author
+                set_tmp_attachments_directory
+                attachment = Attachment.create!(:file => uploaded_test_file("testfile.txt", "text/plain"), :author_id => 2)
+                @request.session[:user_id] = 3
+                get :show, :id => attachment.id
                 assert_response 403
               end
               def test_show_invalid_should_respond_with_404
                 get :show, :id => 999
                 assert_response 404
               end
               def test_download_text_file
                 get :download, :id => 4
                 assert_response :success
                 assert_equal 'application/x-ruby', @response.content_type
                 set_tmp_attachments_directory
               end
               def test_download_version_file_with_issue_tracking_disabled
                 Project.find(1).disable_module! :issue_tracking
                 get :download, :id => 9
                 assert_response :success
               end
               def test_download_should_assign_content_type_if_blank
                 Attachment.find(4).update_attribute(:content_type, '')
                 get :download, :id => 4
                 assert_response :success
                 assert_equal 'text/x-ruby', @response.content_type
                 set_tmp_attachments_directory
               end
               def test_download_missing_file
                 get :download, :id => 2
                 assert_response 404
                 set_tmp_attachments_directory
               end
               def test_download_should_be_denied_without_permission
                 get :download, :id => 7
                 assert_redirected_to '/login?back_url=http%3A%2F%2Ftest.host%2Fattachments%2Fdownload%2F7'
                 set_tmp_attachments_directory
               end
               if convert_installed?
                 def test_thumbnail
                   Attachment.clear_thumbnails
                   @request.session[:user_id] = 2
                   get :thumbnail, :id => 16
                   assert_response :success
                   assert_equal 'image/png', response.content_type
                 end
                 def test_thumbnail_should_not_exceed_maximum_size
                   Redmine::Thumbnail.expects(:generate).with {|source, target, size| size == 800}
                   @request.session[:user_id] = 2
                   get :thumbnail, :id => 16, :size => 2000
                 end
                 def test_thumbnail_should_round_size
                   Redmine::Thumbnail.expects(:generate).with {|source, target, size| size == 250}
                   @request.session[:user_id] = 2
                   get :thumbnail, :id => 16, :size => 260
                 end
                 def test_thumbnail_should_return_404_for_non_image_attachment
                   @request.session[:user_id] = 2
                   get :thumbnail, :id => 15
                   assert_response 404
                 end
                 def test_thumbnail_should_return_404_if_thumbnail_generation_failed
                   Attachment.any_instance.stubs(:thumbnail).returns(nil)
                   @request.session[:user_id] = 2
                   get :thumbnail, :id => 16
                   assert_response 404
                 end
                 def test_thumbnail_should_be_denied_without_permission
                   get :thumbnail, :id => 16
                   assert_redirected_to '/login?back_url=http%3A%2F%2Ftest.host%2Fattachments%2Fthumbnail%2F16'
                 end
               else
                 puts '(ImageMagick convert not available)'
               end
               def test_destroy_issue_attachment
                 set_tmp_attachments_directory
                 issue = Issue.find(3)
                 @request.session[:user_id] = 2
                 assert_difference 'issue.attachments.count', -1 do
                   assert_difference 'Journal.count' do
                     delete :destroy, :id => 1
                     assert_redirected_to '/projects/ecookbook'
                   end
                 end
                 assert_nil Attachment.find_by_id(1)
                 j = Journal.first(:order => 'id DESC')
                 assert_equal issue, j.journalized
                 assert_equal 'attachment', j.details.first.property
                 assert_equal '1', j.details.first.prop_key
                 assert_equal 'error281.txt', j.details.first.old_value
                 assert_equal User.find(2), j.user
               end
               def test_destroy_wiki_page_attachment
                 set_tmp_attachments_directory
                 @request.session[:user_id] = 2
                 assert_difference 'Attachment.count', -1 do
                   delete :destroy, :id => 3
                   assert_response 302
                 end
               end
               def test_destroy_project_attachment
                 set_tmp_attachments_directory
                 @request.session[:user_id] = 2
                 assert_difference 'Attachment.count', -1 do
                   delete :destroy, :id => 8
                   assert_response 302
                 end
               end
               def test_destroy_version_attachment
                 set_tmp_attachments_directory
                 @request.session[:user_id] = 2
                 assert_difference 'Attachment.count', -1 do
                   delete :destroy, :id => 9
                   assert_response 302
                 end
               end
               def test_destroy_without_permission
                 set_tmp_attachments_directory
                 assert_no_difference 'Attachment.count' do
                   delete :destroy, :id => 3
                 end
                 assert_response 302
                 assert Attachment.find_by_id(3)
               end
             end

test/functional/issues_controller_test.rb 0 0

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

test/functional/issues_controller_transaction_test.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             require 'issues_controller'
             class IssuesControllerTransactionTest < ActionController::TestCase
               tests IssuesController
               fixtures :projects,
                        :users,
                        :roles,
                        :members,
                        :member_roles,
                        :issues,
                        :issue_statuses,
                        :versions,
                        :trackers,
                        :projects_trackers,
                        :issue_categories,
                        :enabled_modules,
                        :enumerations,
                        :attachments,
                        :workflows,
                        :custom_fields,
                        :custom_values,
                        :custom_fields_projects,
                        :custom_fields_trackers,
                        :time_entries,
                        :journals,
                        :journal_details,
                        :queries
               self.use_transactional_fixtures = false
               def setup
                 User.current = nil
               end
               def test_update_stale_issue_should_not_update_the_issue
                 issue = Issue.find(2)
                 @request.session[:user_id] = 2
                 assert_no_difference 'Journal.count' do
                   assert_no_difference 'TimeEntry.count' do
                     put :update,
                           :id => issue.id,
                           :issue => {
                             :fixed_version_id => 4,
                             :notes => 'My notes',
                             :lock_version => (issue.lock_version - 1)
                           },
                           :time_entry => { :hours => '2.5', :comments => '', :activity_id => TimeEntryActivity.first.id }
                   end
                 end
                 assert_response :success
                 assert_template 'edit'
                 assert_select 'div.conflict'
                 assert_select 'input[name=?][value=?]', 'conflict_resolution', 'overwrite'
                 assert_select 'input[name=?][value=?]', 'conflict_resolution', 'add_notes'
                 assert_select 'label' do
                   assert_select 'input[name=?][value=?]', 'conflict_resolution', 'cancel'
                   assert_select 'a[href=/issues/2]'
                 end
               end
               def test_update_stale_issue_should_save_attachments
                 set_tmp_attachments_directory
                 issue = Issue.find(2)
                 @request.session[:user_id] = 2
                 assert_no_difference 'Journal.count' do
                   assert_no_difference 'TimeEntry.count' do
                     assert_difference 'Attachment.count' do
                       put :update,
                             :id => issue.id,
                             :issue => {
                               :fixed_version_id => 4,
                               :notes => 'My notes',
                               :lock_version => (issue.lock_version - 1)
                             },
                             :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain')}},
                             :time_entry => { :hours => '2.5', :comments => '', :activity_id => TimeEntryActivity.first.id }
                     end
                   end
                 end
                 assert_response :success
                 assert_template 'edit'
                 attachment = Attachment.first(:order => 'id DESC')
                 assert_tag 'input', :attributes => {:name => 'attachments[p0][token]', :value => attachment.token}
-                assert_tag 'span', :content => /testfile.txt/
+                assert_tag 'input', :attributes => {:name => 'attachments[p0][filename]', :value => 'testfile.txt'}
               end
               def test_update_stale_issue_without_notes_should_not_show_add_notes_option
                 issue = Issue.find(2)
                 @request.session[:user_id] = 2
                 put :update, :id => issue.id,
                       :issue => {
                         :fixed_version_id => 4,
                         :notes => '',
                         :lock_version => (issue.lock_version - 1)
                       }
                 assert_tag 'div', :attributes => {:class => 'conflict'}
                 assert_tag 'input', :attributes => {:name => 'conflict_resolution', :value => 'overwrite'}
                 assert_no_tag 'input', :attributes => {:name => 'conflict_resolution', :value => 'add_notes'}
                 assert_tag 'input', :attributes => {:name => 'conflict_resolution', :value => 'cancel'}
               end
               def test_update_stale_issue_should_show_conflicting_journals
                 @request.session[:user_id] = 2
                 put :update, :id => 1,
                       :issue => {
                         :fixed_version_id => 4,
                         :notes => '',
                         :lock_version => 2
                       },
                       :last_journal_id => 1
                 assert_not_nil assigns(:conflict_journals)
                 assert_equal 1, assigns(:conflict_journals).size
                 assert_equal 2, assigns(:conflict_journals).first.id
                 assert_tag 'div', :attributes => {:class => 'conflict'},
                   :descendant => {:content => /Some notes with Redmine links/}
               end
               def test_update_stale_issue_without_previous_journal_should_show_all_journals
                 @request.session[:user_id] = 2
                 put :update, :id => 1,
                       :issue => {
                         :fixed_version_id => 4,
                         :notes => '',
                         :lock_version => 2
                       },
                       :last_journal_id => ''
                 assert_not_nil assigns(:conflict_journals)
                 assert_equal 2, assigns(:conflict_journals).size
                 assert_tag 'div', :attributes => {:class => 'conflict'},
                   :descendant => {:content => /Some notes with Redmine links/}
                 assert_tag 'div', :attributes => {:class => 'conflict'},
                   :descendant => {:content => /Journal notes/}
               end
               def test_update_stale_issue_should_show_private_journals_with_permission_only
                 journal = Journal.create!(:journalized => Issue.find(1), :notes => 'Privates notes', :private_notes => true, :user_id => 1)
                 @request.session[:user_id] = 2
                 put :update, :id => 1, :issue => {:fixed_version_id => 4, :lock_version => 2}, :last_journal_id => ''
                 assert_include journal, assigns(:conflict_journals)
                 Role.find(1).remove_permission! :view_private_notes
                 put :update, :id => 1, :issue => {:fixed_version_id => 4, :lock_version => 2}, :last_journal_id => ''
                 assert_not_include journal, assigns(:conflict_journals)
               end
               def test_update_stale_issue_with_overwrite_conflict_resolution_should_update
                 @request.session[:user_id] = 2
                 assert_difference 'Journal.count' do
                   put :update, :id => 1,
                         :issue => {
                           :fixed_version_id => 4,
                           :notes => 'overwrite_conflict_resolution',
                           :lock_version => 2
                         },
                         :conflict_resolution => 'overwrite'
                 end
                 assert_response 302
                 issue = Issue.find(1)
                 assert_equal 4, issue.fixed_version_id
                 journal = Journal.first(:order => 'id DESC')
                 assert_equal 'overwrite_conflict_resolution', journal.notes
                 assert journal.details.any?
               end
               def test_update_stale_issue_with_add_notes_conflict_resolution_should_update
                 @request.session[:user_id] = 2
                 assert_difference 'Journal.count' do
                   put :update, :id => 1,
                         :issue => {
                           :fixed_version_id => 4,
                           :notes => 'add_notes_conflict_resolution',
                           :lock_version => 2
                         },
                         :conflict_resolution => 'add_notes'
                 end
                 assert_response 302
                 issue = Issue.find(1)
                 assert_nil issue.fixed_version_id
                 journal = Journal.first(:order => 'id DESC')
                 assert_equal 'add_notes_conflict_resolution', journal.notes
                 assert journal.details.empty?
               end
               def test_update_stale_issue_with_cancel_conflict_resolution_should_redirect_without_updating
                 @request.session[:user_id] = 2
                 assert_no_difference 'Journal.count' do
                   put :update, :id => 1,
                         :issue => {
                           :fixed_version_id => 4,
                           :notes => 'add_notes_conflict_resolution',
                           :lock_version => 2
                         },
                         :conflict_resolution => 'cancel'
                 end
                 assert_redirected_to '/issues/1'
                 issue = Issue.find(1)
                 assert_nil issue.fixed_version_id
               end
               def test_put_update_with_spent_time_and_failure_should_not_add_spent_time
                 @request.session[:user_id] = 2
                 assert_no_difference('TimeEntry.count') do
                   put :update,
                        :id => 1,
                        :issue => { :subject => '' },
                        :time_entry => { :hours => '2.5', :comments => 'should not be added', :activity_id => TimeEntryActivity.first.id }
                   assert_response :success
                 end
                 assert_select 'input[name=?][value=?]', 'time_entry[hours]', '2.5'
                 assert_select 'input[name=?][value=?]', 'time_entry[comments]', 'should not be added'
                 assert_select 'select[name=?]', 'time_entry[activity_id]' do
                   assert_select 'option[value=?][selected=selected]', TimeEntryActivity.first.id
                 end
               end
               def test_index_should_rescue_invalid_sql_query
                 IssueQuery.any_instance.stubs(:statement).returns("INVALID STATEMENT")
                 get :index
                 assert_response 500
                 assert_tag 'p', :content => /An error occurred/
                 assert_nil session[:query]
                 assert_nil session[:issues_index_sort]
               end
             end

General Comments 0

Write
Preview

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

No TODOs yet

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

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