/* jQuery.preloader - v0.95 - K Reeve aka BinaryKitten
*
* v0.95
* # Note - keeping below v1 as really not sure that I consider it public usable.
* # But it saying that it does the job it was intended to do.
* Added Completion of loading callback.
* Main Reworking With Thanks to Remy Sharp of jQuery for Designers
*
*
* v0.9
* Fixed .toString being .toSteing
*
* v0.8
* Fixed sheet.href being null error (was causing issues in FF3RC1)
*
* v0.7
* Remade the preLoadImages from jQuery to DOM
*
* v0.6
* Fixed IE6 Compatability!
* Moved from jQuery to DOM
*
* v0.5
* Shifted the additionalimages loader in the preLoadAllImages so it wasn't called multiple times
* Created secondary .preLoadImages to handle additionalimages and so it can be called on itself
*/
(function ($) {
$.preLoadImages = function(imageList,callback) {
var pic = [], i, total, loaded = 0;
if (typeof imageList != 'undefined') {
if ($.isArray(imageList)) {
total = imageList.length; // used later
for (i=0; i < total; i++) {
pic[i] = new Image();
pic[i].onload = function() {
loaded++; // should never hit a race condition due to JS's non-threaded nature
if (loaded == total) {
if ($.isFunction(callback)) {
callback();
}
}
};
pic[i].src = imageList[i];
}
}
else {
pic[0] = new Image();
pic[0].onload = function() {
if ($.isFunction(callback)) {
callback();
}
}
pic[0].src = imageList;
}
}
pic = undefined;
};
$.preLoadCSSImages = function(callback) {
var pic = [], i, imageList = [], loaded = 0, total, regex = new RegExp("url\((.*)\)",'i'),spl;
var cssSheets = document.styleSheets, path,myRules,Rule,match,txt,img,sheetIdx,ruleIdx;
for (sheetIdx=0;sheetIdx < cssSheets.length;sheetIdx++){
var sheet = cssSheets[sheetIdx];
if (typeof sheet.href == 'string' && sheet.href.length > 0) {
spl = sheet.href.split('/');spl.pop();path = spl.join('/')+'/';
}
else {
path = './';
}
myRules = sheet.cssRules ? sheet.cssRules : sheet.rules;
for (ruleIdx=0;ruleIdx < myRules.length;ruleIdx++) {
Rule = myRules[ruleIdx];
txt = Rule.cssText ? Rule.cssText : Rule.style.cssText;
match = regex.exec(txt);
if (match != null) {
img = match[1].substring(1,match[1].indexOf(')',1));
if (img.substring(0,4) == 'http') {
imageList[imageList.length] = img;
}
else if ( match[1].substring(1,2) == '/') {
var p2 = path.split('/');p2.pop();p2.pop();p2x = p2.join("/");
imageList[imageList.length] = p2x+img;
}
else {
imageList[imageList.length] = path+img;
}
}
};
};
total = imageList.length; // used later
for (i=0; i < total; i++) {
pic[i] = new Image();
pic[i].onload = function() {
loaded++; // should never hit a race condition due to JS's non-threaded nature
if (loaded == total) {
if ($.isFunction(callback)) {
callback();
}
}
};
pic[i].src = imageList[i];
}
};
$.preLoadAllImages = function(imageList,callback) {
if (typeof imageList != 'undefined') {
if ($.isFunction(imageList)) {
callback = imageList;
}
else if (!$.isArray(imageList)) {
imageList = [imageList];
}
}
$.preLoadCSSImages(function(){
if (imageList.length > 0) {
$.preLoadImages(imageList,function(){
callback();
});
}
else {
callback();
}
});
}
})(jQuery);
/*
* jQuery Iframe Transport Plugin 1.2.2
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2011, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://creativecommons.org/licenses/MIT/
*/
/*jslint unparam: true */
/*global jQuery */
(function ($) {
'use strict';
// Helper variable to create unique names for the transport iframes:
var counter = 0;
// The iframe transport accepts three additional options:
// options.fileInput: a jQuery collection of file input fields
// options.paramName: the parameter name for the file form data,
// overrides the name property of the file input field(s)
// options.formData: an array of objects with name and value properties,
// equivalent to the return data of .serializeArray(), e.g.:
// [{name: a, value: 1}, {name: b, value: 2}]
$.ajaxTransport('iframe', function (options, originalOptions, jqXHR) {
if (options.type === 'POST' || options.type === 'GET') {
var form,
iframe;
return {
send: function (headers, completeCallback) {
form = $('');
// javascript:false as initial iframe src
// prevents warning popups on HTTPS in IE6.
// IE versions below IE8 cannot set the name property of
// elements that have already been added to the DOM,
// so we set the name along with the iframe HTML markup:
iframe = $(
''
).bind('load', function () {
var fileInputClones;
iframe
.unbind('load')
.bind('load', function () {
var response;
// Wrap in a try/catch block to catch exceptions thrown
// when trying to access cross-domain iframe contents:
try {
response = iframe.contents();
// Google Chrome and Firefox do not throw an
// exception when calling iframe.contents() on
// cross-domain requests, so we unify the response:
if (!response.length || !response[0].firstChild) {
throw new Error();
}
} catch (e) {
response = undefined;
}
// The complete callback returns the
// iframe content document as response object:
completeCallback(
200,
'success',
{'iframe': response}
);
// Fix for IE endless progress bar activity bug
// (happens on form submits to iframe targets):
$('')
.appendTo(form);
form.remove();
});
form
.prop('target', iframe.prop('name'))
.prop('action', options.url)
.prop('method', options.type);
if (options.formData) {
$.each(options.formData, function (index, field) {
$('')
.prop('name', field.name)
.val(field.value)
.appendTo(form);
});
}
if (options.fileInput && options.fileInput.length &&
options.type === 'POST') {
fileInputClones = options.fileInput.clone();
// Insert a clone for each file input field:
options.fileInput.after(function (index) {
return fileInputClones[index];
});
if (options.paramName) {
options.fileInput.each(function () {
$(this).prop('name', options.paramName);
});
}
// Appending the file input fields to the hidden form
// removes them from their original location:
form
.append(options.fileInput)
.prop('enctype', 'multipart/form-data')
// enctype must be set as encoding for IE:
.prop('encoding', 'multipart/form-data');
}
form.submit();
// Insert the file input fields at their original location
// by replacing the clones with the originals:
if (fileInputClones && fileInputClones.length) {
options.fileInput.each(function (index, input) {
var clone = $(fileInputClones[index]);
$(input).prop('name', clone.prop('name'));
clone.replaceWith(input);
});
}
});
form.append(iframe).appendTo('body');
},
abort: function () {
if (iframe) {
// javascript:false as iframe src aborts the request
// and prevents warning popups on HTTPS in IE6.
// concat is used to avoid the "Script URL" JSLint error:
iframe
.unbind('load')
.prop('src', 'javascript'.concat(':false;'));
}
if (form) {
form.remove();
}
}
};
}
});
// The iframe transport returns the iframe content document as response.
// The following adds converters from iframe to text, json, html, and script:
$.ajaxSetup({
converters: {
'iframe text': function (iframe) {
return iframe.text();
},
'iframe json': function (iframe) {
return $.parseJSON(iframe.text());
},
'iframe html': function (iframe) {
return iframe.find('body').html();
},
'iframe script': function (iframe) {
return $.globalEval(iframe.text());
}
}
});
}(jQuery));
/*
* jQuery File Upload Plugin 5.0.3
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2010, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://creativecommons.org/licenses/MIT/
*/
/*jslint nomen: true, unparam: true, regexp: true */
/*global document, XMLHttpRequestUpload, Blob, File, FormData, location, jQuery */
(function ($) {
'use strict';
// The fileupload widget listens for change events on file input fields
// defined via fileInput setting and drop events of the given dropZone.
// In addition to the default jQuery Widget methods, the fileupload widget
// exposes the "add" and "send" methods, to add or directly send files
// using the fileupload API.
// By default, files added via file input selection, drag & drop or
// "add" method are uploaded immediately, but it is possible to override
// the "add" callback option to queue file uploads.
$.widget('blueimp.fileupload', {
options: {
// The namespace used for event handler binding on the dropZone and
// fileInput collections.
// If not set, the name of the widget ("fileupload") is used.
namespace: undefined,
// The drop target collection, by the default the complete document.
// Set to null or an empty collection to disable drag & drop support:
dropZone: $(document),
// The file input field collection, that is listened for change events.
// If undefined, it is set to the file input fields inside
// of the widget element on plugin initialization.
// Set to null or an empty collection to disable the change listener.
fileInput: undefined,
// By default, the file input field is replaced with a clone after
// each input field change event. This is required for iframe transport
// queues and allows change events to be fired for the same file
// selection, but can be disabled by setting the following option to false:
replaceFileInput: true,
// The parameter name for the file form data (the request argument name).
// If undefined or empty, the name property of the file input field is
// used, or "files[]" if the file input name property is also empty:
paramName: undefined,
// By default, each file of a selection is uploaded using an individual
// request for XHR type uploads. Set to false to upload file
// selections in one request each:
singleFileUploads: true,
// Set the following option to true to issue all file upload requests
// in a sequential order:
sequentialUploads: false,
// Set the following option to true to force iframe transport uploads:
forceIframeTransport: false,
// By default, XHR file uploads are sent as multipart/form-data.
// The iframe transport is always using multipart/form-data.
// Set to false to enable non-multipart XHR uploads:
multipart: true,
// To upload large files in smaller chunks, set the following option
// to a preferred maximum chunk size. If set to 0, null or undefined,
// or the browser does not support the required Blob API, files will
// be uploaded as a whole.
maxChunkSize: undefined,
// When a non-multipart upload or a chunked multipart upload has been
// aborted, this option can be used to resume the upload by setting
// it to the size of the already uploaded bytes. This option is most
// useful when modifying the options object inside of the "add" or
// "send" callbacks, as the options are cloned for each file upload.
uploadedBytes: undefined,
// By default, failed (abort or error) file uploads are removed from the
// global progress calculation. Set the following option to false to
// prevent recalculating the global progress data:
recalculateProgress: true,
// Additional form data to be sent along with the file uploads can be set
// using this option, which accepts an array of objects with name and
// value properties, a function returning such an array, a FormData
// object (for XHR file uploads), or a simple object.
// The form of the first fileInput is given as parameter to the function:
formData: function (form) {
return form.serializeArray();
},
// The add callback is invoked as soon as files are added to the fileupload
// widget (via file input selection, drag & drop or add API call).
// If the singleFileUploads option is enabled, this callback will be
// called once for each file in the selection for XHR file uplaods, else
// once for each file selection.
// The upload starts when the submit method is invoked on the data parameter.
// The data object contains a files property holding the added files
// and allows to override plugin options as well as define ajax settings.
// Listeners for this callback can also be bound the following way:
// .bind('fileuploadadd', func);
// data.submit() returns a Promise object and allows to attach additional
// handlers using jQuery's Deferred callbacks:
// data.submit().done(func).fail(func).always(func);
add: function (e, data) {
data.submit();
},
// Other callbacks:
// Callback for the start of each file upload request:
// send: function (e, data) {}, // .bind('fileuploadsend', func);
// Callback for successful uploads:
// done: function (e, data) {}, // .bind('fileuploaddone', func);
// Callback for failed (abort or error) uploads:
// fail: function (e, data) {}, // .bind('fileuploadfail', func);
// Callback for completed (success, abort or error) requests:
// always: function (e, data) {}, // .bind('fileuploadalways', func);
// Callback for upload progress events:
// progress: function (e, data) {}, // .bind('fileuploadprogress', func);
// Callback for global upload progress events:
// progressall: function (e, data) {}, // .bind('fileuploadprogressall', func);
// Callback for uploads start, equivalent to the global ajaxStart event:
// start: function (e) {}, // .bind('fileuploadstart', func);
// Callback for uploads stop, equivalent to the global ajaxStop event:
// stop: function (e) {}, // .bind('fileuploadstop', func);
// Callback for change events of the fileInput collection:
// change: function (e, data) {}, // .bind('fileuploadchange', func);
// Callback for drop events of the dropZone collection:
// drop: function (e, data) {}, // .bind('fileuploaddrop', func);
// Callback for dragover events of the dropZone collection:
// dragover: function (e) {}, // .bind('fileuploaddragover', func);
// The plugin options are used as settings object for the ajax calls.
// The following are jQuery ajax settings required for the file uploads:
processData: false,
contentType: false,
cache: false
},
// A list of options that require a refresh after assigning a new value:
_refreshOptionsList: ['namespace', 'dropZone', 'fileInput'],
_isXHRUpload: function (options) {
var undef = 'undefined';
return !options.forceIframeTransport &&
typeof XMLHttpRequestUpload !== undef && typeof File !== undef &&
(!options.multipart || typeof FormData !== undef);
},
_getFormData: function (options) {
var formData;
if (typeof options.formData === 'function') {
return options.formData(options.form);
} else if ($.isArray(options.formData)) {
return options.formData;
} else if (options.formData) {
formData = [];
$.each(options.formData, function (name, value) {
formData.push({name: name, value: value});
});
return formData;
}
return [];
},
_getTotal: function (files) {
var total = 0;
$.each(files, function (index, file) {
total += file.size || 1;
});
return total;
},
_onProgress: function (e, data) {
if (e.lengthComputable) {
var total = data.total || this._getTotal(data.files),
loaded = parseInt(
e.loaded / e.total * (data.chunkSize || total),
10
) + (data.uploadedBytes || 0);
this._loaded += loaded - (data.loaded || data.uploadedBytes || 0);
data.lengthComputable = true;
data.loaded = loaded;
data.total = total;
// Trigger a custom progress event with a total data property set
// to the file size(s) of the current upload and a loaded data
// property calculated accordingly:
this._trigger('progress', e, data);
// Trigger a global progress event for all current file uploads,
// including ajax calls queued for sequential file uploads:
this._trigger('progressall', e, {
lengthComputable: true,
loaded: this._loaded,
total: this._total
});
}
},
_initProgressListener: function (options) {
var that = this,
xhr = options.xhr ? options.xhr() : $.ajaxSettings.xhr();
// Accesss to the native XHR object is required to add event listeners
// for the upload progress event:
if (xhr.upload && xhr.upload.addEventListener) {
xhr.upload.addEventListener('progress', function (e) {
that._onProgress(e, options);
}, false);
options.xhr = function () {
return xhr;
};
}
},
_initXHRData: function (options) {
var formData,
file = options.files[0];
if (!options.multipart || options.blob) {
// For non-multipart uploads and chunked uploads,
// file meta data is not part of the request body,
// so we transmit this data as part of the HTTP headers.
// For cross domain requests, these headers must be allowed
// via Access-Control-Allow-Headers or removed using
// the beforeSend callback:
options.headers = $.extend(options.headers, {
'X-File-Name': file.name,
'X-File-Type': file.type,
'X-File-Size': file.size
});
if (!options.blob) {
// Non-chunked non-multipart upload:
options.contentType = file.type;
options.data = file;
} else if (!options.multipart) {
// Chunked non-multipart upload:
options.contentType = 'application/octet-stream';
options.data = options.blob;
}
}
if (options.multipart && typeof FormData !== 'undefined') {
if (options.formData instanceof FormData) {
formData = options.formData;
} else {
formData = new FormData();
$.each(this._getFormData(options), function (index, field) {
formData.append(field.name, field.value);
});
}
if (options.blob) {
formData.append(options.paramName, options.blob);
} else {
$.each(options.files, function (index, file) {
// File objects are also Blob instances.
// This check allows the tests to run with
// dummy objects:
if (file instanceof Blob) {
formData.append(options.paramName, file);
}
});
}
options.data = formData;
}
// Blob reference is not needed anymore, free memory:
options.blob = null;
},
_initIframeSettings: function (options) {
// Setting the dataType to iframe enables the iframe transport:
options.dataType = 'iframe ' + (options.dataType || '');
// The iframe transport accepts a serialized array as form data:
options.formData = this._getFormData(options);
},
_initDataSettings: function (options) {
if (this._isXHRUpload(options)) {
if (!this._chunkedUpload(options, true)) {
if (!options.data) {
this._initXHRData(options);
}
this._initProgressListener(options);
}
} else {
this._initIframeSettings(options);
}
},
_initFormSettings: function (options) {
// Retrieve missing options from the input field and the
// associated form, if available:
if (!options.form || !options.form.length) {
options.form = $(options.fileInput.prop('form'));
}
if (!options.paramName) {
options.paramName = options.fileInput.prop('name') ||
'files[]';
}
if (!options.url) {
options.url = options.form.prop('action') || location.href;
}
// The HTTP request method must be "POST" or "PUT":
options.type = (options.type || options.form.prop('method') || '')
.toUpperCase();
if (options.type !== 'POST' && options.type !== 'PUT') {
options.type = 'POST';
}
},
_getAJAXSettings: function (data) {
var options = $.extend({}, this.options, data);
this._initFormSettings(options);
this._initDataSettings(options);
return options;
},
// Maps jqXHR callbacks to the equivalent
// methods of the given Promise object:
_enhancePromise: function (promise) {
promise.success = promise.done;
promise.error = promise.fail;
promise.complete = promise.always;
return promise;
},
// Creates and returns a Promise object enhanced with
// the jqXHR methods abort, success, error and complete:
_getXHRPromise: function (resolveOrReject, context, args) {
var dfd = $.Deferred(),
promise = dfd.promise();
context = context || this.options.context || promise;
if (resolveOrReject === true) {
dfd.resolveWith(context, args);
} else if (resolveOrReject === false) {
dfd.rejectWith(context, args);
}
promise.abort = dfd.promise;
return this._enhancePromise(promise);
},
// Uploads a file in multiple, sequential requests
// by splitting the file up in multiple blob chunks.
// If the second parameter is true, only tests if the file
// should be uploaded in chunks, but does not invoke any
// upload requests:
_chunkedUpload: function (options, testOnly) {
var that = this,
file = options.files[0],
fs = file.size,
ub = options.uploadedBytes = options.uploadedBytes || 0,
mcs = options.maxChunkSize || fs,
// Use the Blob methods with the slice implementation
// according to the W3C Blob API specification:
slice = file.webkitSlice || file.mozSlice || file.slice,
upload,
n,
jqXHR,
pipe;
if (!(this._isXHRUpload(options) && slice && (ub || mcs < fs)) ||
options.data) {
return false;
}
if (testOnly) {
return true;
}
if (ub >= fs) {
file.error = 'uploadedBytes';
return this._getXHRPromise(false);
}
// n is the number of blobs to upload,
// calculated via filesize, uploaded bytes and max chunk size:
n = Math.ceil((fs - ub) / mcs);
// The chunk upload method accepting the chunk number as parameter:
upload = function (i) {
if (!i) {
return that._getXHRPromise(true);
}
// Upload the blobs in sequential order:
return upload(i -= 1).pipe(function () {
// Clone the options object for each chunk upload:
var o = $.extend({}, options);
o.blob = slice.call(
file,
ub + i * mcs,
ub + (i + 1) * mcs
);
// Store the current chunk size, as the blob itself
// will be dereferenced after data processing:
o.chunkSize = o.blob.size;
// Process the upload data (the blob and potential form data):
that._initXHRData(o);
// Add progress listeners for this chunk upload:
that._initProgressListener(o);
jqXHR = ($.ajax(o) || that._getXHRPromise(false, o.context))
.done(function () {
// Create a progress event if upload is done and
// no progress event has been invoked for this chunk:
if (!o.loaded) {
that._onProgress($.Event('progress', {
lengthComputable: true,
loaded: o.chunkSize,
total: o.chunkSize
}), o);
}
options.uploadedBytes = o.uploadedBytes
+= o.chunkSize;
});
return jqXHR;
});
};
// Return the piped Promise object, enhanced with an abort method,
// which is delegated to the jqXHR object of the current upload,
// and jqXHR callbacks mapped to the equivalent Promise methods:
pipe = upload(n);
pipe.abort = function () {
return jqXHR.abort();
};
return this._enhancePromise(pipe);
},
_beforeSend: function (e, data) {
if (this._active === 0) {
// the start callback is triggered when an upload starts
// and no other uploads are currently running,
// equivalent to the global ajaxStart event:
this._trigger('start');
}
this._active += 1;
// Initialize the global progress values:
this._loaded += data.uploadedBytes || 0;
this._total += this._getTotal(data.files);
},
_onDone: function (result, textStatus, jqXHR, options) {
if (!this._isXHRUpload(options)) {
// Create a progress event for each iframe load:
this._onProgress($.Event('progress', {
lengthComputable: true,
loaded: 1,
total: 1
}), options);
}
options.result = result;
options.textStatus = textStatus;
options.jqXHR = jqXHR;
this._trigger('done', null, options);
},
_onFail: function (jqXHR, textStatus, errorThrown, options) {
options.jqXHR = jqXHR;
options.textStatus = textStatus;
options.errorThrown = errorThrown;
this._trigger('fail', null, options);
if (options.recalculateProgress) {
// Remove the failed (error or abort) file upload from
// the global progress calculation:
this._loaded -= options.loaded || options.uploadedBytes || 0;
this._total -= options.total || this._getTotal(options.files);
}
},
_onAlways: function (result, textStatus, jqXHR, errorThrown, options) {
this._active -= 1;
options.result = result;
options.textStatus = textStatus;
options.jqXHR = jqXHR;
options.errorThrown = errorThrown;
this._trigger('always', null, options);
if (this._active === 0) {
// The stop callback is triggered when all uploads have
// been completed, equivalent to the global ajaxStop event:
this._trigger('stop');
// Reset the global progress values:
this._loaded = this._total = 0;
}
},
_onSend: function (e, data) {
var that = this,
jqXHR,
pipe,
options = that._getAJAXSettings(data),
send = function (resolve, args) {
jqXHR = jqXHR || (
(resolve !== false &&
that._trigger('send', e, options) !== false &&
(that._chunkedUpload(options) || $.ajax(options))) ||
that._getXHRPromise(false, options.context, args)
).done(function (result, textStatus, jqXHR) {
that._onDone(result, textStatus, jqXHR, options);
}).fail(function (jqXHR, textStatus, errorThrown) {
that._onFail(jqXHR, textStatus, errorThrown, options);
}).always(function (a1, a2, a3) {
if (a3 && a3.done) {
that._onAlways(a1, a2, a3, undefined, options);
} else {
that._onAlways(undefined, a2, a1, a3, options);
}
});
return jqXHR;
};
this._beforeSend(e, options);
if (this.options.sequentialUploads) {
// Return the piped Promise object, enhanced with an abort method,
// which is delegated to the jqXHR object of the current upload,
// and jqXHR callbacks mapped to the equivalent Promise methods:
pipe = (this._sequence = this._sequence.pipe(send, send));
pipe.abort = function () {
if (!jqXHR) {
return send(false, [undefined, 'abort', 'abort']);
}
return jqXHR.abort();
};
return this._enhancePromise(pipe);
}
return send();
},
_onAdd: function (e, data) {
var that = this,
result = true,
options = $.extend({}, this.options, data);
if (options.singleFileUploads && this._isXHRUpload(options)) {
$.each(data.files, function (index, file) {
var newData = $.extend({}, data, {files: [file]});
newData.submit = function () {
return that._onSend(e, newData);
};
return (result = that._trigger('add', e, newData));
});
return result;
} else if (data.files.length) {
data = $.extend({}, data);
data.submit = function () {
return that._onSend(e, data);
};
return this._trigger('add', e, data);
}
},
// File Normalization for Gecko 1.9.1 (Firefox 3.5) support:
_normalizeFile: function (index, file) {
if (file.name === undefined && file.size === undefined) {
file.name = file.fileName;
file.size = file.fileSize;
}
},
_replaceFileInput: function (input) {
var inputClone = input.clone(true);
$('').append(inputClone)[0].reset();
// Detaching allows to insert the fileInput on another form
// without loosing the file input value:
input.after(inputClone).detach();
// Replace the original file input element in the fileInput
// collection with the clone, which has been copied including
// event handlers:
this.options.fileInput = this.options.fileInput.map(function (i, el) {
if (el === input[0]) {
return inputClone[0];
}
return el;
});
},
_onChange: function (e) {
var that = e.data.fileupload,
data = {
files: $.each($.makeArray(e.target.files), that._normalizeFile),
fileInput: $(e.target),
form: $(e.target.form)
};
if (!data.files.length) {
// If the files property is not available, the browser does not
// support the File API and we add a pseudo File object with
// the input value as name with path information removed:
data.files = [{name: e.target.value.replace(/^.*\\/, '')}];
}
// Store the form reference as jQuery data for other event handlers,
// as the form property is not available after replacing the file input:
if (data.form.length) {
data.fileInput.data('blueimp.fileupload.form', data.form);
} else {
data.form = data.fileInput.data('blueimp.fileupload.form');
}
if (that.options.replaceFileInput) {
that._replaceFileInput(data.fileInput);
}
if (that._trigger('change', e, data) === false ||
that._onAdd(e, data) === false) {
return false;
}
},
_onDrop: function (e) {
var that = e.data.fileupload,
dataTransfer = e.dataTransfer = e.originalEvent.dataTransfer,
data = {
files: $.each(
$.makeArray(dataTransfer && dataTransfer.files),
that._normalizeFile
)
};
if (that._trigger('drop', e, data) === false ||
that._onAdd(e, data) === false) {
return false;
}
e.preventDefault();
},
_onDragOver: function (e) {
var that = e.data.fileupload,
dataTransfer = e.dataTransfer = e.originalEvent.dataTransfer;
if (that._trigger('dragover', e) === false) {
return false;
}
if (dataTransfer) {
dataTransfer.dropEffect = dataTransfer.effectAllowed = 'copy';
}
e.preventDefault();
},
_initEventHandlers: function () {
var ns = this.options.namespace || this.name;
this.options.dropZone
.bind('dragover.' + ns, {fileupload: this}, this._onDragOver)
.bind('drop.' + ns, {fileupload: this}, this._onDrop);
this.options.fileInput
.bind('change.' + ns, {fileupload: this}, this._onChange);
},
_destroyEventHandlers: function () {
var ns = this.options.namespace || this.name;
this.options.dropZone
.unbind('dragover.' + ns, this._onDragOver)
.unbind('drop.' + ns, this._onDrop);
this.options.fileInput
.unbind('change.' + ns, this._onChange);
},
_beforeSetOption: function (key, value) {
this._destroyEventHandlers();
},
_afterSetOption: function (key, value) {
var options = this.options;
if (!options.fileInput) {
options.fileInput = $();
}
if (!options.dropZone) {
options.dropZone = $();
}
this._initEventHandlers();
},
_setOption: function (key, value) {
var refresh = $.inArray(key, this._refreshOptionsList) !== -1;
if (refresh) {
this._beforeSetOption(key, value);
}
$.Widget.prototype._setOption.call(this, key, value);
if (refresh) {
this._afterSetOption(key, value);
}
},
_create: function () {
var options = this.options;
if (options.fileInput === undefined) {
options.fileInput = this.element.is('input:file') ?
this.element : this.element.find('input:file');
} else if (!options.fileInput) {
options.fileInput = $();
}
if (!options.dropZone) {
options.dropZone = $();
}
this._sequence = this._getXHRPromise(true);
this._active = this._loaded = this._total = 0;
this._initEventHandlers();
},
destroy: function () {
this._destroyEventHandlers();
$.Widget.prototype.destroy.call(this);
},
enable: function () {
$.Widget.prototype.enable.call(this);
this._initEventHandlers();
},
disable: function () {
this._destroyEventHandlers();
$.Widget.prototype.disable.call(this);
},
// This method is exposed to the widget API and allows adding files
// using the fileupload API. The data parameter accepts an object which
// must have a files property and can contain additional options:
// .fileupload('add', {files: filesList});
add: function (data) {
if (!data || this.options.disabled) {
return;
}
data.files = $.each($.makeArray(data.files), this._normalizeFile);
this._onAdd(null, data);
},
// This method is exposed to the widget API and allows sending files
// using the fileupload API. The data parameter accepts an object which
// must have a files property and can contain additional options:
// .fileupload('send', {files: filesList});
// The method returns a Promise object for the file upload call.
send: function (data) {
if (data && !this.options.disabled) {
data.files = $.each($.makeArray(data.files), this._normalizeFile);
if (data.files.length) {
return this._onSend(null, data);
}
}
return this._getXHRPromise(false, data && data.context);
}
});
}(jQuery));
/*
* jQuery File Upload User Interface Plugin 5.0.13
* https://github.com/blueimp/jQuery-File-Upload
*
* Copyright 2010, Sebastian Tschan
* https://blueimp.net
*
* Licensed under the MIT license:
* http://creativecommons.org/licenses/MIT/
*/
/*jslint nomen: true, unparam: true, regexp: true */
/*global window, document, URL, webkitURL, FileReader, jQuery */
(function ($) {
'use strict';
// The UI version extends the basic fileupload widget and adds
// a complete user interface based on the given upload/download
// templates.
$.widget('blueimpUI.fileupload', $.blueimp.fileupload, {
options: {
// By default, files added to the widget are uploaded as soon
// as the user clicks on the start buttons. To enable automatic
// uploads, set the following option to true:
autoUpload: false,
// The following option limits the number of files that are
// allowed to be uploaded using this widget:
maxNumberOfFiles: undefined,
// The maximum allowed file size:
maxFileSize: undefined,
// The minimum allowed file size:
minFileSize: 1,
// The regular expression for allowed file types, matches
// against either file type or file name:
acceptFileTypes: /.+$/i,
// The regular expression to define for which files a preview
// image is shown, matched against the file type:
previewFileTypes: /^image\/(gif|jpeg|png)$/,
// The maximum width of the preview images:
previewMaxWidth: 80,
// The maximum height of the preview images:
previewMaxHeight: 80,
// By default, preview images are displayed as canvas elements
// if supported by the browser. Set the following option to false
// to always display preview images as img elements:
previewAsCanvas: true,
// The file upload template that is given as first argument to the
// jQuery.tmpl method to render the file uploads:
uploadTemplate: $('#power-gallery-template-upload'),
// The file download template, that is given as first argument to the
// jQuery.tmpl method to render the file downloads:
downloadTemplate: $('#power-gallery-template-download'),
// The expected data type of the upload response, sets the dataType
// option of the $.ajax upload requests:
dataType: 'json',
// The add callback is invoked as soon as files are added to the fileupload
// widget (via file input selection, drag & drop or add API call).
// See the basic file upload widget for more information:
add: function (e, data) {
var that = $(this).data('fileupload');
that._adjustMaxNumberOfFiles(-data.files.length);
data.isAdjusted = true;
data.isValidated = that._validate(data.files);
data.context = that._renderUpload(data.files)
.appendTo($(this).find('.files')).fadeIn(function () {
// Fix for IE7 and lower:
$(this).show();
}).data('data', data);
if ((that.options.autoUpload || data.autoUpload) &&
data.isValidated) {
data.jqXHR = data.submit();
}
},
// Callback for the start of each file upload request:
send: function (e, data) {
if (!data.isValidated) {
var that = $(this).data('fileupload');
if (!data.isAdjusted) {
that._adjustMaxNumberOfFiles(-data.files.length);
}
if (!that._validate(data.files)) {
return false;
}
}
if (data.context && data.dataType &&
data.dataType.substr(0, 6) === 'iframe') {
// Iframe Transport does not support progress events.
// In lack of an indeterminate progress bar, we set
// the progress to 100%, showing the full animated bar:
data.context.find('.ui-progressbar').progressbar(
'value',
parseInt(100, 10)
);
}
},
// Callback for successful uploads:
done: function (e, data) {
var that = $(this).data('fileupload');
if (data.context) {
data.context.each(function (index) {
var file = ($.isArray(data.result) &&
data.result[index]) || {error: 'emptyResult'};
if (file.error) {
that._adjustMaxNumberOfFiles(1);
}
$(this).fadeOut(function () {
that._renderDownload([file])
.css('display', 'none')
.replaceAll(this)
.fadeIn(function () {
// Fix for IE7 and lower:
$(this).show();
});
});
});
} else {
that._renderDownload(data.result)
.css('display', 'none')
.appendTo($(this).find('.files'))
.fadeIn(function () {
// Fix for IE7 and lower:
$(this).show();
});
}
},
// Callback for failed (abort or error) uploads:
fail: function (e, data) {
var that = $(this).data('fileupload');
that._adjustMaxNumberOfFiles(data.files.length);
if (data.context) {
data.context.each(function (index) {
$(this).fadeOut(function () {
if (data.errorThrown !== 'abort') {
var file = data.files[index];
file.error = file.error || data.errorThrown
|| true;
that._renderDownload([file])
.css('display', 'none')
.replaceAll(this)
.fadeIn(function () {
// Fix for IE7 and lower:
$(this).show();
});
} else {
data.context.remove();
}
});
});
} else if (data.errorThrown !== 'abort') {
that._adjustMaxNumberOfFiles(-data.files.length);
data.context = that._renderUpload(data.files)
.css('display', 'none')
.appendTo($(this).find('.files'))
.fadeIn(function () {
// Fix for IE7 and lower:
$(this).show();
}).data('data', data);
}
},
// Callback for upload progress events:
progress: function (e, data) {
if (data.context) {
data.context.find('.ui-progressbar').progressbar(
'value',
parseInt(data.loaded / data.total * 100, 10)
);
}
},
// Callback for global upload progress events:
progressall: function (e, data) {
$(this).find('.fileupload-progressbar').progressbar(
'value',
parseInt(data.loaded / data.total * 100, 10)
);
},
// Callback for uploads start, equivalent to the global ajaxStart event:
start: function () {
$(this).find('.fileupload-progressbar')
.progressbar('value', 0).fadeIn();
},
// Callback for uploads stop, equivalent to the global ajaxStop event:
stop: function () {
$(this).find('.fileupload-progressbar').fadeOut();
},
// Callback for file deletion:
destroy: function (e, data) {
var that = $(this).data('fileupload');
if (data.url) {
$.ajax(data)
.success(function () {
that._adjustMaxNumberOfFiles(1);
$(this).fadeOut(function () {
$(this).remove();
});
});
} else {
data.context.fadeOut(function () {
$(this).remove();
});
}
}
},
// Scales the given image (img HTML element)
// using the given options.
// Returns a canvas object if the canvas option is true
// and the browser supports canvas, else the scaled image:
_scaleImage: function (img, options) {
options = options || {};
var canvas = document.createElement('canvas'),
scale = Math.min(
(options.maxWidth || img.width) / img.width,
(options.maxHeight || img.height) / img.height
);
if (scale >= 1) {
scale = Math.max(
(options.minWidth || img.width) / img.width,
(options.minHeight || img.height) / img.height
);
}
img.width = parseInt(img.width * scale, 10);
img.height = parseInt(img.height * scale, 10);
if (!options.canvas || !canvas.getContext) {
return img;
}
canvas.width = img.width;
canvas.height = img.height;
canvas.getContext('2d')
.drawImage(img, 0, 0, img.width, img.height);
return canvas;
},
_createObjectURL: function (file) {
var undef = 'undefined',
urlAPI = (typeof window.createObjectURL !== undef && window) ||
(typeof URL !== undef && URL) ||
(typeof webkitURL !== undef && webkitURL);
return urlAPI ? urlAPI.createObjectURL(file) : false;
},
_revokeObjectURL: function (url) {
var undef = 'undefined',
urlAPI = (typeof window.revokeObjectURL !== undef && window) ||
(typeof URL !== undef && URL) ||
(typeof webkitURL !== undef && webkitURL);
return urlAPI ? urlAPI.revokeObjectURL(url) : false;
},
// Loads a given File object via FileReader interface,
// invokes the callback with a data url:
_loadFile: function (file, callback) {
if (typeof FileReader !== 'undefined' &&
FileReader.prototype.readAsDataURL) {
var fileReader = new FileReader();
fileReader.onload = function (e) {
callback(e.target.result);
};
fileReader.readAsDataURL(file);
return true;
}
return false;
},
// Loads an image for a given File object.
// Invokes the callback with an img or optional canvas
// element (if supported by the browser) as parameter:
_loadImage: function (file, callback, options) {
var that = this,
url,
img;
if (!options || !options.fileTypes ||
options.fileTypes.test(file.type)) {
url = this._createObjectURL(file);
img = $('').bind('load', function () {
$(this).unbind('load');
that._revokeObjectURL(url);
callback(that._scaleImage(img[0], options));
}).prop('src', url);
if (!url) {
this._loadFile(file, function (url) {
img.prop('src', url);
});
}
}
},
// Link handler, that allows to download files
// by drag & drop of the links to the desktop:
_enableDragToDesktop: function () {
var link = $(this),
url = link.prop('href'),
name = decodeURIComponent(url.split('/').pop())
.replace(/:/g, '-'),
type = 'application/octet-stream';
link.bind('dragstart', function (e) {
try {
e.originalEvent.dataTransfer.setData(
'DownloadURL',
[type, name, url].join(':')
);
} catch (err) {}
});
},
_adjustMaxNumberOfFiles: function (operand) {
if (typeof this.options.maxNumberOfFiles === 'number') {
this.options.maxNumberOfFiles += operand;
if (this.options.maxNumberOfFiles < 1) {
this._disableFileInputButton();
} else {
this._enableFileInputButton();
}
}
},
_formatFileSize: function (file) {
if (typeof file.size !== 'number') {
return '';
}
if (file.size >= 1000000000) {
return (file.size / 1000000000).toFixed(2) + ' GB';
}
if (file.size >= 1000000) {
return (file.size / 1000000).toFixed(2) + ' MB';
}
return (file.size / 1000).toFixed(2) + ' KB';
},
_hasError: function (file) {
if (file.error) {
return file.error;
}
// The number of added files is subtracted from
// maxNumberOfFiles before validation, so we check if
// maxNumberOfFiles is below 0 (instead of below 1):
if (this.options.maxNumberOfFiles < 0) {
return 'maxNumberOfFiles';
}
// Files are accepted if either the file type or the file name
// matches against the acceptFileTypes regular expression, as
// only browsers with support for the File API report the type:
if (!(this.options.acceptFileTypes.test(file.type) ||
this.options.acceptFileTypes.test(file.name))) {
return 'acceptFileTypes';
}
if (this.options.maxFileSize &&
file.size > this.options.maxFileSize) {
return 'maxFileSize';
}
if (typeof file.size === 'number' &&
file.size < this.options.minFileSize) {
return 'minFileSize';
}
return null;
},
_validate: function (files) {
var that = this,
valid;
$.each(files, function (index, file) {
file.error = that._hasError(file);
valid = !file.error;
});
return valid;
},
_uploadTemplateHelper: function (file) {
file.sizef = this._formatFileSize(file);
return file;
},
_renderUploadTemplate: function (files) {
var that = this;
return $.tmpl(
this.options.uploadTemplate,
$.map(files, function (file) {
return that._uploadTemplateHelper(file);
})
);
},
_renderUpload: function (files) {
var that = this,
options = this.options,
tmpl = this._renderUploadTemplate(files);
if (!(tmpl instanceof $)) {
return $();
}
tmpl.css('display', 'none');
// .slice(1).remove().end().first() removes all but the first
// element and selects only the first for the jQuery collection:
tmpl.find('.progress div').slice(1).remove().end().first()
.progressbar();
tmpl.find('.start button').slice(
this.options.autoUpload ? 0 : 1
).remove().end().first()
.button({
text: false,
icons: {primary: 'ui-icon-circle-arrow-e'}
});
tmpl.find('.cancel button').slice(1).remove().end().first()
.button({
text: false,
icons: {primary: 'ui-icon-cancel'}
});
tmpl.find('.preview').each(function (index, node) {
that._loadImage(
files[index],
function (img) {
$(img).hide().appendTo(node).fadeIn();
},
{
maxWidth: options.previewMaxWidth,
maxHeight: options.previewMaxHeight,
fileTypes: options.previewFileTypes,
canvas: options.previewAsCanvas
}
);
});
return tmpl;
},
_downloadTemplateHelper: function (file) {
file.sizef = this._formatFileSize(file);
return file;
},
_renderDownloadTemplate: function (files) {
var that = this;
return $.tmpl(
this.options.downloadTemplate,
$.map(files, function (file) {
return that._downloadTemplateHelper(file);
})
);
},
_renderDownload: function (files) {
var tmpl = this._renderDownloadTemplate(files);
if (!(tmpl instanceof $)) {
return $();
}
tmpl.css('display', 'none');
tmpl.find('.delete button').button({
text: false,
icons: {primary: 'ui-icon-trash'}
});
// Ajout par Benjamin Beyssac
tmpl.find('.edit button').button({
text: false,
icons: {primary: 'ui-icon-pencil'}
});
tmpl.find('a').each(this._enableDragToDesktop);
return tmpl;
},
_startHandler: function (e) {
e.preventDefault();
var tmpl = $(this).closest('.template-upload'),
data = tmpl.data('data');
if (data && data.submit && !data.jqXHR) {
data.jqXHR = data.submit();
$(this).fadeOut();
}
},
_cancelHandler: function (e) {
e.preventDefault();
var tmpl = $(this).closest('.template-upload'),
data = tmpl.data('data') || {};
if (!data.jqXHR) {
data.errorThrown = 'abort';
e.data.fileupload._trigger('fail', e, data);
} else {
data.jqXHR.abort();
}
},
_deleteHandler: function (e) {
e.preventDefault();
var button = $(this);
e.data.fileupload._trigger('destroy', e, {
context: button.closest('.template-download'),
url: button.attr('data-url'),
type: button.attr('data-type'),
dataType: e.data.fileupload.options.dataType
});
},
// Ajout par Benjamin Beyssac
_editHandler: function (e) {
e.preventDefault();
var button = $(this);
var legende = '';
if(legende = prompt("Saisissez la légende :")){
$.ajax({
url: button.attr('data-url') + '&legende=' + legende,
type: button.attr('data-type'),
dataType: 'json',
success: function(){
button.parent('td.edit').first().next('td.legende').text(legende);
}
});
}
},
_initEventHandlers: function () {
$.blueimp.fileupload.prototype._initEventHandlers.call(this);
var filesList = this.element.find('.files'),
eventData = {fileupload: this};
filesList.find('.start button')
.live(
'click.' + this.options.namespace,
eventData,
this._startHandler
);
filesList.find('.cancel button')
.live(
'click.' + this.options.namespace,
eventData,
this._cancelHandler
);
filesList.find('.delete button')
.live(
'click.' + this.options.namespace,
eventData,
this._deleteHandler
);
// Ajout par Benjamin Beyssac
filesList.find('.edit button')
.live(
'click.' + this.options.namespace,
eventData,
this._editHandler
);
},
_destroyEventHandlers: function () {
var filesList = this.element.find('.files');
filesList.find('.start button')
.die('click.' + this.options.namespace);
filesList.find('.cancel button')
.die('click.' + this.options.namespace);
filesList.find('.delete button')
.die('click.' + this.options.namespace);
// Ajout par Benjamin Beyssac
filesList.find('.edit button')
.die('click.' + this.options.namespace);
$.blueimp.fileupload.prototype._destroyEventHandlers.call(this);
},
_initFileUploadButtonBar: function () {
var fileUploadButtonBar = this.element.find('.fileupload-buttonbar'),
filesList = this.element.find('.files'),
ns = this.options.namespace;
fileUploadButtonBar
.addClass('ui-widget-header ui-corner-top');
this.element.find('.fileinput-button').each(function () {
var fileInput = $(this).find('input:file').detach();
$(this).button({icons: {primary: 'ui-icon-plusthick'}})
.append(fileInput);
});
fileUploadButtonBar.find('.start')
.button({icons: {primary: 'ui-icon-circle-arrow-e'}})
.bind('click.' + ns, function (e) {
e.preventDefault();
filesList.find('.start button').click();
});
fileUploadButtonBar.find('.cancel')
.button({icons: {primary: 'ui-icon-cancel'}})
.bind('click.' + ns, function (e) {
e.preventDefault();
filesList.find('.cancel button').click();
});
fileUploadButtonBar.find('.delete')
.button({icons: {primary: 'ui-icon-trash'}})
.bind('click.' + ns, function (e) {
e.preventDefault();
filesList.find('.delete button').click();
});
// Ajout par Benjamin Beyssac
fileUploadButtonBar.find('.edit')
.button({icons: {primary: 'ui-icon-pencil'}})
.bind('click.' + ns, function (e) {
e.preventDefault();
filesList.find('.edit button').click();
});
},
_destroyFileUploadButtonBar: function () {
this.element.find('.fileupload-buttonbar')
.removeClass('ui-widget-header ui-corner-top');
this.element.find('.fileinput-button').each(function () {
var fileInput = $(this).find('input:file').detach();
$(this).button('destroy')
.append(fileInput);
});
this.element.find('.fileupload-buttonbar button')
.unbind('click.' + this.options.namespace)
.button('destroy');
},
_enableFileInputButton: function () {
this.element.find('.fileinput-button input:file:disabled')
.each(function () {
var fileInput = $(this),
button = fileInput.parent();
fileInput.detach().prop('disabled', false);
button.button('enable').append(fileInput);
});
},
_disableFileInputButton: function () {
this.element.find('.fileinput-button input:file:enabled')
.each(function () {
var fileInput = $(this),
button = fileInput.parent();
fileInput.detach().prop('disabled', true);
button.button('disable').append(fileInput);
});
},
_initTemplates: function () {
// Handle cases where the templates are defined
// after the widget library has been included:
if (this.options.uploadTemplate instanceof $ &&
!this.options.uploadTemplate.length) {
this.options.uploadTemplate = $(
this.options.uploadTemplate.selector
);
}
if (this.options.downloadTemplate instanceof $ &&
!this.options.downloadTemplate.length) {
this.options.downloadTemplate = $(
this.options.downloadTemplate.selector
);
}
},
_create: function () {
$.blueimp.fileupload.prototype._create.call(this);
this._initTemplates();
this.element
.addClass('ui-widget');
this._initFileUploadButtonBar();
this.element.find('.fileupload-content')
.addClass('ui-widget-content ui-corner-bottom');
this.element.find('.fileupload-progressbar')
.hide().progressbar();
},
destroy: function () {
this.element.find('.fileupload-progressbar')
.progressbar('destroy');
this.element.find('.fileupload-content')
.removeClass('ui-widget-content ui-corner-bottom');
this._destroyFileUploadButtonBar();
this.element.removeClass('ui-widget');
$.blueimp.fileupload.prototype.destroy.call(this);
},
enable: function () {
$.blueimp.fileupload.prototype.enable.call(this);
this.element.find(':ui-button').not('.fileinput-button')
.button('enable');
this._enableFileInputButton();
},
disable: function () {
this.element.find(':ui-button').not('.fileinput-button')
.button('disable');
this._disableFileInputButton();
$.blueimp.fileupload.prototype.disable.call(this);
}
});
}(jQuery));
(function($) {
// Nom du Plugin
$.fn.powerGallery = function(method) {
// Méthodes publiques
//
// Elles peuvent être appelées depuis l'extérieur par
// element.pluginName('methodName', arg1, arg2, ... argn)
// où "element" est un objet du DOM auquel on attache la méthode
//
// ou, de l'intérieur par
// methods.methodName(arg1, arg2, ... argn)
var methods = {
// Constructeur
init: function(options) {
// the plugin's final properties are the merged default and user-provided properties (if any)
// this has the advantage of not polluting the defaults, making them re-usable
this.powerGallery.settings = $.extend({}, this.powerGallery.defaults, options);
// Boucle sur les éléments attachés au plugin
return this.each( function() {
var $element = $(this), // reference to the jQuery version of the current DOM element
element = this; // reference to the actual DOM element
$element.width($.fn.powerGallery.settings.width);
$element.css({
'dipslay': 'block',
'position': 'relative',
'min-height': $.fn.powerGallery.settings.height + 'px',
'font-size': '13px'
});
helpers.init($element);
});
}
}
// Méthodes privées
// Elles ne peuvent être appelées que depuis l'intérieur du Plugin par
// helpers.methodName(arg1, arg2, ... argn)
var helpers = {
// Charge l'interfaçe d'upload d'images
initUpload: function(element){
$.ajax({
url: $.fn.powerGallery.settings.template_html_file_url,
success: function(html){
element.html('');
element.append(html);
var date = new Date();
var id = 'id' + date.getTime();
$("#power-gallery-template-form").tmpl({
id: id,
action: $.fn.powerGallery.settings.upload_php_file_url,
text_browse: $.fn.powerGallery.settings.text_browse,
text_start: $.fn.powerGallery.settings.text_start,
text_cancel: $.fn.powerGallery.settings.text_cancel,
text_delete: $.fn.powerGallery.settings.text_delete
}).appendTo(element);
$('#' + id).fileupload({
autoUpload: $.fn.powerGallery.settings.autoUpload,
sequentialUploads: true
});
$('#' + id).find('button.preview').button({
icons: {primary: 'ui-icon-trash'}
}).click(function(){
helpers.initGallery(element);
});
// Load existing files:
$.getJSON($('#' + id + ' form').prop('action'), function (files) {
var fu = $('#' + id).data('fileupload');
fu._adjustMaxNumberOfFiles(-files.length);
fu._renderDownload(files)
.appendTo($('#' + id + ' .files'))
.fadeIn(function () {
// Fix for IE7 and lower:
$(this).show();
});
});
// Open download dialogs via iframes,
// to prevent aborting current uploads:
$('#' + id + ' .files a:not([target^=_blank])').live('click', function (e) {
e.preventDefault();
$('')
.prop('src', this.href)
.appendTo('body');
});
}
});
},
// Charge la gallerie photos
initGallery: function(element){
// Calcul de largeur et hauteur du container photo et du container wignette
$.fn.powerGallery.settings.image_container_width = $.fn.powerGallery.settings.width;
$.fn.powerGallery.settings.image_container_height = $.fn.powerGallery.settings.height - $.fn.powerGallery.settings.thumbnail_height;
$.fn.powerGallery.settings.thumbnail_nb = parseInt($.fn.powerGallery.settings.width / ($.fn.powerGallery.settings.thumbnail_width + $.fn.powerGallery.settings.thumbnail_margin * 2));
$.fn.powerGallery.settings.thumbnail_container_width = $.fn.powerGallery.settings.thumbnail_nb * ($.fn.powerGallery.settings.thumbnail_width + $.fn.powerGallery.settings.thumbnail_margin * 2);
$.fn.powerGallery.settings.thumbnail_container_height = $.fn.powerGallery.settings.thumbnail_height;
$.getJSON($.fn.powerGallery.settings.upload_php_file_url, function(json) {
element.html('');
// Mise en place du container vignette avec les boutons précédant et suivant
var top = $.fn.powerGallery.settings.thumbnail_container_height / 2 - 16 + $.fn.powerGallery.settings.thumbnail_margin;
var thumbnail_container = $('
').css({'display': 'block', 'position': 'relative', 'width': $.fn.powerGallery.settings.thumbnail_container_width + 'px', 'height': $.fn.powerGallery.settings.thumbnail_container_height + 'px', 'margin': '0 auto', 'padding': '0'});
var prev = $('').css({'display': 'block', 'position': 'absolute', 'left': '-32px', 'top': top + 'px', 'cursor': 'pointer'});
var next = $('').css({'display': 'block', 'position': 'absolute', 'right': '-32px', 'top': top + 'px', 'cursor': 'pointer'});
element.append(thumbnail_container);
thumbnail_container.append(prev);
thumbnail_container.append(next);
//var images = [];
$.each(json, function(key, file) {
var thumbnail_li = $('').css({
'display': 'block',
'float': 'left',
'position': 'relative',
'background-color': 'transparent',
'background-image': 'url(' + file.thumbnail_url + ')',
'background-position': 'center center',
'background-repeat': 'no-repeat',
'opacity': '1',
'width': $.fn.powerGallery.settings.thumbnail_width + 'px',
'height': $.fn.powerGallery.settings.thumbnail_height + 'px',
'margin': '0',
'padding': $.fn.powerGallery.settings.thumbnail_margin + 'px',
'cursor': 'pointer'
}).data({
'image': file.url,
'width': file.width,
'height': file.height,
'legende': file.legende
});
if(key == 0)
thumbnail_li.addClass('first active');
else if(key == $.fn.powerGallery.settings.thumbnail_nb - 1)
thumbnail_li.addClass('last');
thumbnail_container.append(thumbnail_li);
if($.fn.powerGallery.settings.thumbnail_nb <= key)
thumbnail_li.hide();
//images.push(file.url);
});
//$.preLoadImages(images);
var image_container = $('').css({
'display': 'block',
'float': 'left',
'position': 'relative',
'margin': '0',
'padding': '5px 0',
'width': $.fn.powerGallery.settings.image_container_width + 'px',
'height': $.fn.powerGallery.settings.image_container_height + 'px',
'text-align': 'center'
});
element.append(image_container);
$('.power-gallery-thumbnail').click(function(){
clearTimeout($.fn.powerGallery.settings.timeout);
helpers.click(element, $(this));
}).mouseenter(function(){
if(!$(this).hasClass('active'))
$(this).animate({'background-color': '#000', 'opacity': '0.5'});
}).mouseleave(function(){
if(!$(this).hasClass('active'))
$(this).animate({'background-color': 'transparent', 'opacity': '1'});
});
image_container.click(function(){
clearTimeout($.fn.powerGallery.settings.timeout);
var li = element.find('.power-gallery-thumbnail.active').first().next('li');
if(li.is('li'))
helpers.click(element, li, $.fn.powerGallery.settings.pause);
});
// Affichage de la première image et lancement du diaporama
var li = element.find('.power-gallery-thumbnail.active').first();
helpers.click(element, li, $.fn.powerGallery.settings.pause);
// Défilement des vignettes
prev.click(function(){
clearTimeout($.fn.powerGallery.settings.timeout);
helpers.prev(element);
});
next.click(function(){
clearTimeout($.fn.powerGallery.settings.timeout);
helpers.next(element);
});
// On affiche le bouton pour accéder au transfert d'image si on est admin
if($.fn.powerGallery.settings.admin == true){
var add = $('').css({'display': 'block', 'position': 'absolute', 'top': $.fn.powerGallery.settings.thumbnail_container_height + 20 + 'px', 'right': '0', 'cursor': 'pointer'});
element.append(add);
add.show();
add.click(function(){
helpers.initUpload(element);
});
}
});
},
// Lance le diaporama
play: function(element){
var li = element.find('.power-gallery-thumbnail.active').first().next();
if(li.is('li'))
helpers.click(element, li, $.fn.powerGallery.settings.pause);
},
// Affiche les vignettes précédantes
prev: function(element){
var thumbnail_container = element.find('.power-gallery-thumbnail-container').first();
var prev_li = thumbnail_container.find('li.first').first().prev('li');
if(prev_li.is('li')){
var li = thumbnail_container.find('li.last').first();
li.removeClass('last');
while(!li.hasClass('first')){
li.hide();
li = li.prev('li');
}
li.removeClass('first');
li.hide();
for(var i = 0; i < $.fn.powerGallery.settings.thumbnail_nb; i++){
li = li.prev('li');
li.fadeIn(1000);
if(i == 0)
li.addClass('last');
else if(i == $.fn.powerGallery.settings.thumbnail_nb - 1)
li.addClass('first');
}
}
},
// Affiche les vignettes suivantes
next: function(element){
var thumbnail_container = element.find('.power-gallery-thumbnail-container').first();
var next_li = thumbnail_container.find('li.last').first().next('li');
if(next_li.is('li')){
var li = thumbnail_container.find('li.first').first();
li.removeClass('first');
while(!li.hasClass('last')){
li.hide();
li = li.next('li');
}
li.removeClass('last');
li.hide();
for(var i = 0; i < $.fn.powerGallery.settings.thumbnail_nb; i++){
if(li.next('li').is('li')){
li = li.next('li');
li.fadeIn(1000);
if(i == 0)
li.addClass('first');
else if(i == $.fn.powerGallery.settings.thumbnail_nb - 1)
li.addClass('last');
}
else
li.addClass('last');
}
}
},
click: function(element, li, delay){
var image_container = element.find('.power-gallery-image-container').first();
$('.power-gallery-thumbnail.active').animate({'background-color': 'transparent', 'opacity': '1'});
$('.power-gallery-thumbnail.active').removeClass('active');
li.animate({'background-color': '#000', 'opacity': '0.5'});
li.addClass('active');
var width = li.data('width');
var height = li.data('height');
var size = 'height="' + $.fn.powerGallery.settings.image_container_height + '"';
if(li.css('display') == 'none')
helpers.next(element);
image_container.html('
');
$('').load(function(){
image_container.html('');
image_container.append($(this));
if(li.data('legende'))
image_container.append(
$('').css({
'background-color': '#000',
'opacity': '0.8',
'color': '#fff',
'display': 'block',
'position': 'absolute',
'width': $.fn.powerGallery.settings.image_container_width - 20 + 'px',
'left': '0',
'bottom': '0',
'padding': '10px',
'font-size': '18px',
'font-weight': 'bold'
}).text(li.data('legende')));
if(delay)
$.fn.powerGallery.settings.timeout = setTimeout(function(){
helpers.play(element);
}, delay);
}).css({'cursor': 'pointer'});
},
// Ecrit les paramètres dans un fichier json
init: function(element){
$.ajax({
url: $.fn.powerGallery.settings.upload_php_file_url,
type: 'post',
data: 'action=settings'
+ '&file_dir=' + $.fn.powerGallery.settings.file_dir
+ '&file_url=' + $.fn.powerGallery.settings.file_url
+ '&thumbnail_dir=' + $.fn.powerGallery.settings.thumbnail_dir
+ '&thumbnail_url=' + $.fn.powerGallery.settings.thumbnail_url
+ '&thumbnail_width=' + $.fn.powerGallery.settings.thumbnail_width
+ '&thumbnail_height=' + $.fn.powerGallery.settings.thumbnail_height,
success: function(){
helpers.initGallery(element);
}
});
}
}
// if a method as the given argument exists
if (methods[method]) {
// call the respective method
return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
// if an object is given as method OR nothing is given as argument
} else if (typeof method === 'object' || !method) {
// call the initialization method
return methods.init.apply(this, arguments);
// otherwise
} else {
// trigger an error
$.error('Method "' + method + '" does not exist in powerGallery plugin!');
}
}
// Options par défaut
$.fn.powerGallery.defaults = {
upload_php_file_url: 'bb.jquery.powerGallery/upload.php',
template_html_file_url: 'bb.jquery.powerGallery/template.html',
file_dir: null,
file_url: null,
thumbnail_dir: null,
thumbnail_url: null,
text_browse: 'Parcourir',
text_start: 'Transférer',
text_cancel: 'Annuler',
text_delete: 'Supprimer les fichiers',
width: 800,
height: 600,
thumbnail_width: 80,
thumbnail_height: 80,
thumbnail_margin: 5,
autoUpload: false,
image_loader: 'bb.jquery.powerGallery/loader.gif',
image_add: 'bb.jquery.powerGallery/add.png',
image_next: 'bb.jquery.powerGallery/next.png',
image_prev: 'bb.jquery.powerGallery/prev.png',
admin: false,
pause: 4000
}
// this will hold the merged default and user-provided options
// you will have access to these options like:
// this.pluginName.settings.propertyName from inside the plugin or
// element.pluginName.settings.propertyName from outside the plugin, where "element" is the element the
// plugin is attached to;
$.fn.powerGallery.settings = {
image_container_width: 0,
image_container_height: 0,
thumbnail_nb: 0,
thumbnail_container_width: 0,
thumbnail_container_height: 0,
timeout: null
}
})(jQuery);