mosaico 1.0.0

data/vendor/assets/mosaico-0.16.0/mosaico/src/js/bindings/choose-template.js

@@ -0,0 +1,7 @@
+"use strict";
+
+// script template is the one provided by KO and deals with tempaltes defined as <script type=text/html.
+// string template defines them in memory and avoids polluting the HTML: seems to work better in Mosaico.
+
+module.exports = require('./string-template.js');
+// module.exports = require('./script-template.js');

data/vendor/assets/mosaico-0.16.0/mosaico/src/js/bindings/colorpicker.js

@@ -0,0 +1,58 @@
+"use strict";
+/* global global: false */
+
+require("evol-colorpicker");
+
+var $ = require("jquery");
+var ko = require("knockout");
+var kojqui = require("knockout-jqueryui");
+
+
+var ColorPicker = function() {
+  kojqui.BindingHandler.call(this, 'colorpicker');
+};
+ColorPicker.prototype = kojqui.utils.createObject(kojqui.BindingHandler.prototype);
+ColorPicker.prototype.constructor = ColorPicker;
+
+ColorPicker.prototype.init = function(element, valueAccessor, allBindings) {
+  var va = valueAccessor();
+  var value = va.color;
+
+  // In order to have a correct dependency tracking in "ifSubs" we have to ensure we use a single computer for each editable
+  // property. Given this binding needs 2 of them, we create a computed so to "proxy" the dependencies.
+  var newDO = ko.computed({
+    read: value,
+    write: value,
+    disposeWhenNodeIsRemoved: element
+  });
+  var newVA = function() {
+    return newDO;
+  };
+
+  ko.bindingHandlers.value.init(element, newVA, allBindings);
+
+  var changePropagator = function(event, color) {
+    if (typeof color !== 'undefined') newDO(color);
+  };
+  $(element).on('change.color', changePropagator);
+
+  ko.computed({
+    read: function() {
+      var opt = {
+        color: ko.utils.unwrapObservable(newDO),
+        showOn: 'button'
+      };
+      for (var prop in va)
+        if (prop !== 'color' && va.hasOwnProperty(prop)) opt[prop] = ko.utils.unwrapObservable(va[prop]);
+      $(element).colorpicker(opt);
+    },
+    disposeWhenNodeIsRemoved: element
+  });
+
+  ko.utils.domNodeDisposal.addDisposeCallback(element, function() {
+    $(element).off('change.color', changePropagator);
+    $(element).colorpicker('destroy');
+  });
+
+};
+kojqui.utils.register(ColorPicker);

data/vendor/assets/mosaico-0.16.0/mosaico/src/js/bindings/csstext.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var ko = require("knockout");
+
+/* https://github.com/knockout/knockout/issues/1171 */
+ko.bindingHandlers.cssText = {
+  'update': function(node, valueAccessor, allBindings) {
+    var text = ko.utils.unwrapObservable(valueAccessor());
+    try {
+      node.innerText = text;
+    } catch (e) {
+      if (!node.styleSheet) node.innerHTML = "a{}";
+      node.styleSheet.cssText = text;
+    }
+  }
+};

data/vendor/assets/mosaico-0.16.0/mosaico/src/js/bindings/droppable.js

