/**
* jQuery EasyUI 1.3.6
* Copyright (c) 2009-2014 www.jeasyui.com. All rights reserved.
*
* Licensed under the GPL or commercial licenses
* To use it on other terms please contact author: info@jeasyui.com
* http://www.gnu.org/licenses/gpl.txt
* http://www.jeasyui.com/license_commercial.php
*
* jQuery EasyUI uploadify Plugin Extensions 1.0 beta
* jQuery EasyUI uploadify 插件扩展
* jquery.euploadify.js
* 二次开发 流云
* 最近更新：2014-05-23
*
* 依赖项：
* 1、jquery.jdirk.js v1.0 beta late
* 2、jeasyui.extensions.js v1.0 beta late
* 3、jeasyui.extensions.menu.js v1.0 beta late
* 4、jeasyui.extensions.panel.js v1.0 beta late 和 jeasyui.extensions.window.js v1.0 beta late(可选)
* 5、jeasyui.extensions.progressbar.js v1.0 beta late
* 6、uploadify/jquery.uploadify.js
* 7、uploadify/uploadify.css
* 8、uploadify/uploadify.swf
* 9、uploadify/uploadify.php|uploadify.ashx|uploadify.jsp
*
* Copyright (c) 2013-2014 ChenJianwei personal All rights reserved.
* http://www.chenjianwei.org
*/
(function ($, undefined) {
function create(target) {
var t = $(target).addClass("euploadify-f").hide(),
state = $.data(target, "euploadify"), opts = state.options,
name = state.name = t.attr("name");
state.uploadifyID = "euploadify_" + $.util.guid("N");
state.queueID = "euploadify_queue_" + $.util.guid("N");
state.lastFileID = null;
state.panel = $("").insertAfter(t).append(t).panel($.extend({}, opts, {
onResize: function (width, height) {
$.fn.panel.defaults.onResize.apply(this, arguments);
$.extend(opts, { width: width, height: height });
setSize(target);
if ($.isFunction(opts.onResize)) { opts.onResize.apply(target, arguments); }
}
}));
state.wrapper = state.panel.panel("body").addClass("euploadify-wrapper");
state.queueDOM = $("").appendTo(state.wrapper);
state.queues = [];
t.removeAttr(name).attr("euploadifyName", name);
opts.originalValue = opts.value;
opts.originalFormData = $.extend({}, opts.formData);
initializeUploadify(target);
setValues(target, opts.value);
setSize(target);
if (opts.disabled) { disable(target, opts.disabled); }
setValidation(target)
};
function refreshQueueStatus(queues, file, value) {
var q = $.array.first(queues, function (f) { return f.id == file.id; })
if (q) {
q.filestatus = file.filestatus;
if (value != null) { q.value = value; }
}
};
function initializeUploadify(target) {
var t = $(target), state = $.data(target, "euploadify"), opts = state.options,
template = String(opts.multiTemplate).toLowerCase();
if (!$.array.contains(["uploadify", "simple", "bootstrap", "grid"], template)) {
template = $.fn.euploadify.defaults.multiTemplate;
}
var uopts = {
auto: opts.auto, method: opts.method, multi: opts.multi,
buttonClass: opts.buttonClass, buttonCursor: opts.buttonCursor, buttonImage: opts.buttonImage, buttonText: opts.buttonText,
checkExisting: opts.checkExisting, debug: opts.debug,
fileObjName: opts.fileObjName, fileSizeLimit: opts.fileSizeLimit, fileTypeDesc: opts.fileTypeDesc, fileTypeExts: opts.fileTypeExts,
formData: opts.formData, progressData: opts.progressData,
width: opts.buttonWidth, height: opts.buttonHeight, queueID: state.queueID,
itemTemplate: opts.multi && template != "custome" ? opts.multiTemplateData[template] : opts.itemTemplate,
overrideEvents: opts.overrideEvents, preventCaching: opts.preventCaching,
queueSizeLimit: opts.queueSizeLimit, uploadLimit: opts.uploadLimit,
removeCompleted: opts.removeCompleted, removeTimeout: opts.removeTimeout, requeueErrors: opts.requeueErrors,
swf: opts.swf, uploader: opts.uploader, successTimeout: opts.successTimeout,
onCancel: function (file) {
$.array.remove(state.queues, file, function (q) { return file.id == q.id; });
return opts.onCancel.apply(target, arguments);
},
onClearQueue: function () {
state.queues = [];
return opts.onClearQueue.apply(target, arguments);
},
onDestroy: function () {
state.queues = null;
return opts.onDestroy.apply(target, arguments);
},
onDialogClose: function () { return opts.onDialogClose.apply(target, arguments); },
onDialogOpen: function () { return opts.onDialogOpen.apply(target, arguments); },
onDisable: function () { return opts.onDisable.apply(target, arguments); },
onEnable: function () { return opts.onEnable.apply(target, arguments); },
onFallback: function () { return opts.onFallback.apply(target, arguments); },
onInit: function () { return opts.onInit.apply(target, arguments); },
onQueueComplete: function () { return opts.onQueueComplete.apply(target, arguments); },
onSelect: function (file) {
state.queues.push($.extend({}, file));
return opts.onSelect.apply(target, arguments);
},
onSelectError: function () { return opts.onSelectError.apply(target, arguments); },
onSWFReady: function () { return opts.onSWFReady.apply(target, arguments); },
onUploadComplete: function (file) {
refreshQueueStatus(state.queues, file);
return opts.onUploadComplete.apply(target, arguments);
},
onUploadError: function (file, errorCode, errorMsg, errorString) {
refreshQueueStatus(state.queues, file);
return opts.onUploadError.apply(target, arguments);
},
onUploadProgress: function (file, bytesUploaded, bytesTotal, totalBytesUploaded, totalBytesTotal) {
//refreshQueueStatus(state.queues, file);
return opts.onUploadProgress.apply(target, arguments);
},
onUploadStart: function (file) {
refreshQueueStatus(state.queues, file);
return opts.onUploadStart.apply(target, arguments);
},
onUploadSuccess: function (file, data, response) {
var obj = opts.responseFilter.call(target, data, file),
val = file.value = obj && obj.value != null && obj.value != undefined ? obj.value : null;
refreshQueueStatus(state.queues, file, val);
var values = opts.multi ? $.array.map(getQueuesByStatus(target, -4), function (f) { return f.value; }) : [val];
setValues(target, values);
return opts.onUploadSuccess.apply(target, arguments);
}
};
if (opts.multi) {
state.wrapper.addClass("euploadify-wrapper-multi euploadify-wrapper-multi-" + template);
state.buttonbar = $("").insertBefore(state.queueDOM);
if (template == "grid") {
buildGridPanel(target, uopts);
} else {
buildMultiPanel(target, uopts);
}
} else {
state.wrapper.addClass("euploadify-wrapper-single");
state.queueDOM.addClass("euploadify-hidden");
state.progressbar = $("").insertBefore(state.queueDOM).progressbar({
width: 400, height: 18, value: 0, text: opts.emptyText
});
state.buttonbar = $("").insertAfter(state.progressbar);
var onCancel = uopts.onCancel, onSelect = uopts.onSelect,
onUploadStart = uopts.onUploadStart, onUploadProgress = uopts.onUploadProgress,
onUploadError = uopts.onUploadError, onUploadSuccess = uopts.onUploadSuccess;
$.extend(uopts, {
onCancel: function (file) {
var ret = onCancel.apply(this, arguments), queues = getQueues(target);
if (!queues.length) {
state.progressbar.progressbar("setText", opts.emptyText).progressbar("setValue", 0);
return ret;
}
if (queues.length) {
state.progressbar.progressbar("setText", getFileName(target, queues[0]) + "(" + $.number.toFileSize(file.size) + ") - 0%").progressbar("setValue", 0);
} else {
state.progressbar.progressbar("setText", opts.emptyText).progressbar("setValue", 0);
}
return ret;
},
onSelect: function (file) {
var ret = onSelect.apply(this, arguments);
if (state.lastFileID && !opts.multi) {
state.uploadify.uploadify("cancel", state.lastFileID);
}
if (file) {
state.progressbar.progressbar("setText", getFileName(target, file) + "(" + $.number.toFileSize(file.size) + ") - 0%").progressbar("setValue", 0).
find(".progressbar-value .progressbar-text").removeClass("progressbar-text-success progressbar-text-error");
state.lastFileID = file.id;
} else {
state.progressbar.progressbar("setText", opts.emptyText).progressbar("setValue", 0).
find(".progressbar-value .progressbar-text").removeClass("progressbar-text-success progressbar-text-error");
}
return ret;
},
onUploadStart: function (file) {
var ret = onUploadStart.apply(this, arguments);
t.euploadify("resetFormData");
var data = $.extend({}, file, { customeName: file.name }),
formData = opts.requestFilter.call(target, data, file);
state.uploadify.uploadify("settings", "formData", formData);
return ret;
},
onUploadProgress: function (file, bytesUploaded, bytesTotal, totalBytesUploaded, totalBytesTotal) {
var ret = onUploadProgress.apply(this, arguments),
val = !bytesTotal ? 0 : (bytesUploaded / bytesTotal * 100).round(2);
state.progressbar.progressbar("setText", getFileName(target, file) + "(" + $.number.toFileSize(file.size) + ") - {value}%").progressbar("setValue", val).
find(".progressbar-value .progressbar-text").removeClass("progressbar-text-success progressbar-text-error");
return ret;
},
onUploadError: function (file, errorCode, errorMsg, errorString) {
var ret = onUploadError.apply(this, arguments);
if (!$.array.contains(["Cancelled", "Stopped"], errorString)) {
state.progressbar.progressbar("setText", getFileName(target, file) + "(" + opts.errorText + ":" + errorString + ")").
find(".progressbar-value .progressbar-text").removeClass("progressbar-text-success progressbar-text-error").addClass("progressbar-text-error");
}
return ret;
},
onUploadSuccess: function (file, data, response) {
var ret = onUploadSuccess.apply(this, arguments);
state.progressbar.progressbar("setText", getFileName(target, file) + "(" + opts.finishText + ")").progressbar("setValue", 100).
find(".progressbar-value .progressbar-text").removeClass("progressbar-text-success progressbar-text-error").addClass("progressbar-text-success");
return ret;
}
});
}
state.button = $(" ").appendTo(state.buttonbar);
state.uploadify = $("").insertBefore(state.button.find("span.l-btn-icon")).uploadify(uopts);
state.uploadify = $("#" + state.uploadifyID);
state.uploadButton = $("").appendTo(state.buttonbar).linkbutton({
plain: opts.buttonPlain, text: opts.uploadText, iconCls: opts.uploadIcon,
onClick: function () {
var queues = getQueues(target),
ff = $.array.first(queues, function (val) { return val.filestatus != -4; });
if (!queues || !queues.length || !ff) {
return $.easyui.messager.show(opts.message.queueEmpty);
}
state.uploadify.uploadify("upload", "*");
}
});
state.stopButton = $("").appendTo(state.buttonbar).linkbutton({
plain: opts.buttonPlain, text: opts.stopText, iconCls: opts.stopIcon,
onClick: function () {
state.uploadify.uploadify("stop");
return opts.onButtonStop.call(target, getQueues(target), this);
}
});
state.cancelButton = $("").appendTo(state.buttonbar).linkbutton({
plain: opts.buttonPlain, text: opts.cancelText, iconCls: opts.cancelIcon,
onClick: function () { state.uploadify.uploadify("cancel", "*"); }
});
if (opts.multi && template == "grid") {
$("-").insertAfter(state.button);
if (!opts.auto) {
$("-").insertAfter(state.uploadButton);
}
if (opts.showStop || opts.showCancel) {
$("-").appendTo(state.buttonbar);
}
state.removeButton = $("").appendTo(state.buttonbar).linkbutton({
plain: opts.buttonPlain, text: opts.removeText, iconCls: "icon-hamburg-busy",
onClick: function () {
var rows = state.grid.datagrid("getChecked"), array = $.array.clone(rows);
if (!rows || !rows.length) { return $.easyui.messager.show(opts.message.mustNotEmpty); }
$.each(array, function (i, row) {
var index = state.grid.datagrid("getRowIndex", row);
if (index > -1) { state.grid.datagrid("deleteRow", index); }
state.uploadify.uploadify("cancel", row.id);
$.array.remove(state.queues, row, function (q) { return row.id == q.id; });
});
var values = $.array.map(getQueuesByStatus(target, -4), function (f) { return f.value; });
setValues(target, values);
}
});
state.buttonbar.toolbar();
}
if (opts.tooltip) {
var tooltip = opts.tooltip === true ? $.fn.euploadify.defaults.tooltip : opts.tooltip;
if (state.button) { state.button.tooltip({ content: tooltip.button }); }
if (state.uploadButton) { state.uploadButton.tooltip({ content: tooltip.upload }); }
if (state.stopButton) { state.stopButton.tooltip({ content: tooltip.stop }); }
if (state.cancelButton) { state.cancelButton.tooltip({ content: tooltip.cancel }); }
if (state.removeButton) { state.removeButton.tooltip({ content: tooltip.remove }); }
}
};
function buildMultiPanel(target, uopts) {
var t = $(target), state = $.data(target, "euploadify"), opts = state.options,
onUploadStart = uopts.onUploadStart;
state.queueDOM.on("click", ".uploadify-queue-item .cancel a", function () {
var item = $(this).closest(".uploadify-queue-item"), id = item.attr("id");
$.array.remove(state.queues, id, function (q) { return q.id == id; });
var queues = getQueuesByStatus(target, -4),
values = $.array.map(queues, function (q) { return q.value; });
setValues(target, values.length ? values : [null])
});
$.extend(uopts, {
onUploadStart: function (file) {
var ret = onUploadStart.apply(this, arguments);
t.euploadify("resetFormData");
var data = $.extend({}, file, { customeName: file.name }),
formData = opts.requestFilter.call(target, data, file);
state.uploadify.uploadify("settings", "formData", formData);
return ret;
}
});
};
function buildGridPanel(target, uopts) {
var t = $(target), state = $.data(target, "euploadify"), opts = state.options,
layout = state.layout = $("").insertBefore(state.queueDOM),
north = state.north = $("").appendTo(layout).append(state.buttonbar),
center = state.center = $("").appendTo(layout),
grid = state.grid = $("").appendTo(center);
state.queueDOM.addClass("euploadify-hidden");
layout.layout({ fit: true });
grid.datagrid({
fit: true, border: false, idField: "id", rownumbers: true, refreshMenu: false, extEditing: true, singleEditing: true,
frozenColumns: [[
{ field: "ck", checkbox: true, filterable: false },
{ field: "name", title: "全文件名", width: 100, filterable: false }
]],
columns: [[
{ field: "customeName", title: opts.gridColumnNames.customeName, width: 120, editor: "text", filterable: false },
{ field: "type", title: opts.gridColumnNames.type, width: 60, filterable: false },
{
field: "size", title: opts.gridColumnNames.size, width: 80, filterable: false,
formatter: function (val) { return $.number.toFileSize(val); }
},
{
field: "progress", title: opts.gridColumnNames.progress, width: 80, align: "center", filterable: false,
formatter: function (val, row) {
return "";
}
},
{
field: "progressValue", title: opts.gridColumnNames.progressValue, width: 50, filterable: false,
formatter: function (val) { return String(val || 0) + "%"; }
},
{
field: "filestatus", title: opts.gridColumnNames.filestatus, width: 80, filterable: false,
formatter: function (val, row, index) {
var str = opts.FILE_STATUS[val], ret = val == -3 ?
("" + str + "") :
(val == -4 ? ("" + str + "") : str);
return ret;
}
},
{
field: "operate", title: opts.gridColumnNames.operate, width: 80, filterable: false,
formatter: function (val, row) {
return "\
\
\
\
\
";
}
}
]],
rowContextMenu: [
{
text: opts.gridRowContextNames.edit, iconCls: "icon-edit",
disabled: function () { return opts.disabled || state.wrapper.is(".euploadify-disabled"); },
handler: function (e, index, row) { grid.datagrid("beginEdit", index); }
},
{
text: opts.gridRowContextNames.cancel, iconCls: "icon-standard-delete",
disabled: function () { return opts.disabled || state.wrapper.is(".euploadify-disabled"); },
handler: function (e, index, row) {
if (row.filestatus == -4) {
$.easyui.messager.show(opts.message.fileUploadSuccessCanntCancel);
} else {
state.uploadify.uploadify("cancel", row.id);
}
}
},
{
text: opts.gridRowContextNames.upload, iconCls: "icon-standard-arrow-up",
disabled: function () { return opts.disabled || state.wrapper.is(".euploadify-disabled"); },
handler: function (e, index, row) {
if (row.filestatus == -4) {
$.easyui.messager.show(opts.message.fileUploadSuccess);
} else {
state.uploadify.uploadify("upload", row.id);
}
}
}
],
onBeginEdit: function (index, row) {
if ($.array.contains([-2, -4, -5], row.filestatus)) {
var msg = $.string.format(opts.message.fileCannotRename, opts.FILE_STATUS[row.filestatus]);
$.easyui.messager.show(msg);
grid.datagrid("cancelEdit", index);
}
return $.fn.datagrid.defaults.onBeginEdit.apply(this, arguments);
},
onAfterEdit: function (index, row, changes) {
if (!row.customeName) {
$.easyui.messager.show(opts.message.fileNameCannotEmpty);
var array = String(row.name).split("."), temp = $.array.removeAt(array, array.length - 1), name = temp.join("");
grid.datagrid("updateRow", { index: index, row: { customeName: name } });
}
return $.fn.datagrid.defaults.onAfterEdit.apply(this, arguments);
}
});
var onCancel = uopts.onCancel, onSelect = uopts.onSelect,
onUploadStart = uopts.onUploadStart, onUploadProgress = uopts.onUploadProgress,
onUploadError = uopts.onUploadError, onUploadComplete = uopts.onUploadComplete;
$.extend(uopts, {
onCancel: function (file) {
var ret = onCancel.apply(this, arguments),
id = file.id, index = grid.datagrid("getRowIndex", id);
if (index > -1) { grid.datagrid("deleteRow", index); }
return ret;
},
onSelect: function (file) {
var ret = onSelect.apply(this, arguments),
nameArray = String(file.name).split("."),
tempName = $.array.removeAt(nameArray, nameArray.length - 1), name = tempName.join(""),
row = $.extend({}, file, { customeName: name, progress: 0, progressValue: 0 });
grid.datagrid("appendRow", row);
return ret;
},
onUploadStart: function (file) {
var ret = onUploadStart.apply(this, arguments),
id = file.id, index = grid.datagrid("getRowIndex", id), row = index > -1 ? grid.datagrid("getRowData", index) : null;
if (row) {
t.euploadify("resetFormData");
var data = $.extend({}, row, { customeName: row.customeName + file.type }),
formData = opts.requestFilter.call(target, data, file);
state.uploadify.uploadify("settings", "formData", formData);
grid.datagrid("updateRow", { index: index, row: { filestatus: file.filestatus } });
}
return ret;
},
onUploadProgress: function (file, bytesUploaded, bytesTotal, totalBytesUploaded, totalBytesTotal) {
var ret = onUploadProgress.apply(this, arguments),
val = !bytesTotal ? 0 : (bytesUploaded / bytesTotal * 100).round(2), id = file.id, index = grid.datagrid("getRowIndex", id);
if (index > -1) {
grid.datagrid("updateRow", { index: index, row: { progress: val, progressValue: val, filestatus: file.filestatus } });
}
return ret;
},
onUploadError: function (file, errorCode, errorMsg, errorString) {
var ret = onUploadError.apply(this, arguments),
id = file.id, index = grid.datagrid("getRowIndex", id), row = index > -1 ? grid.datagrid("getRowData", index) : null;
if (row) {
state.uploadify.uploadify("settings", "formData", row);
grid.datagrid("updateRow", { index: index, row: { errorString: errorCode + "," + errorMsg + "," + errorString } });
}
return onUploadError.apply(this, arguments);
},
onUploadComplete: function (file) {
var ret = onUploadComplete.apply(this, arguments),
id = file.id, index = grid.datagrid("getRowIndex", id);
if (index > -1) {
grid.datagrid("updateRow", { index: index, row: { filestatus: file.filestatus } });
}
return ret;
}
});
};
function getOptions(target) {
var state = $.data(target, "euploadify"), opts = state.panel.panel("options");
return $.extend(state.options, {
title: opts.title, iconCls: opts.iconCls, width: opts.width, height: opts.height, left: opts.left, top: opts.top,
cls: opts.cls, headerCls: opts.headerCls, bodyCls: opts.bodyCls, style: opts.style, fit: opts.fit, border: opts.border,
doSize: opts.doSize, noheader: opts.noheader, collapsible: opts.collapsible, minimizable: opts.minimizable, maximizable: opts.maximizable,
closable: opts.closable, collapsed: opts.collapsed, minimized: opts.minimized, maximized: opts.maximized, closed: opts.closed
});
};
function getUploadify(target) {
return $.data(target, "euploadify").uploadify;
};
function getButtons(target) {
return $.data(target, "euploadify").buttonbar.find("a.euploadify-button");
};
function getFileName(target, file) {
if (!file || !file.name) { return $(target).euploadify("options").emptyText; }
return $.string.getByteLen(file.name) > 28 ? $.string.leftBytes(file.name, 25) + "..." : file.name;
};
function getQueueDOM(target) {
return $.data(target, "euploadify").queueDOM;
};
function getGrid(target) {
return $.data(target, "euploadify").grid;
};
function getQueues(target) {
return $.array.clone($.data(target, "euploadify").queues);
};
function getQueuesByStatus(target, status) {
return $.array.filter(getQueues(target), function (q) { return q.filestatus == status; });
};
function setSize(target) {
var t = $(target), state = $.data(target, "euploadify"), opts = state.options;
if (state.buttonbar && state.progressbar && !opts.multi) {
var fit = t._fit(false), width = fit.width - state.buttonbar.outerWidth() - 15;
state.progressbar.progressbar("resize", width);
}
};
function cancel(target, param) {
var state = $.data(target, "euploadify");
state.uploadify.uploadify("cancel", param);
};
function destroy(target) {
var t = $(target), state = $.data(target, "euploadify");
state.uploadify.uploadify("destroy");
state.panel.panel("destroy");
t.remove();
}
function disable(target, setDisabled) {
if (setDisabled == null || setDisabled == undefined) {
setDisabled = true;
}
var t = $(target), state = $.data(target, "euploadify"), opts = state.options;
opts.disabled = setDisabled;
var buttons = state.buttonbar.find(".euploadify-button:not(.euploadify-select)");
if (setDisabled) {
t.attr("disabled", true);
state.wrapper.addClass("euploadify-disabled");
state.button.addClass("l-btn-disabled");
if (opts.buttonPlain) { state.button.addClass("l-btn-plain-disabled"); }
$.util.tryExec(function () {
state.uploadify.uploadify("stop");
});
buttons.linkbutton("disable");
} else {
t.removeAttr("disabled");
state.wrapper.removeClass("euploadify-disabled");
state.button.removeClass("l-btn-disabled");
if (opts.buttonPlain) { state.button.removeClass("l-btn-plain-disabled"); }
buttons.linkbutton("enable");
}
$.util.tryExec(function () {
state.uploadify.uploadify("disable", setDisabled);
});
};
function enable(target) {
disable(target, false);
};
function stop(target) {
$.data(target, "euploadify").uploadify.uploadify("stop");
};
function upload(target, param) {
$.data(target, "euploadify").uploadify.uploadify("upload", param);
};
function resize(target, param) {
var state = $.data(target, "euploadify");
state.panel.panel("resize", param);
};
function settings(target, param) {
var t = $(target);
if (!param) { return t; }
var state = $.data(target, "euploadify"), opts = state.options;
if (typeof param == "string") {
return opts[param];
} else {
if (param.name) {
opts[param.name] = param.value;
state.uploadify.uploadify("settings", param.name, param.value);
}
return t;
}
};
function setFormData(target, param) {
param = param || {};
var state = $.data(target, "euploadify"), opts = state.options,
swfuploadify = state.uploadify.data("uploadify"),
settings = swfuploadify.settings;
settings.formData = {};
swfuploadify.setPostParams(opts.formData = $.extend(settings.formData, param));
};
function resetFormData(target) {
var state = $.data(target, "euploadify"), opts = state.options;
setFormData(target, opts.originalFormData);
};
function clearFormData(target) {
setFormData(target, {});
};
function hideTip(target) {
var state = $.data(target, "euploadify");
state.tip = false;
state.wrapper.tooltip("hide");
};
function showTip(target) {
var state = $.data(target, "euploadify"), opts = state.options;
state.wrapper.tooltip($.extend({}, opts.tipOptions, { content: opts.missingMessage, position: opts.tipPosition, deltaX: opts.deltaX })).tooltip("show");
state.tip = true;
};
function repositionTip(target) {
var state = $.data(target, "euploadify");
if (state && state.tip) {
state.wrapper.tooltip("reposition");
}
};
function initializeValidate(target) {
var t = $(target), state = $.data(target, "euploadify"), opts = state.options;
state.wrapper.unbind(".euploadify");
if (opts.novalidate) {
return;
}
state.wrapper.bind("focus.euploadify", function () {
state.validating = true;
state.values = undefined;
(function () {
if (state.validating) {
var values = t.euploadify("getValues").join(opts.separator);
if (state.values != values) {
state.values = values;
if (state.timer) {
clearTimeout(state.timer);
}
state.timer = setTimeout(function () { t.euploadify("validate"); }, opts.delay);
} else {
repositionTip(target);
}
setTimeout(arguments.callee, 200);
}
})();
}).bind("blur.euploadify", function () {
if (state.timer) {
clearTimeout(state.timer);
state.timer = undefined;
}
state.validating = false;
hideTip(target);
}).bind("mouseenter.euploadify", function () {
if (state.wrapper.hasClass("euploadify-invalid")) {
showTip(target);
}
}).bind("mouseleave.euploadify", function () {
if (!state.validating) {
hideTip(target);
}
});
};
function validate(target) {
var t = $(target), state = $.data(target, "euploadify"), opts = state.options,
values = t.euploadify("getValues"), str = values.join(opts.separator);
state.wrapper.removeClass("euploadify-invalid");
hideTip(target);
if (!opts.novalidate && opts.required && (!values.length || !str) && !t.is(":disabled") && !state.wrapper.hasClass("euploadify-disabled")) {
state.wrapper.addClass("euploadify-invalid");
if (state.validating) {
showTip(target);
}
return false;
}
return true;
};
function setValidation(target, novalidate) {
var state = $.data(target, "euploadify"), opts = state.options;
if (novalidate != undefined && novalidate != null) {
opts.novalidate = novalidate;
}
if (opts.novalidate) {
state.wrapper.removeClass("euploadify-invalid");
hideTip(target);
}
initializeValidate(target);
};
function getValues(target) {
var state = $.data(target, "euploadify"), opts = state.options,
fields = state.wrapper.find(".euploadify-value"),
values = $.array.map(fields, function (val) { return $(val).val(); });
state.values = values.join(opts.separator);
return opts.values = values;
};
function getValue(target) {
var values = getValues(target);
return values[0];
};
function setValues(target, values) {
var t = $(target), state = $.data(target, "euploadify"), opts = state.options,
original = t.euploadify("getValues"),
array = $.util.likeArrayNotString(values) ? values : [values];
state.wrapper.find(".euploadify-value").remove();
$.each(array, function (i, val) {
var field = $("").appendTo(state.wrapper).val(val);
if (state.name) {
field.attr("name", state.name);
}
});
var temps = $.array.filter(array, function (val) {
return $.array.contains(original, val) ? false : true;
});
if (temps.length != array.length || array.length != original.length) {
if (opts.multi) {
opts.onChange.call(target, array, original);
} else {
opts.onChange.call(target, array[0], original[0]);
}
}
state.values = array.join(opts.separator);
opts.values = array;
};
function setValue(target, value) {
setValues(target, [value]);
};
function clear(target) { setValues(target, []); };
function reset(target) {
var state = $.data(target, "euploadify"), opts = state.options;
setValues(target, opts.originalValue);
};
function show(target) {
var state = $.data(target, "euploadify");
state.panel.panel("open");
return getOptions(target);
};
function hide(target) {
var state = $.data(target, "euploadify");
state.panel.panel("close");
return getOptions(target);
};
$.fn.euploadify = function (options, param) {
if (typeof options == "string") {
var method = $.fn.euploadify.methods[options];
if (method) {
return method(this, param);
} else {
return this.euploadify("panel").panel(options, param);
}
}
options = options || {};
return this.each(function () {
var state = $.data(this, "euploadify");
if (state) {
$.extend(state.options, options);
} else {
$.data(this, "euploadify", { options: $.extend({}, $.fn.euploadify.defaults, $.fn.euploadify.parseOptions(this), options) });
create(this);
}
});
};
function operateQueue(mini, method) {
var btn = $(mini), t = btn.closest("div.euploadify-wrapper").find(".euploadify-f"),
state = $.data(t[0], "euploadify"), opts = state.options;
if (!opts.disabled && !state.wrapper.is(".euploadify-disabled")) {
var index = window.parseInt(btn.closest("tr.datagrid-row").attr("datagrid-row-index")),
row = state.grid.datagrid("getRowData", index);
if (row.filestatus == -4) {
var msg = {
cancel: opts.message.fileUploadSuccessCanntRemove,
upload: opts.message.fileUploadSuccess
};
$.easyui.messager.show(msg[method]);
} else {
state.uploadify.uploadify(method, row.id);
}
}
if (window.event && window.event.stopPropagation) {
window.event.stopPropagation();
}
return false;
};
$.fn.euploadify.cancelQueue = function (mini) {
return operateQueue(mini, "cancel");
};
$.fn.euploadify.uploadQueue = function (mini) {
return operateQueue(mini, "upload");
};
$.fn.euploadify.parseOptions = function (target) {
return $.extend({}, $.parser.parseOptions(target, [
"buttonClass", "buttonCursor", "buttonImage", "buttonText", "checkExisting", "fileObjName",
"fileTypeDesc", "fileTypeExts", "itemTemplate", "method", "progressData", "queueID", "swf", "uploader",
"uploadText", "stopText", "cancelText", "removeText", "emptyText", "finishText", "errorText",
"buttonIcon", "stopIcon", "cancelIcon", "uploadIcon", "multiTemplate",
"value", "width", "height", "missingMessage", "tipPosition", "separator",
{
auto: "boolean", debug: "boolean", multi: "boolean", preventCaching: "boolean", removeCompleted: "boolean", requeueErrors: "boolean",
disabled: "boolean", buttonPlain: "boolean", showStop: "boolean", showCancel: "boolean", required: "boolean", novalidate: "boolean"
},
{
fileSizeLimit: "number", height: "number", queueSizeLimit: "number", removeTimeout: "number", successTimeout: "number", uploadLimit: "number", width: "number",
buttonWidth: "number", buttonHeight: "number", deltaX: "number"
}
]));
};
// 提供外部调用公共方法 $.easyui.showEuploadifyDialog 用于快速创建 euploadify 文件上传对话框；
// 该方法的参数 options 参考继承于方法 $.easyui.showDialog 和插件 easyui-euploadify 的参数格式，在在此基础上增加了如下描述的属性：
// title : string
// value : string
// onEnter : function(val, euploadify, uploadify, btn)
// onCancel: function(val, euploadify, uploadify, btn)
// ...
// 返回值：返回创建的 easyui-dialog 对象；
$.easyui.showEuploadifyDialog = function (options) {
if (options && options.topMost && $ != $.util.$ && $.util.$.easyui.showEuploadifyDialog) {
return $.util.$.easyui.showEuploadifyDialog.apply(this, options);
}
var opts = $.extend({}, $.easyui.showEuploadifyDialog.defaults, options || {}),
euploadify, uploadify, value = opts.value,
dia = $.easyui.showDialog($.extend({}, opts, {
content: "",
enableApplyButton: false, topMost: false,
height: opts.height == "auto" ? (opts.multi ? 480 : 160) : opts.height,
onBeforeDestroy: function () { if (euploadify) { euploadify.euploadify("destroy"); } },
onSave: function () { return opts.onEnter.call(dia, getValue(), euploadify, uploadify, this); },
onClose: function () { return opts.onCancel.call(dia, getValue(), euploadify, uploadify, this); }
}));
$.util.exec(function () {
var container = dia.find(".euploadify-dialog-container").euploadify($.extend({}, opts, {
fit: true, border: false, noheader: true, value: value
}));
dia.euploadify = euploadify = container;
uploadify = container.euploadify("uploadify");
euploadify.euploadify("resize");
});
function getValue() {
if (!euploadify || !uploadify) { return value; }
var eopts = euploadify.euploadify("options");
return euploadify.euploadify(eopts.multi ? "getValues" : "getValue");
};
return dia;
};
$.easyui.showEuploadifyDialog.defaults = {
title: "文件上传对话框",
iconCls: "icon-hamburg-publish",
width: 750, height: "auto", minWidth: 400, minHeight: 160,
maximizable: true, collapsible: true,
multi: false, value: null,
onEnter: function (val, editor, btn) { },
onCancel: function (val, editor, btn) { }
};
$.fn.euploadify.methods = {
options: function (jq) { return getOptions(jq[0]); },
panel: function (jq) { return $.data(jq[0], "euploadify").panel; },
uploadify: function (jq) { return getUploadify(jq[0]); },
buttons: function (jq) { return getButtons(jq[0]); },
queueDOM: function (jq) { return getQueueDOM(jq[0]); },
grid: function (jq) { return getGrid(jq[0]); },
// 从当前上传队列中取消一个或多个文件的上传；该方法的参数 param 可以定义为如下数据类型：
// String : 表示要取消上传的文件的 id 值；如果不定义该参数，则取消队列中第一个文件的上传；如果该值定义为 "*"，则取消队列中所有文件上传；
// Boolean : 默认为 false；如果定义为 true，则执行该方法时将不触发 onUploadCancel 事件；
// 返回值：返回表示当前 easyui-euploadify 控件的 jQuery 链式对象。
cancel: function (jq, param) { return jq.each(function () { cancel(this, param); }); },
// 从当前文档上下文中销毁该 easyui-euploadify 控件；该方法将触发 onDestroy 事件；
// 返回值：返回表示当前 easyui-euploadify 控件的 jQuery 链式对象。
destroy: function (jq) { return jq.each(function () { destroy(this); }); },
// 禁用该 easyui-euploadify 控件；该方法将触发 onDisable 事件；
// 该方法的参数 setDisabled 为 Boolean 类型值，为 true 时表示禁用上传按钮；为 false 表示启用上传按钮；
// 注意：该方法会导致当前的上传任务停止；
// 返回值：返回表示当前 easyui-euploadify 控件的 jQuery 链式对象。
disable: function (jq, setDisabled) { return jq.each(function () { disable(this, setDisabled); }); },
// 获取或设置 easyui-euploadify 控件中指定名称的属性值；该方法的参数 param 可以定义为如下数据类型：
// String : 该参数指定一个属性名称，该属性名所示的属性值将会被返回；
// Object : 格式如 { name: string, value: object }；设定指定名称的属性为指定的值。
// 返回值：返回表示当前 easyui-euploadify 控件中指定名称的属性值；或者返回表示当前 easyui-euploadify 控件的 jQuery 链式对象。
settings: function (jq, param) { return settings(jq[0], param); },
// 停止当前上传队列中所有文件的上传。
// 返回值：返回表示当前 easyui-euploadify 控件的 jQuery 链式对象。
stop: function (jq) { return jq.each(function () { stop(this); }); },
// 获取当前上传队列中有多少文件数量；
// 返回值：返回一个 array 类型数组，数组中的每一项都是一个 file 对象；
queues: function (jq) { return getQueues(jq[0]); },
// 立即上传当前队列中的特定文件或所有文件。该方法的参数 param 可以定义为如下数据类型：
// String : 表示要立即上传的文件 id 值；如果不定义该参数，则上传队列中的第一个文件；如果该值定义为 "*"，则上传队列中所有文件；
// 返回值：返回表示当前 easyui-euploadify 控件的 jQuery 链式对象。
upload: function (jq, param) { return jq.each(function () { upload(this, param); }); },
setFormData: function (jq, param) { return jq.each(function () { setFormData(this, param); }); },
resetFormData: function (jq) { return jq.each(function () { resetFormData(this); }); },
clearFormData: function (jq) { return jq.each(function () { clearFormData(this); }); },
resize: function (jq, param) { return jq.each(function () { resize(this, param); }); },
enable: function (jq) { return jq.each(function () { enable(this); }); },
validate: function (jq) { return jq.each(function () { validate(this); }); },
isValid: function (jq) { return validate(jq[0]); },
enableValidation: function (jq) { return jq.each(function () { setValidation(this, false) }); },
disableValidation: function (jq) { return jq.each(function () { setValidation(this, true) }); },
clear: function (jq) { return jq.each(function () { clear(this); }); },
reset: function (jq) { return jq.each(function () { reset(this); }); },
getValues: function (jq) { return getValues(jq[0]); },
setValues: function (jq, values) { return jq.each(function () { setValues(this, values); }); },
getValue: function (jq) { return getValue(jq[0]); },
setValue: function (jq, value) { return jq.each(function () { setValue(this, value); }); },
show: function (jq) { return jq.each(function () { show(this); }); },
hide: function (jq) { return jq.each(function () { hide(this); }); }
};
$.fn.euploadify.defaults = {
// 表示 "上传" 按钮的宽度(像素值)；
width: 120,
// 表示 "上传" 按钮的高度(像素值)；
height: 30,
// 表示当选择了待上传文件后，是否自动执行 upload 方法以上传文件；
auto: true,
// 表示 uploadify.swf SWFObject Flash 对象的相对路径；该参数必须设置正确，否则上传控件将无效；
swf: "uploadify.swf",
// 表示服务器端接收上传数据的 url 相对路径；该参数必须设置正确，否则上传控件将无效；
uploader: "uploadify.php",
// 表示能够上传文件的最大数量；当文件数超出此限制时，将会触发 onUploadError 事件；
uploadLimit: 999,
// 表示文件上传时进行 ajax 提交的方法；可选的值为 "post" 或 "get"；
method: "post",
// 表示文件在上传过程中，每一个文件块的上传超时事件(秒)；
successTimeout: 30,
// 表示被添加到 "上传" 按钮的 html-css 样式类名
buttonClass: "",
// 表示当鼠标移动至 "上传" 按钮时，鼠标显示的样式，可能的值为 "hand" 或 "arrow"
buttonCursor: "hand",
// 表示 "上传" 按钮附加的背景图片；如果需要设置一个 "上传" 按钮的鼠标悬停时显示的图标，可以用 buttonClass 属性并定义一个具有 hover 效果的 css；
buttonImage: null,
// 表示 "上传" 按钮显示的按钮文本；该值也可以定义为 html 标签包含的文本内容，例如 SELECT FILES；
buttonText: "SELECT FILES",
// 表示是否校验服务器目标文件夹中已经存在待上传的文件名；
// 该值如果定义为布尔值 false，则表示不进行校验；
// 如果定义为一个服务器 url 地址例如 "/uploadify/check-exists.php"，则表示进行服务器校验；该地址如果返回 1 则表示服务器上存在指定的文件名；如果返回 0 则表示不存在。
checkExisting: false,
// 表示是否开启 SWFUpload 对象的调试模式
debug: false,
// 表示待上传文件对象提交至服务器时，采用的表单字段名；例如当该值定义为 "Filedata" 时，ASP.NET 服务器端可以用 HttpContext.Current.Request["Filedata"] 获取文件的二进制对象；
fileObjName: "Filedata",
// 表示文件上传大小上限；
// 该值可以定义为一个 Number 值，表示文件最大字节数(KB为单位)；
// 也可以定义为一个以 "KB"、"MB" 或 "GB" 结尾的 String 值；
// 如果该属性值为 0，则表示不限制文件的上传大小；
fileSizeLimit: 0,
// 表示可选择的上传文件类型的描述；
fileTypeDesc: "All Files",
// 表示可选择的上传文件的扩展名列表，多个扩展名用半角分号隔开，例如 "*.jpg; *.png; *.gif"
// 注意：手动输入的文件名将会绕过此验证规则，因此在服务端还需要进行文件类型的校验；
fileTypeExts: "*.*",
// 表示随待上传文件被提交至服务器端时，被一并发送至服务器的表单参数；可以在 onUploadStart 事件中动态设置这些参数；
formData: {},
// 表示上传文件队列的 HTML 页面显示模板；该值定义为 false 表示按照默认格式显示；该模版中可以使用如下四个变量标签：
// instanceID:
// fileID:
// fileName:
// fileSize:
// 模板使用变量标签的格式如：${fileName}.
itemTemplate: false,
// 表示是否能够同时上传多个文件；
multi: true,
// 一个 array: 格式数组，数组中的每一项都是一个表示 uploadify 事件名称的字符串；
// 该属性表示哪些事件在 uploadify 的生命周期中将不会被触发执行；
overrideEvents: [],
// 表示浏览器是否缓存 SWFObject；如果该值设置为 false，则 SWF 文件的 url 中将会被添加一个随机值参数，以实现 SWFObject 不缓存效果；
preventCaching: true,
// 表示文件上传时的文件上传进度显示方式；
// percentage: 表示上传时显示上传进度百分比
// speed: 表示上传时显示上传速度
progressData: "percentage",
// 一个 HTML-DOM 元素的 ID 值，用于作为文件上传队列显示的容器；如果定义该值，则文件上传队列中每个上传的元素将会被附加到这个 DOM 对象中；
// 如果该值定义为 false，则文件上传队列显示容器将会动态生成；
queueID: false,
// 表示能够同时执行上传操作的文件最大数量；这并不限制该控件可上传文件的最大数量；要限制可上传文件最大数量请用 uploadLimit 参数；
// 如果添加到上传队列中的文件数量超过此限制，将会触发 onSelectError 事件；
queueSizeLimit: 999,
// 表示是否可以移除已经上传完成的文件；
removeCompleted: true,
// 表示文件上传完成后将会延迟多少秒后采用上传队列中被移除；
removeTimeout: 3,
// 表示文件在上传过程中如果出错是否自动重新上传；
requeueErrors: false,
// 当上传队列中的一个或多个文件被执行 cancel 方法而从队列中取消时，该事件将会被触发；
// file : object 类型值；表示被取消上传的文件对象；
onCancel: function (file) { },
// 当 cancel 方法被执行并且参数值为 "*"，该事件将会被触发；
// queueItemCount: number 类型值；表示取消上传的文件总数量
onClearQueue: function () { },
// 当 destroy 方法被调用时，该事件将会被触发；
onDestroy: function () { },
// 当浏览文件对话框被关闭时，该事件将会被触发；如果该事件会添加至 overrideEvents 属性，则在将文件添加到上传队列中时如果出现错误，将不会弹出警告消息；
// queueData: object 类型值，格式如 { filesSelected: number, filesQueued: number, filesReplaced: number, filesCancelled: number, filesErrored: number }
onDialogClose: function (queueData) { },
// 当打开浏览文件对话框后，该事件将会被触发；注意，该事件函数不会在浏览文件对话框打开时被立即执行，而是在窗口关闭时执行。
onDialogOpen: function () { },
// 当 disable 方法被调用时，该事件将会被触发；
onDisable: function () { },
// 当 disable 方法被调用并且 setDisabled 值为 false 以启用按钮时，该事件将会被触发；
onEnable: function () { },
// 在上传控件初始化过程中，如果当前浏览器的 Flash 插件版本不兼容，该事件将会被触发；
onFallback: function () { },
// 在 easyui-euploadify 控件第一次被初始化完成后，该事件将会被触发；
// instance: 表示 uploadify 对象；
onInit: function (instance) { },
// 当上传队列中所有文件被处理完成后，该事件将会被触发；
// queueData: object 类型值，格式如 { uploadsSuccessful: number, uploadsErrored: number }
onQueueComplete: function (queueData) { },
// 当打开文件浏览器对话框并选择了要上传的文件之后，该事件将会被触发；
// file: 表示被选择的待上传文件；
onSelect: function (file) { },
// 当打开文件浏览器对话框并在选择文件出错后，该事件将会被触发；针对每个选择文件出错后，该事件都会被触发一次；
// file: 表示触发异常事件的文件对象；
// errorCode:表示错误代码，可能的值为如下几种：
// QUEUE_LIMIT_EXCEEDED: 选定的文件数量超过限制；
// FILE_EXCEEDS_SIZE_LIMIT:选定的文件大小超过限制；
// INVALID_FILETYPE: 选定的文件类型超过限制；
// errorMsg:表示触发该事件时的错误消息；
onSelectError: function (file, errorCode, errorMsg) { },
// 当该控件的 Flash 插件对象加载完成后，该事件将会被触发；
onSWFReady: function () { },
// 当文件上传完成(不管成功还是失败)，该事件将会被触发；针对每个上传的文件，该事件都会触发一次；
// file: 表示触发该事件的文件对象；
onUploadComplete: function (file) { },
// 当文件上传失败后，该事件将会被触发；针对每个上传失败的文件，该事件都会触发一次；
// file: 表示触发该事件的文件对象；
// errorCode: 表示错误编号
// errorMsg: 表示错误消息
// errorString:表示错误消息字符串，可能包含所有的错误细节的可读内容；
onUploadError: function (file, errorCode, errorMsg, errorString) { },
// 当文件上传进度每次更新时，该事件将会被触发；针对每个上传文件的每次进度更新，该事件都会触发一次；
// file: 表示触发该事件的文件对象；
// bytesUploaded: 表示该文件自开始上传时至当前时刻已上传的字节总数；
// bytesTotal: 表示该文件的字节总数；
// totalBytesUploaded: 表示目前为止所有文件的上传字节总数；
// totalBytesTotal: 表示所有文件的字节总数
onUploadProgress: function (file, bytesUploaded, bytesTotal, totalBytesUploaded, totalBytesTotal) { },
// 当文件上传进度每次更新时，该事件将会被触发；
// file: 表示将要被上传的文件对象；
onUploadStart: function (file) { },
// 当文件上传成功完成时，该事件将会被触发；针对每个上传成功的文件，该事件都会触发一次；
// file: 表示上传完成的文件对象；
// data: 文件上传完成后，由服务器端返回的数据；
// response: 表示文件是否上传成功；boolean 类型值；如果为 true 则表示文件上传成功；
// 如果该值为 false，则表示当提交上传后并超过 successTimeout 属性设置的超时时间后，服务器任未有数据返回(文件上传失败)；
onUploadSuccess: function (file, data, response) { }
};
$.extend($.fn.euploadify.defaults, {
successTimeout: 3600,
removeCompleted: false,
formData: { folder: "uploads" },
buttonText: "选择文件...",
multi: false,
auto: true,
uploadText: "上传",
stopText: "停止上传",
cancelText: "取消上传",
removeText: "移除选择",
emptyText: "未选择文件",
finishText: "上传完成!",
errorText: "上传失败",
// 设置按钮提示文字；
// 该属性可以为一个格式如 { button: string, upload: string, stop: string, cancel: string, remove: string } 的对象，表示每个按钮的提示文字内容；
// 也可以是一个 boolean 类型值，表示是否启用按钮文字提示；
tooltip: {
button: "打开文件浏览器窗口并选择需要上传的文件",
upload: "上传当前文件队列中所有未上传的文件",
stop: "停止当前文件上传队列中所有文件的上传动作",
cancel: "取消当前文件队列中所有未上传文件的上传任务",
remove: "取消选定行的上传任务并删除该行"
},
message: {
queueEmpty: "当前上传队列中没有待上传文件.",
mustNotEmpty: "请至少选择一行数据.",
fileUploadSuccessCanntCancel: "该文件已经上传完成，无法取消！",
fileUploadSuccess: "该文件已经上传完成！",
fileCannotRename: "该文件处于\"{0}\"状态，不能编辑\"自定义文件名\"，编辑状态已撤销.",
fileNameCannotEmpty: "自定义文件名不能为空（已经恢复）",
fileUploadSuccessCanntRemove: "该文件已经上传完成，无法取消(如想移除该行请选中该行后点击上方按钮\"移除选择\")！"
},
gridColumnNames: {
name: "全文件名", customeName: "自定义文件名", type: "类型", size: "大小",
progress: "上传进度", progressValue: "进度值", filestatus: "状态", operate: "操作"
},
gridRowButtonNames: {
cancel: "取消", upload: "上传"
},
gridRowContextNames: {
edit: "编辑文件名", cancel: "取消该文件", upload: "上传该文件"
},
FILE_STATUS: { "-1": "等待上传", "-2": "正在上传...", "-3": "上传出错", "-4": "上传完成", "-5": "已取消" },
buttonIcon: "icon-search",
stopIcon: "icon-hamburg-stop",
cancelIcon: "icon-standard-cancel",
uploadIcon: "icon-hamburg-publish",
response: { "id": null, "status": false, "message": null, "value": null, "url": null },
requestFilter: function (data, file) { return data; },
responseFilter: function (data, file) {
return $.util.tryExec(function () { return $.util.parseJSON(data); });
},
// 在设置控件允许可以同时上传多个文件时(multi: true)，多文件列表的显示方式；String 类型值，可选的值限定如下范围：
// uploadify:
// simple:
// list:
// grid:
multiTemplate: "grid",
multiTemplateData: {
uploadify: $.fn.euploadify.defaults.itemTemplate,
simple: "\
\
${fileName} (${fileSize})\