@@ -0,0 +1,87 @@
+"use strict";
+
+var $ = require("jquery");
+var ko = require("knockout");
+
+/* knockout droppable, with simplified UMD */
+;(function(factory) {
+  factory(ko, $);
+})(function(ko, $) {
+  var ITEMKEY = "ko_sortItem",
+    INDEXKEY = "ko_sourceIndex",
+    LISTKEY = "ko_sortList",
+    PARENTKEY = "ko_parentList",
+    DRAGKEY = "ko_dragItem",
+    unwrap = ko.utils.unwrapObservable,
+    dataGet = ko.utils.domData.get,
+    dataSet = ko.utils.domData.set;
+
+  ko.bindingHandlers.droppable = {
+    init: function(element, valueAccessor, allBindingsAccessor, data, context) {
+      var $element = $(element),
+        value = ko.utils.unwrapObservable(valueAccessor()) || {},
+        droppable = {},
+        dropActual;
+
+      $.extend(true, droppable, ko.bindingHandlers.droppable);
+      if (value.data) {
+        if (value.options && droppable.options) {
+          ko.utils.extend(droppable.options, value.options);
+          delete value.options;
+        }
+        ko.utils.extend(droppable, value);
+      } else {
+        droppable.data = value;
+      }
+
+      dropActual = droppable.options.drop;
+
+      $element.droppable(ko.utils.extend(droppable.options, {
+        drop: function(event, ui) {
+
+          var el = ui.draggable[0],
+            item = dataGet(el, ITEMKEY) || dataGet(el, DRAGKEY);
+
+          if (item) {
+
+            if (item.clone) {
+              item = item.clone();
+            }
+
+            if (droppable.dragged) {
+              item = droppable.dragged.call(this, item, event, ui) || item;
+            }
+
+            if (droppable.data) {
+              droppable.data(item);
+            }
+
+          }
+
+          if (dropActual) {
+            dropActual.apply(this, arguments);
+          }
+
+        }
+      }));
+
+      //handle enabling/disabling
+      if (droppable.isEnabled !== undefined) {
+        ko.computed({
+          read: function() {
+            $element.droppable(ko.utils.unwrapObservable(droppable.isEnabled) ? "enable" : "disable");
+          },
+          disposeWhenNodeIsRemoved: element
+        });
+      }
+
+    },
+    update: function(element, valueAccessor, allBindingsAccessor, data, context) {
+
+    },
+    targetIndex: null,
+    afterMove: null,
+    beforeMove: null,
+    options: {}
+  };
+});

data/vendor/assets/mosaico-0.16.0/mosaico/src/js/bindings/eventable.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var ko = require("knockout");
+var $ = require("jquery");
+var console = require("console");
+
+/* utility for togetherjs */
+ko.bindingHandlers.focusable = {
+  'focus': function() {},
+  'blur': function() {},
+  'init': function(element) {
+    ko.utils.domNodeDisposal.addDisposeCallback(element, function() {
+      $(element).off("focusin", ko.bindingHandlers.focusable.focus);
+      $(element).off("focusout", ko.bindingHandlers.focusable.blur);
+    });
+
+    $(element).on("focusin", ko.bindingHandlers.focusable.focus);
+    $(element).on("focusout", ko.bindingHandlers.focusable.blur);
+
+  }
+};
+
+ko.bindingHandlers.scrollable = {
+  'scroll': function() {},
+  'init': function(element) {
+    ko.utils.domNodeDisposal.addDisposeCallback(element, function() {
+      $(element).off("scroll", ko.bindingHandlers.scrollable.scroll);
+    });
+
+    $(element).on("scroll", ko.bindingHandlers.scrollable.scroll);
+
+  }
+};

data/vendor/assets/mosaico-0.16.0/mosaico/src/js/bindings/extender-pagination.js

@@ -0,0 +1,60 @@
+"use strict";
+
+var ko = require("knockout");
+
+ko.extenders.paging = function(target, pageSize) {
+  var _pageSize = ko.observable(pageSize || 10),
+    // default pageSize to 10
+    _currentPage = ko.observable(1); // default current page to 1
+  target.pageSize = ko.computed({
+    read: _pageSize,
+    write: function(newValue) {
+      if (newValue > 0) {
+        _pageSize(newValue);
+      } else {
+        _pageSize(10);
+      }
+    }
+  });
+
+  target.currentPage = ko.computed({
+    read: _currentPage,
+    write: function(newValue) {
+      if (newValue > target.pageCount()) {
+        _currentPage(target.pageCount());
+      } else if (newValue <= 0) {
+        _currentPage(1);
+      } else {
+        _currentPage(newValue);
+      }
+    }
+  });
+
+  target.pageCount = ko.computed(function() {
+    return Math.ceil(target().length / target.pageSize()) || 1;
+  });
+
+  target.currentPageData = ko.computed(function() {
+    var pageSize = _pageSize(),
+      pageIndex = _currentPage(),
+      startIndex = pageSize * (pageIndex - 1),
+      endIndex = pageSize * pageIndex;
+
+    return target().slice(startIndex, endIndex);
+  });
+
+  target.moveFirst = function() {
+    target.currentPage(1);
+  };
+  target.movePrevious = function() {
+    target.currentPage(target.currentPage() - 1);
+  };
+  target.moveNext = function() {
+    target.currentPage(target.currentPage() + 1);
+  };
+  target.moveLast = function() {
+    target.currentPage(target.pageCount());
+  };
+
+  return target;
+};

data/vendor/assets/mosaico-0.16.0/mosaico/src/js/bindings/extsortables.js

@@ -0,0 +1,103 @@
+"use strict";
+/* globals global: true */
+
+var $ = require("jquery");
+var ko = require("knockout");
+var sortable = require("jquery-ui/sortable");
+var draggable = require("jquery-ui/draggable");
+var console = require("console");
+require("knockout-sortable");
+
+if (typeof sortable == 'undefined') throw "Cannot find jquery-ui sortable widget dependency!";
+if (typeof draggable == 'undefined') throw "Cannot find jquery-ui sortable widget dependency!";
+
+var isDraggingHelper = function(writable, e) {
+  if (writable()) {
+    if (e.type == writable() + 'stop') writable(false);
+  } else {
+    if (e.type == 'dragstart' || e.type == 'sortstart') writable(e.type.substring(0, 4));
+  }
+};
+
+var makeExtendedValueAccessor = function(valueAccessor) {
+  return function() {
+    var modelValue = valueAccessor(),
+      unwrappedValue = ko.utils.peekObservable(modelValue); // Unwrap without setting a dependency here
+
+    ko.utils.unwrapObservable(modelValue);
+
+    if (modelValue.options == 'undefined') {
+      modelValue.options = {};
+    }
+
+    var origStart = modelValue.options.start;
+    modelValue.options.start = function(e, ui) {
+      if (typeof modelValue.dragging != 'undefined' && ko.isWritableObservable(modelValue.dragging)) isDraggingHelper(modelValue.dragging, e);
+      if (typeof modelValue.dropContainer != 'undefined') {
+        modelValue.scrollInterval = global.setInterval(function() {
+          var foo = $(modelValue.dropContainer).scrollTop();
+          $(modelValue.dropContainer).scrollTop(foo + modelValue.adding);
+        }, 20);
+      }
+      if (typeof origStart != 'undefined') return origStart(e, ui);
+    };
+    var origStop = modelValue.options.stop;
+    modelValue.options.stop = function(e, ui) {
+      if (typeof modelValue.dragging != 'undefined' && ko.isWritableObservable(modelValue.dragging)) isDraggingHelper(modelValue.dragging, e);
+      if (typeof modelValue.dropContainer != 'undefined') {
+        global.clearInterval(modelValue.scrollInterval);
+      }
+      if (typeof origStop != 'undefined') return origStop(e, ui);
+    };
+    var origDrag = modelValue.options.drag;
+    modelValue.options.drag = function(e, ui) {
+      if (typeof modelValue.dropContainer != 'undefined') {
+        var top = e.pageY - $(modelValue.dropContainer).offset().top;
+        var bottom = top - $(modelValue.dropContainer).height();
+        // Handle scrolling speed depending on distance from border.
+        if (top < -20) {
+          modelValue.adding = -20;
+          // console.log("<<<");
+        } else if (top < 0) {
+          modelValue.adding = -10;
+          // console.log("<<");
+        } else if (top < 10) {
+          modelValue.adding = -5;
+          // console.log("<");
+        } else if (bottom > 20) {
+          modelValue.adding = 20;
+          // console.log(">>>");
+        } else if (bottom > 0) {
+          modelValue.adding = 10;
+          // console.log(">>");
+        } else if (bottom > -10) {
+          modelValue.adding = 5;
+          // console.log(">");
+        } else {
+          modelValue.adding = 0;
+        }
+      }
+      if (typeof origDrag != 'undefined') return origDrag(e, ui);
+    };
+
+    return modelValue;
+  };
+};
+
+ko.bindingHandlers.extsortable = {
+  init: function(element, valueAccessor, allBindingsAccessor, data, context) {
+    return ko.bindingHandlers.sortable.init(element, makeExtendedValueAccessor(valueAccessor), allBindingsAccessor, data, context);
+  },
+  update: function(element, valueAccessor, allBindingsAccessor, data, context) {
+    return ko.bindingHandlers.sortable.update(element, makeExtendedValueAccessor(valueAccessor), allBindingsAccessor, data, context);
+  }
+};
+
+ko.bindingHandlers.extdraggable = {
+  init: function(element, valueAccessor, allBindingsAccessor, data, context) {
+    return ko.bindingHandlers.draggable.init(element, makeExtendedValueAccessor(valueAccessor), allBindingsAccessor, data, context);
+  },
+  update: function(element, valueAccessor, allBindingsAccessor, data, context) {
+    return ko.bindingHandlers.draggable.update(element, makeExtendedValueAccessor(valueAccessor), allBindingsAccessor, data, context);
+  }
+};

data/vendor/assets/mosaico-0.16.0/mosaico/src/js/bindings/fileupload.js

@@ -0,0 +1,373 @@
+"use strict";
+/* global global: false, Image: false */
+
+// This module depends on those files, but it doesn't have a direct dependency, so we don't require them here.
+
+//require("blueimp-canvas-to-blob");
+//require("jquery-file-upload/js/jquery.iframe-transport.js");
+//require("jquery-file-upload/js/jquery.fileupload.js");
+//require("jquery-file-upload/js/jquery.fileupload-process.js");
+//require("jquery-file-upload/js/jquery.fileupload-image.js");
+//require("jquery-file-upload/js/jquery.fileupload-validate.js");
+
+var $ = require("jquery");
+var ko = require("knockout");
+var console = require("console");
+
+// experimental image preloading.
+ko.bindingHandlers['preloader'] = {
+  init: function(element, valueAccessor) {
+    var value = valueAccessor();
+    if (typeof value.preloaded == 'undefined') {
+      value.preloaded = ko.observable("");
+
+      var preloader = function(newValue) {
+        if (newValue != value.preloaded()) {
+          if (newValue !== '') {
+            var img = new Image();
+            img.onload = function() {
+              value.preloaded(newValue);
+            };
+            img.onerror = function() {
+              value.preloaded(newValue);
+            };
+            img.src = newValue;
+          } else {
+            value.preloaded(newValue);
+          }
+        }
+      };
+
+      value.subscribe(preloader);
+      preloader(value());
+    }
+  }
+};
+
+// TODO we don't use advattr and advstyle, maybe we should simply remove this code.
+ko.bindingHandlers['advattr'] = {
+  'init': function(element, valueAccessor, allBindings, viewModel, bindingContext) {
+    var value = ko.utils.unwrapObservable(valueAccessor() || {});
+    ko.utils.objectForEach(value, function(attrName, attrValueAccessor) {
+      var attrValue = element.getAttribute(attrName);
+
+      if (ko.isWriteableObservable(attrValueAccessor)) {
+        var oldValue = attrValueAccessor();
+        if (oldValue != attrValue) {
+          attrValueAccessor(attrValue);
+          if (oldValue !== null) {
+            console.log("AdvAttr found a value different from the default", attrName, oldValue, attrValue);
+          }
+        }
+      }
+    });
+  },
+  'update': function(element, valueAccessor, allBindings) {
+    var value = ko.utils.unwrapObservable(valueAccessor()) || {};
+    ko.utils.objectForEach(value, function(attrName, attrValue) {
+      attrValue = ko.utils.unwrapObservable(attrValue);
+      // To cover cases like "attr: { checked:someProp }", we want to remove the attribute entirely
+      // when someProp is a "no value"-like value (strictly null, false, or undefined)
+      // (because the absence of the "checked" attr is how to mark an element as not checked, etc.)
+      var toRemove = (attrValue === false) || (attrValue === null) || (attrValue === undefined);
+      if (toRemove) element.removeAttribute(attrName);
+      else element.setAttribute(attrName, attrValue.toString());
+    });
+  }
+};
+ko.bindingHandlers['advstyle'] = {
+  'init': function(element, valueAccessor, allBindings, viewModel, bindingContext) {
+    var value = ko.utils.unwrapObservable(valueAccessor() || {});
+    ko.utils.objectForEach(value, function(styleName, styleValueAccessor) {
+      var styleValue;
+      if (styleName.match(/Px$/)) {
+        styleName = styleName.substr(0, styleName.length - 2);
+        styleValue = element.style[styleName];
+        if (styleValue.match(/px$/)) {
+          styleValue = styleValue.replace(/px$/, '');
+        } else {
+          console.log("AdvStyle binding found an unexpected default value", styleName, styleValue, element);
+        }
+      } else {
+        styleValue = element.style[styleName];
+      }
+
+      if (ko.isWriteableObservable(styleValueAccessor)) {
+        var oldValue = styleValueAccessor();
+        if (oldValue != styleValue) {
+          styleValueAccessor(styleValue);
+          if (oldValue !== null) {
+            console.log("AdvStyle found a value different from the default", styleName, oldValue, styleValue);
+          }
+        }
+      }
+    });
+  },
+  'update': function(element, valueAccessor) {
+    var value = ko.utils.unwrapObservable(valueAccessor() || {});
+    ko.utils.objectForEach(value, function(styleName, styleValue) {
+      styleValue = ko.utils.unwrapObservable(styleValue);
+
+      if (styleValue === null || typeof styleValue === 'undefined' || styleValue === false) {
+        styleValue = "";
+      }
+
+      if (styleName.match(/Px$/)) {
+        styleName = styleName.substr(0, styleName.length - 2);
+        styleValue = styleValue + "px";
+      }
+
+      element.style[styleName] = styleValue;
+    });
+  }
+};
+
+// Utility to log inizialization and disposal of DOM elements.
+ko.bindingHandlers['domlog'] = {
+  init: function(element, valueAccessor) {
+    console.log("initialized", element);
+    ko.utils.domNodeDisposal.addDisposeCallback(element, function() {
+      console.log("disposed", element);
+    });
+  }
+};
+
+ko.bindingHandlers['fudroppable'] = {
+  init: function(element, valueAccessor) {
+    var opt = valueAccessor() || {};
+    var timeoutsObj = {};
+
+    var over = function(timeouts, dropZoneTimeout, element, className, observable, event) {
+
+      if (!timeouts[dropZoneTimeout]) {
+        if (typeof className !== 'undefined') {
+          element.classList.add(className);
+        }
+        if (ko.isWriteableObservable(observable) && !observable()) {
+          observable(true);
+        }
+      } else {
+        global.clearTimeout(timeouts[dropZoneTimeout]);
+      }
+
+      var stop = function() {
+        timeouts[dropZoneTimeout] = null;
+        if (typeof className !== 'undefined') {
+          element.classList.remove(className);
+        }
+        if (ko.isWriteableObservable(observable) && observable()) {
+          observable(false);
+        }
+      };
+
+      if (event.type == 'dragleave') stop();
+      else {
+        // Using 100 it doens't work fine on Linux (chome/firefox), using 200 still shows issues on slow Linux boxes
+        timeouts[dropZoneTimeout] = global.setTimeout(stop, 500);
+      }
+
+    };
+
+    if (opt.active || opt.activeClass) {
+      ko.utils.registerEventHandler(global, 'dragover', over.bind(undefined, timeoutsObj, 'activeTimeout', element, opt.activeClass, opt.active));
+    }
+    if (opt.hoverClass) {
+      // dragenter and dragleave are not required but they speedup feedback when used.
+      ko.utils.registerEventHandler(element, 'dragover dragenter dragleave', over.bind(undefined, timeoutsObj, 'hoverTimeout', element, opt.hoverClass, undefined));
+    }
+  }
+};
+
+ko.bindingHandlers['fileupload'] = {
+  extendOptions: {},
+  remoteFilePreprocessor: function(url) { return url; },
+  init: function(element, valueAccessor) {
+    // TODO domnodedisposal doesn't work when the upload is done by "clicking"
+    // Probably jquery-fileupload moves the DOM somewhere else so that KO doesn't 
+    // detect the removal anymore.
+    ko.utils.domNodeDisposal.addDisposeCallback(element, function() {
+      $(element).fileupload('destroy');
+    });
+
+    // if we leave the title the native control will show us a tooltip we don't want.
+    // In WebKit the right way to remove it is leaving a "whitespace".
+    // In Gecko we have to set it empty.
+    if (global.webkitURL)
+      $(element).attr('title', ' ');
+    else
+      $(element).attr('title', '');
+  },
+
+  update: function(element, valueAccessor) {
+    var options = valueAccessor() || {};
+
+    var $fu = $(element);
+    var $parent = $fu.parents('.uploadzone');
+
+    var dataValue = options.data;
+    options.data = undefined;
+
+    var canvasPreview = options.canvasPreview;
+
+    // TODO remove hardcoded url
+    ko.utils.extend(options, {
+      url: '/upload/',
+      dataType: 'json',
+      dropZone: $parent.find('.mo-uploadzone')[0],
+      autoUpload: true,
+      acceptFileTypes: /(\.|\/)(gif|jpe?g|png)$/i,
+      maxFileSize: 1024 * 1024,
+      // Enable image resizing, except for Android and Opera,
+      // which actually support image resizing, but fail to
+      // send Blob objects via XHR requests:
+      disableImageResize: /Android(?!.*Chrome)|Opera/.test(global.navigator.userAgent),
+      previewMaxWidth: 200,
+      previewMaxHeight: 200,
+      previewCrop: false,
+      replaceFileInput: false, // replaceFileInput true breaks after uploading using "input" (using mouse clic instead of dropping)
+
+      messages: {
+        // client side
+        unknownError: 'Unknown error',
+        uploadedBytes: 'Uploaded bytes exceed file size',
+        maxNumberOfFiles: 'Maximum number of files exceeded',
+        acceptFileTypes: 'File type not allowed',
+        maxFileSize: 'File is too large',
+        minFileSize: 'File is too small',
+        // server side
+        post_max_size: 'The uploaded file exceeds the post_max_size directive in php.ini',
+        max_file_size: 'File is too big',
+        min_file_size: 'File is too small',
+        accept_file_types: 'Filetype not allowed',
+        max_number_of_files: 'Maximum number of files exceeded',
+        max_width: 'Image exceeds maximum width',
+        min_width: 'Image requires a minimum width',
+        max_height: 'Image exceeds maximum height',
+        min_height: 'Image requires a minimum height',
+        abort: 'File upload aborted',
+        image_resize: 'Failed to resize image',
+        generic: 'Unexpected upload error'
+      }
+    });
+
+    ko.utils.extend(options, ko.bindingHandlers['fileupload'].extendOptions);
+
+    var working = 0;
+    var firstWorked = '';
+
+    var cleanup = function() {
+      if (--working === 0) {
+        if (dataValue) {
+          dataValue(firstWorked);
+        }
+        firstWorked = '';
+        if (canvasPreview) {
+          $parent.find('img').show();
+          $parent.find('canvas').remove();
+        }
+        $parent.removeClass("uploading");
+        $parent.find('.progress-bar').css('width', 0);
+      }
+    };
+
+    var translatedMessage = function(text) {
+      if (typeof options.messages == 'object' && options.messages !== null) {
+        var match = text.match(/^([^ ]+)(.*)$/);
+        if (match) {
+          if (typeof options.messages[match[1]] !== 'undefined') {
+            return options.messages[match[1]] + match[2];
+          }
+        }
+      }
+      return text;
+    };
+
+    $fu.fileupload(options);
+
+    var events = ['fileuploadadd', 'fileuploadprocessalways', 'fileuploadprogressall', 'fileuploaddone', 'fileuploadfail'];
+    var eventHandler = function(e, data) {
+      if (e.type == 'fileuploadadd') {
+        working++;
+      }
+      if (e.type == 'fileuploadfail') {
+        console.log("fileuploadfail", e, data);
+        if (options.onerror) {
+          if (data.errorThrown === '' && data.textStatus == 'error') {
+            options.onerror(translatedMessage('generic'));
+          } else {
+            options.onerror(translatedMessage('generic (' + data.errorThrown + ')'));
+          }
+        }
+        cleanup();
+      }
+      if (e.type == 'fileuploaddone') {
+        if (typeof data.result.files[0].url !== 'undefined') {
+          if (options.onfile) {
+            for (var i = 0; i < data.result.files.length; i++) {
+              data.result.files[i] = ko.bindingHandlers['fileupload'].remoteFilePreprocessor(data.result.files[i]);
+              options.onfile(data.result.files[i]);
+            }
+          }
+
+          if (firstWorked === '') firstWorked = data.result.files[0].url;
+
+          if (canvasPreview) {
+            var img = new Image();
+            img.onload = cleanup;
+            img.onerror = cleanup;
+            img.src = data.result.files[0].url;
+          } else {
+            cleanup();
+          }
+        } else if (typeof data.result.files[0].error !== 'undefined') {
+          console.log("remote error", e, data);
+          if (options.onerror) {
+            options.onerror(translatedMessage(data.result.files[0].error));
+          }
+          cleanup();
+        } else {
+          console.log("unexpected error", e, data);
+          if (options.onerror) {
+            options.onerror(translatedMessage('generic (Unexpected Error retrieving uploaded file)'));
+          }
+          cleanup();
+        }
+      }
+      if (e.type == 'fileuploadprocessalways') {
+        var index = data.index,
+          file = data.files[index];
+        if (file.preview && index === 0) {
+          // if we have a canvas we had multiple uploaded files
+          if ($parent.find('canvas').length === 0) {
+            if (canvasPreview) {
+              var el = $(file.preview).css('width', '100%'); // .css('position', 'absolute').css('left', '0');
+              $parent.find('img').hide();
+              $parent.prepend(el);
+            }
+            $parent.addClass("uploading");
+            $parent.find('.progress-bar').css('width', 0);
+          }
+        }
+        if (file.error) {
+          // File type not allowed
+          // File is too large
+          if (options.onerror) {
+            options.onerror(translatedMessage(file.error));
+          }
+          cleanup();
+        }
+      }
+      if (e.type == 'fileuploadprogressall') {
+        var progress = parseInt(data.loaded / data.total * 100, 10);
+        $parent.find('.progress-bar').css('width', progress + '%');
+      }
+    };
+    for (var i = events.length - 1; i >= 0; i--) {
+      var eventName = events[i];
+      $fu.on(eventName, eventHandler);
+    }
+    if (!$.support.fileInput) {
+      $fu.prop('disabled', true).parent().addClass('disabled');
+    }
+  }
+};