");
+ fabric.window = fabric.document.createWindow();
+}
+
+/**
+ * True when in environment that supports touch events
+ * @property isTouchSupported
+ * @type boolean
+ */
+fabric.isTouchSupported = "ontouchstart" in fabric.document.documentElement;
+
+/**
+ * True when in environment that's probably Node.js
+ * @property isLikelyNode
+ * @type boolean
+ */
+fabric.isLikelyNode = typeof Buffer !== 'undefined' && typeof window === 'undefined';
+/*!
+ * Copyright (c) 2009 Simo Kinnunen.
+ * Licensed under the MIT license.
+ */
+
+var Cufon = (function() {
+
+ /** @ignore */
+ var api = function() {
+ return api.replace.apply(null, arguments);
+ };
+
+ /** @ignore */
+ var DOM = api.DOM = {
+
+ ready: (function() {
+
+ var complete = false, readyStatus = { loaded: 1, complete: 1 };
+
+ var queue = [], /** @ignore */ perform = function() {
+ if (complete) return;
+ complete = true;
+ for (var fn; fn = queue.shift(); fn());
+ };
+
+ // Gecko, Opera, WebKit r26101+
+
+ if (fabric.document.addEventListener) {
+ fabric.document.addEventListener('DOMContentLoaded', perform, false);
+ fabric.window.addEventListener('pageshow', perform, false); // For cached Gecko pages
+ }
+
+ // Old WebKit, Internet Explorer
+
+ if (!fabric.window.opera && fabric.document.readyState) (function() {
+ readyStatus[fabric.document.readyState] ? perform() : setTimeout(arguments.callee, 10);
+ })();
+
+ // Internet Explorer
+
+ if (fabric.document.readyState && fabric.document.createStyleSheet) (function() {
+ try {
+ fabric.document.body.doScroll('left');
+ perform();
+ }
+ catch (e) {
+ setTimeout(arguments.callee, 1);
+ }
+ })();
+
+ addEvent(fabric.window, 'load', perform); // Fallback
+
+ return function(listener) {
+ if (!arguments.length) perform();
+ else complete ? listener() : queue.push(listener);
+ };
+
+ })()
+
+ };
+
+ /** @ignore */
+ var CSS = api.CSS = /** @ignore */ {
+
+ /** @ignore */
+ Size: function(value, base) {
+
+ this.value = parseFloat(value);
+ this.unit = String(value).match(/[a-z%]*$/)[0] || 'px';
+
+ /** @ignore */
+ this.convert = function(value) {
+ return value / base * this.value;
+ };
+
+ /** @ignore */
+ this.convertFrom = function(value) {
+ return value / this.value * base;
+ };
+
+ /** @ignore */
+ this.toString = function() {
+ return this.value + this.unit;
+ };
+
+ },
+
+ /** @ignore */
+ getStyle: function(el) {
+ return new Style(el.style);
+ /*
+ var view = document.defaultView;
+ if (view && view.getComputedStyle) return new Style(view.getComputedStyle(el, null));
+ if (el.currentStyle) return new Style(el.currentStyle);
+ return new Style(el.style);
+ */
+ },
+
+ quotedList: cached(function(value) {
+ // doesn't work properly with empty quoted strings (""), but
+ // it's not worth the extra code.
+ var list = [], re = /\s*((["'])([\s\S]*?[^\\])\2|[^,]+)\s*/g, match;
+ while (match = re.exec(value)) list.push(match[3] || match[1]);
+ return list;
+ }),
+
+ ready: (function() {
+
+ var complete = false;
+
+ var queue = [], perform = function() {
+ complete = true;
+ for (var fn; fn = queue.shift(); fn());
+ };
+
+ // Safari 2 does not include ');
+
+ function getFontSizeInPixels(el, value) {
+ return getSizeInPixels(el, /(?:em|ex|%)$/i.test(value) ? '1em' : value);
+ }
+
+ // Original by Dead Edwards.
+ // Combined with getFontSizeInPixels it also works with relative units.
+ function getSizeInPixels(el, value) {
+ if (/px$/i.test(value)) return parseFloat(value);
+ var style = el.style.left, runtimeStyle = el.runtimeStyle.left;
+ el.runtimeStyle.left = el.currentStyle.left;
+ el.style.left = value;
+ var result = el.style.pixelLeft;
+ el.style.left = style;
+ el.runtimeStyle.left = runtimeStyle;
+ return result;
+ }
+
+ return function(font, text, style, options, node, el, hasNext) {
+ var redraw = (text === null);
+
+ if (redraw) text = node.alt;
+
+ // @todo word-spacing, text-decoration
+
+ var viewBox = font.viewBox;
+
+ var size = style.computedFontSize ||
+ (style.computedFontSize = new Cufon.CSS.Size(getFontSizeInPixels(el, style.get('fontSize')) + 'px', font.baseSize));
+
+ var letterSpacing = style.computedLSpacing;
+
+ if (letterSpacing == undefined) {
+ letterSpacing = style.get('letterSpacing');
+ style.computedLSpacing = letterSpacing =
+ (letterSpacing == 'normal') ? 0 : ~~size.convertFrom(getSizeInPixels(el, letterSpacing));
+ }
+
+ var wrapper, canvas;
+
+ if (redraw) {
+ wrapper = node;
+ canvas = node.firstChild;
+ }
+ else {
+ wrapper = fabric.document.createElement('span');
+ wrapper.className = 'cufon cufon-vml';
+ wrapper.alt = text;
+
+ canvas = fabric.document.createElement('span');
+ canvas.className = 'cufon-vml-canvas';
+ wrapper.appendChild(canvas);
+
+ if (options.printable) {
+ var print = fabric.document.createElement('span');
+ print.className = 'cufon-alt';
+ print.appendChild(fabric.document.createTextNode(text));
+ wrapper.appendChild(print);
+ }
+
+ // ie6, for some reason, has trouble rendering the last VML element in the document.
+ // we can work around this by injecting a dummy element where needed.
+ // @todo find a better solution
+ if (!hasNext) wrapper.appendChild(fabric.document.createElement('cvml:shape'));
+ }
+
+ var wStyle = wrapper.style;
+ var cStyle = canvas.style;
+
+ var height = size.convert(viewBox.height), roundedHeight = Math.ceil(height);
+ var roundingFactor = roundedHeight / height;
+ var minX = viewBox.minX, minY = viewBox.minY;
+
+ cStyle.height = roundedHeight;
+ cStyle.top = Math.round(size.convert(minY - font.ascent));
+ cStyle.left = Math.round(size.convert(minX));
+
+ wStyle.height = size.convert(font.height) + 'px';
+
+ var textDecoration = Cufon.getTextDecoration(options);
+
+ var color = style.get('color');
+
+ var chars = Cufon.CSS.textTransform(text, style).split('');
+
+ var width = 0, offsetX = 0, advance = null;
+
+ var glyph, shape, shadows = options.textShadow;
+
+ // pre-calculate width
+ for (var i = 0, k = 0, l = chars.length; i < l; ++i) {
+ glyph = font.glyphs[chars[i]] || font.missingGlyph;
+ if (glyph) width += advance = ~~(glyph.w || font.w) + letterSpacing;
+ }
+
+ if (advance === null) return null;
+
+ var fullWidth = -minX + width + (viewBox.width - advance);
+
+ var shapeWidth = size.convert(fullWidth * roundingFactor), roundedShapeWidth = Math.round(shapeWidth);
+
+ var coordSize = fullWidth + ',' + viewBox.height, coordOrigin;
+ var stretch = 'r' + coordSize + 'nsnf';
+
+ for (i = 0; i < l; ++i) {
+
+ glyph = font.glyphs[chars[i]] || font.missingGlyph;
+ if (!glyph) continue;
+
+ if (redraw) {
+ // some glyphs may be missing so we can't use i
+ shape = canvas.childNodes[k];
+ if (shape.firstChild) shape.removeChild(shape.firstChild); // shadow
+ }
+ else {
+ shape = fabric.document.createElement('cvml:shape');
+ canvas.appendChild(shape);
+ }
+
+ shape.stroked = 'f';
+ shape.coordsize = coordSize;
+ shape.coordorigin = coordOrigin = (minX - offsetX) + ',' + minY;
+ shape.path = (glyph.d ? 'm' + glyph.d + 'xe' : '') + 'm' + coordOrigin + stretch;
+ shape.fillcolor = color;
+
+ // it's important to not set top/left or IE8 will grind to a halt
+ var sStyle = shape.style;
+ sStyle.width = roundedShapeWidth;
+ sStyle.height = roundedHeight;
+
+ if (shadows) {
+ // due to the limitations of the VML shadow element there
+ // can only be two visible shadows. opacity is shared
+ // for all shadows.
+ var shadow1 = shadows[0], shadow2 = shadows[1];
+ var color1 = Cufon.CSS.color(shadow1.color), color2;
+ var shadow = fabric.document.createElement('cvml:shadow');
+ shadow.on = 't';
+ shadow.color = color1.color;
+ shadow.offset = shadow1.offX + ',' + shadow1.offY;
+ if (shadow2) {
+ color2 = Cufon.CSS.color(shadow2.color);
+ shadow.type = 'double';
+ shadow.color2 = color2.color;
+ shadow.offset2 = shadow2.offX + ',' + shadow2.offY;
+ }
+ shadow.opacity = color1.opacity || (color2 && color2.opacity) || 1;
+ shape.appendChild(shadow);
+ }
+
+ offsetX += ~~(glyph.w || font.w) + letterSpacing;
+
+ ++k;
+
+ }
+
+ wStyle.width = Math.max(Math.ceil(size.convert(width * roundingFactor)), 0);
+
+ return wrapper;
+
+ };
+
+})());
+
+Cufon.getTextDecoration = function(options) {
+ return {
+ underline: options.textDecoration === 'underline',
+ overline: options.textDecoration === 'overline',
+ 'line-through': options.textDecoration === 'line-through'
+ };
+};
+
+if (typeof exports != 'undefined') {
+ exports.Cufon = Cufon;
+}
+
+/*
+ json2.js
+ 2011-10-19
+
+ Public Domain.
+
+ NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
+
+ See http://www.JSON.org/js.html
+
+
+ This code should be minified before deployment.
+ See http://javascript.crockford.com/jsmin.html
+
+ USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO
+ NOT CONTROL.
+
+
+ This file creates a global JSON object containing two methods: stringify
+ and parse.
+
+ JSON.stringify(value, replacer, space)
+ value any JavaScript value, usually an object or array.
+
+ replacer an optional parameter that determines how object
+ values are stringified for objects. It can be a
+ function or an array of strings.
+
+ space an optional parameter that specifies the indentation
+ of nested structures. If it is omitted, the text will
+ be packed without extra whitespace. If it is a number,
+ it will specify the number of spaces to indent at each
+ level. If it is a string (such as '\t' or ' '),
+ it contains the characters used to indent at each level.
+
+ This method produces a JSON text from a JavaScript value.
+
+ When an object value is found, if the object contains a toJSON
+ method, its toJSON method will be called and the result will be
+ stringified. A toJSON method does not serialize: it returns the
+ value represented by the name/value pair that should be serialized,
+ or undefined if nothing should be serialized. The toJSON method
+ will be passed the key associated with the value, and this will be
+ bound to the value
+
+ For example, this would serialize Dates as ISO strings.
+
+ Date.prototype.toJSON = function (key) {
+ function f(n) {
+ // Format integers to have at least two digits.
+ return n < 10 ? '0' + n : n;
+ }
+
+ return this.getUTCFullYear() + '-' +
+ f(this.getUTCMonth() + 1) + '-' +
+ f(this.getUTCDate()) + 'T' +
+ f(this.getUTCHours()) + ':' +
+ f(this.getUTCMinutes()) + ':' +
+ f(this.getUTCSeconds()) + 'Z';
+ };
+
+ You can provide an optional replacer method. It will be passed the
+ key and value of each member, with this bound to the containing
+ object. The value that is returned from your method will be
+ serialized. If your method returns undefined, then the member will
+ be excluded from the serialization.
+
+ If the replacer parameter is an array of strings, then it will be
+ used to select the members to be serialized. It filters the results
+ such that only members with keys listed in the replacer array are
+ stringified.
+
+ Values that do not have JSON representations, such as undefined or
+ functions, will not be serialized. Such values in objects will be
+ dropped; in arrays they will be replaced with null. You can use
+ a replacer function to replace those with JSON values.
+ JSON.stringify(undefined) returns undefined.
+
+ The optional space parameter produces a stringification of the
+ value that is filled with line breaks and indentation to make it
+ easier to read.
+
+ If the space parameter is a non-empty string, then that string will
+ be used for indentation. If the space parameter is a number, then
+ the indentation will be that many spaces.
+
+ Example:
+
+ text = JSON.stringify(['e', {pluribus: 'unum'}]);
+ // text is '["e",{"pluribus":"unum"}]'
+
+
+ text = JSON.stringify(['e', {pluribus: 'unum'}], null, '\t');
+ // text is '[\n\t"e",\n\t{\n\t\t"pluribus": "unum"\n\t}\n]'
+
+ text = JSON.stringify([new Date()], function (key, value) {
+ return this[key] instanceof Date ?
+ 'Date(' + this[key] + ')' : value;
+ });
+ // text is '["Date(---current time---)"]'
+
+
+ JSON.parse(text, reviver)
+ This method parses a JSON text to produce an object or array.
+ It can throw a SyntaxError exception.
+
+ The optional reviver parameter is a function that can filter and
+ transform the results. It receives each of the keys and values,
+ and its return value is used instead of the original value.
+ If it returns what it received, then the structure is not modified.
+ If it returns undefined then the member is deleted.
+
+ Example:
+
+ // Parse the text. Values that look like ISO date strings will
+ // be converted to Date objects.
+
+ myData = JSON.parse(text, function (key, value) {
+ var a;
+ if (typeof value === 'string') {
+ a =
+/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
+ if (a) {
+ return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4],
+ +a[5], +a[6]));
+ }
+ }
+ return value;
+ });
+
+ myData = JSON.parse('["Date(09/09/2001)"]', function (key, value) {
+ var d;
+ if (typeof value === 'string' &&
+ value.slice(0, 5) === 'Date(' &&
+ value.slice(-1) === ')') {
+ d = new Date(value.slice(5, -1));
+ if (d) {
+ return d;
+ }
+ }
+ return value;
+ });
+
+
+ This is a reference implementation. You are free to copy, modify, or
+ redistribute.
+*/
+
+/*jslint evil: true, regexp: true */
+
+/*members "", "\b", "\t", "\n", "\f", "\r", "\"", JSON, "\\", apply,
+ call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours,
+ getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join,
+ lastIndex, length, parse, prototype, push, replace, slice, stringify,
+ test, toJSON, toString, valueOf
+*/
+
+
+// Create a JSON object only if one does not already exist. We create the
+// methods in a closure to avoid creating global variables.
+
+var JSON;
+if (!JSON) {
+ JSON = {};
+}
+
+(function () {
+ 'use strict';
+
+ function f(n) {
+ // Format integers to have at least two digits.
+ return n < 10 ? '0' + n : n;
+ }
+
+ if (typeof Date.prototype.toJSON !== 'function') {
+
+ /** @ignore */
+ Date.prototype.toJSON = function (key) {
+
+ return isFinite(this.valueOf())
+ ? this.getUTCFullYear() + '-' +
+ f(this.getUTCMonth() + 1) + '-' +
+ f(this.getUTCDate()) + 'T' +
+ f(this.getUTCHours()) + ':' +
+ f(this.getUTCMinutes()) + ':' +
+ f(this.getUTCSeconds()) + 'Z'
+ : null;
+ };
+
+ String.prototype.toJSON =
+ Number.prototype.toJSON =
+ /** @ignore */
+ Boolean.prototype.toJSON = function (key) {
+ return this.valueOf();
+ };
+ }
+
+ var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+ escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+ gap,
+ indent,
+ meta = { // table of character substitutions
+ '\b': '\\b',
+ '\t': '\\t',
+ '\n': '\\n',
+ '\f': '\\f',
+ '\r': '\\r',
+ '"' : '\\"',
+ '\\': '\\\\'
+ },
+ rep;
+
+
+ function quote(string) {
+
+// If the string contains no control characters, no quote characters, and no
+// backslash characters, then we can safely slap some quotes around it.
+// Otherwise we must also replace the offending characters with safe escape
+// sequences.
+
+ escapable.lastIndex = 0;
+ return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
+ var c = meta[a];
+ return typeof c === 'string'
+ ? c
+ : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+ }) + '"' : '"' + string + '"';
+ }
+
+
+ function str(key, holder) {
+
+// Produce a string from holder[key].
+
+ var i, // The loop counter.
+ k, // The member key.
+ v, // The member value.
+ length,
+ mind = gap,
+ partial,
+ value = holder[key];
+
+// If the value has a toJSON method, call it to obtain a replacement value.
+
+ if (value && typeof value === 'object' &&
+ typeof value.toJSON === 'function') {
+ value = value.toJSON(key);
+ }
+
+// If we were called with a replacer function, then call the replacer to
+// obtain a replacement value.
+
+ if (typeof rep === 'function') {
+ value = rep.call(holder, key, value);
+ }
+
+// What happens next depends on the value's type.
+
+ switch (typeof value) {
+ case 'string':
+ return quote(value);
+
+ case 'number':
+
+// JSON numbers must be finite. Encode non-finite numbers as null.
+
+ return isFinite(value) ? String(value) : 'null';
+
+ case 'boolean':
+ case 'null':
+
+// If the value is a boolean or null, convert it to a string. Note:
+// typeof null does not produce 'null'. The case is included here in
+// the remote chance that this gets fixed someday.
+
+ return String(value);
+
+// If the type is 'object', we might be dealing with an object or an array or
+// null.
+
+ case 'object':
+
+// Due to a specification blunder in ECMAScript, typeof null is 'object',
+// so watch out for that case.
+
+ if (!value) {
+ return 'null';
+ }
+
+// Make an array to hold the partial results of stringifying this object value.
+
+ gap += indent;
+ partial = [];
+
+// Is the value an array?
+
+ if (Object.prototype.toString.apply(value) === '[object Array]') {
+
+// The value is an array. Stringify every element. Use null as a placeholder
+// for non-JSON values.
+
+ length = value.length;
+ for (i = 0; i < length; i += 1) {
+ partial[i] = str(i, value) || 'null';
+ }
+
+// Join all of the elements together, separated with commas, and wrap them in
+// brackets.
+
+ v = partial.length === 0
+ ? '[]'
+ : gap
+ ? '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']'
+ : '[' + partial.join(',') + ']';
+ gap = mind;
+ return v;
+ }
+
+// If the replacer is an array, use it to select the members to be stringified.
+
+ if (rep && typeof rep === 'object') {
+ length = rep.length;
+ for (i = 0; i < length; i += 1) {
+ if (typeof rep[i] === 'string') {
+ k = rep[i];
+ v = str(k, value);
+ if (v) {
+ partial.push(quote(k) + (gap ? ': ' : ':') + v);
+ }
+ }
+ }
+ } else {
+
+// Otherwise, iterate through all of the keys in the object.
+
+ for (k in value) {
+ if (Object.prototype.hasOwnProperty.call(value, k)) {
+ v = str(k, value);
+ if (v) {
+ partial.push(quote(k) + (gap ? ': ' : ':') + v);
+ }
+ }
+ }
+ }
+
+// Join all of the member texts together, separated with commas,
+// and wrap them in braces.
+
+ v = partial.length === 0
+ ? '{}'
+ : gap
+ ? '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}'
+ : '{' + partial.join(',') + '}';
+ gap = mind;
+ return v;
+ }
+ }
+
+// If the JSON object does not yet have a stringify method, give it one.
+
+ if (typeof JSON.stringify !== 'function') {
+ /** @ignore */
+ JSON.stringify = function (value, replacer, space) {
+
+// The stringify method takes a value and an optional replacer, and an optional
+// space parameter, and returns a JSON text. The replacer can be a function
+// that can replace values, or an array of strings that will select the keys.
+// A default replacer method can be provided. Use of the space parameter can
+// produce text that is more easily readable.
+
+ var i;
+ gap = '';
+ indent = '';
+
+// If the space parameter is a number, make an indent string containing that
+// many spaces.
+
+ if (typeof space === 'number') {
+ for (i = 0; i < space; i += 1) {
+ indent += ' ';
+ }
+
+// If the space parameter is a string, it will be used as the indent string.
+
+ } else if (typeof space === 'string') {
+ indent = space;
+ }
+
+// If there is a replacer, it must be a function or an array.
+// Otherwise, throw an error.
+
+ rep = replacer;
+ if (replacer && typeof replacer !== 'function' &&
+ (typeof replacer !== 'object' ||
+ typeof replacer.length !== 'number')) {
+ throw new Error('JSON.stringify');
+ }
+
+// Make a fake root object containing our value under the key of ''.
+// Return the result of stringifying the value.
+
+ return str('', {'': value});
+ };
+ }
+
+
+// If the JSON object does not yet have a parse method, give it one.
+
+ if (typeof JSON.parse !== 'function') {
+ /** @ignore */
+ JSON.parse = function (text, reviver) {
+
+// The parse method takes a text and an optional reviver function, and returns
+// a JavaScript value if the text is a valid JSON text.
+
+ var j;
+
+ function walk(holder, key) {
+
+// The walk method is used to recursively walk the resulting structure so
+// that modifications can be made.
+
+ var k, v, value = holder[key];
+ if (value && typeof value === 'object') {
+ for (k in value) {
+ if (Object.prototype.hasOwnProperty.call(value, k)) {
+ v = walk(value, k);
+ if (v !== undefined) {
+ value[k] = v;
+ } else {
+ delete value[k];
+ }
+ }
+ }
+ }
+ return reviver.call(holder, key, value);
+ }
+
+
+// Parsing happens in four stages. In the first stage, we replace certain
+// Unicode characters with escape sequences. JavaScript handles many characters
+// incorrectly, either silently deleting them, or treating them as line endings.
+
+ text = String(text);
+ cx.lastIndex = 0;
+ if (cx.test(text)) {
+ text = text.replace(cx, function (a) {
+ return '\\u' +
+ ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+ });
+ }
+
+// In the second stage, we run the text against regular expressions that look
+// for non-JSON patterns. We are especially concerned with '()' and 'new'
+// because they can cause invocation, and '=' because it can cause mutation.
+// But just to be safe, we want to reject all unexpected forms.
+
+// We split the second stage into 4 regexp operations in order to work around
+// crippling inefficiencies in IE's and Safari's regexp engines. First we
+// replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
+// replace all simple value tokens with ']' characters. Third, we delete all
+// open brackets that follow a colon or comma or that begin the text. Finally,
+// we look to see that the remaining characters are only whitespace or ']' or
+// ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
+
+ if (/^[\],:{}\s]*$/
+ .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
+ .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
+ .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
+
+// In the third stage we use the eval function to compile the text into a
+// JavaScript structure. The '{' operator is subject to a syntactic ambiguity
+// in JavaScript: it can begin a block or an object literal. We wrap the text
+// in parens to eliminate the ambiguity.
+
+ j = eval('(' + text + ')');
+
+// In the optional fourth stage, we recursively walk the new structure, passing
+// each name/value pair to a reviver function for possible transformation.
+
+ return typeof reviver === 'function'
+ ? walk({'': j}, '')
+ : j;
+ }
+
+// If the text is not JSON parseable, then a SyntaxError is thrown.
+
+ throw new SyntaxError('JSON.parse');
+ };
+ }
+}());
+/**
+ * Wrapper around `console.log` (when available)
+ * @method log
+ * @param {Any} values Values to log
+ */
+fabric.log = function() { };
+
+/**
+ * Wrapper around `console.warn` (when available)
+ * @method warn
+ * @param {Any} Values to log as a warning
+ */
+fabric.warn = function() { };
+
+if (typeof console !== 'undefined') {
+ if (typeof console.log !== 'undefined' && console.log.apply) {
+ fabric.log = function() {
+ return console.log.apply(console, arguments);
+ };
+ }
+ if (typeof console.warn !== 'undefined' && console.warn.apply) {
+ fabric.warn = function() {
+ return console.warn.apply(console, arguments);
+ };
+ }
+}
+
+/**
+ * @namespace
+ */
+fabric.Observable = {
+
+ /**
+ * Observes specified event
+ * @method observe
+ * @depracated Since 0.8.34. Use `on` instead.
+ * @param {String} eventName
+ * @param {Function} handler
+ */
+ observe: function(eventName, handler) {
+ if (!this.__eventListeners) {
+ this.__eventListeners = { };
+ }
+ // one object with key/value pairs was passed
+ if (arguments.length === 1) {
+ for (var prop in eventName) {
+ this.on(prop, eventName[prop]);
+ }
+ }
+ else {
+ if (!this.__eventListeners[eventName]) {
+ this.__eventListeners[eventName] = [ ];
+ }
+ this.__eventListeners[eventName].push(handler);
+ }
+ },
+
+ /**
+ * Stops event observing for a particular event handler
+ * @method stopObserving
+ * @depracated Since 0.8.34. Use `off` instead.
+ * @param {String} eventName
+ * @param {Function} handler
+ */
+ stopObserving: function(eventName, handler) {
+ if (!this.__eventListeners) {
+ this.__eventListeners = { };
+ }
+ if (this.__eventListeners[eventName]) {
+ if (handler) {
+ fabric.util.removeFromArray(this.__eventListeners[eventName], handler);
+ }
+ else {
+ this.__eventListeners[eventName].length = 0;
+ }
+ }
+ },
+
+ /**
+ * Fires event with an optional options object
+ * @method fire
+ * @param {String} eventName
+ * @param {Object} [options]
+ */
+ fire: function(eventName, options) {
+ if (!this.__eventListeners) {
+ this.__eventListeners = { };
+ }
+ var listenersForEvent = this.__eventListeners[eventName];
+ if (!listenersForEvent) return;
+ for (var i = 0, len = listenersForEvent.length; i < len; i++) {
+ // avoiding try/catch for perf. reasons
+ listenersForEvent[i](options || { });
+ }
+ }
+};
+
+/**
+ * Alias for observe
+ * @method observe
+ * @type function
+ */
+fabric.Observable.on = fabric.Observable.observe;
+
+/**
+ * Alias for stopObserving
+ * @method off
+ * @type function
+ */
+fabric.Observable.off = fabric.Observable.stopObserving;
+(function() {
+
+ /**
+ * @namespace
+ */
+ fabric.util = { };
+
+ /**
+ * Removes value from an array.
+ * Presence of value (and its position in an array) is determined via `Array.prototype.indexOf`
+ * @static
+ * @memberOf fabric.util
+ * @method removeFromArray
+ * @param {Array} array
+ * @param {Any} value
+ * @return {Array} original array
+ */
+ function removeFromArray(array, value) {
+ var idx = array.indexOf(value);
+ if (idx !== -1) {
+ array.splice(idx, 1);
+ }
+ return array;
+ }
+
+ /**
+ * Returns random number between 2 specified ones.
+ * @static
+ * @method getRandomInt
+ * @memberOf fabric.util
+ * @param {Number} min lower limit
+ * @param {Number} max upper limit
+ * @return {Number} random value (between min and max)
+ */
+ function getRandomInt(min, max) {
+ return Math.floor(Math.random() * (max - min + 1)) + min;
+ }
+
+ var PiBy180 = Math.PI / 180;
+
+ /**
+ * Transforms degrees to radians.
+ * @static
+ * @method degreesToRadians
+ * @memberOf fabric.util
+ * @param {Number} degrees value in degrees
+ * @return {Number} value in radians
+ */
+ function degreesToRadians(degrees) {
+ return degrees * PiBy180;
+ }
+
+ /**
+ * Transforms radians to degrees.
+ * @static
+ * @method radiansToDegrees
+ * @memberOf fabric.util
+ * @param {Number} radians value in radians
+ * @return {Number} value in degrees
+ */
+ function radiansToDegrees(radians) {
+ return radians / PiBy180;
+ }
+
+ /**
+ * A wrapper around Number#toFixed, which contrary to native method returns number, not string.
+ * @static
+ * @method toFixed
+ * @memberOf fabric.util
+ * @param {Number | String} number number to operate on
+ * @param {Number} fractionDigits number of fraction digits to "leave"
+ * @return {Number}
+ */
+ function toFixed(number, fractionDigits) {
+ return parseFloat(Number(number).toFixed(fractionDigits));
+ }
+
+ /**
+ * Function which always returns `false`.
+ * @static
+ * @method falseFunction
+ * @memberOf fabric.util
+ * @return {Boolean}
+ */
+ function falseFunction() {
+ return false;
+ }
+
+ /**
+ * Changes value from one to another within certain period of time, invoking callbacks as value is being changed.
+ * @method animate
+ * @memberOf fabric.util
+ * @param {Object} [options] Animation options
+ * @param {Function} [options.onChange] Callback; invoked on every value change
+ * @param {Function} [options.onComplete] Callback; invoked when value change is completed
+ * @param {Number} [options.startValue=0] Starting value
+ * @param {Number} [options.endValue=100] Ending value
+ * @param {Number} [options.byValue=100] Value to modify the property by
+ * @param {Function} [options.easing] Easing function
+ * @param {Number} [options.duration=500] Duration of change
+ */
+ function animate(options) {
+
+ options || (options = { });
+
+ var start = +new Date(),
+ duration = options.duration || 500,
+ finish = start + duration, time,
+ onChange = options.onChange || function() { },
+ abort = options.abort || function() { return false; },
+ easing = options.easing || function(t, b, c, d) {return -c * Math.cos(t/d * (Math.PI/2)) + c + b;},
+ startValue = 'startValue' in options ? options.startValue : 0,
+ endValue = 'endValue' in options ? options.endValue : 100,
+ byValue = options.byValue || endValue - startValue;
+
+ options.onStart && options.onStart();
+
+ (function tick() {
+ time = +new Date();
+ var currentTime = time > finish ? duration : (time - start);
+ onChange(easing(currentTime, startValue, byValue, duration));
+ if (time > finish || abort()) {
+ options.onComplete && options.onComplete();
+ return;
+ }
+ requestAnimFrame(tick);
+ })();
+ }
+
+ var _requestAnimFrame = fabric.window.requestAnimationFrame ||
+ fabric.window.webkitRequestAnimationFrame ||
+ fabric.window.mozRequestAnimationFrame ||
+ fabric.window.oRequestAnimationFrame ||
+ fabric.window.msRequestAnimationFrame ||
+ function(callback) {
+ fabric.window.setTimeout(callback, 1000 / 60);
+ };
+ /**
+ * requestAnimationFrame polyfill based on http://paulirish.com/2011/requestanimationframe-for-smart-animating/
+ * @method requestAnimFrame
+ * @memberOf fabric.util
+ * @param {Function} callback Callback to invoke
+ * @param {DOMElement} element optional Element to associate with animation
+ */
+ var requestAnimFrame = function() {
+ return _requestAnimFrame.apply(fabric.window, arguments);
+ };
+
+ /**
+ * Loads image element from given url and passes it to a callback
+ * @method loadImage
+ * @memberOf fabric.util
+ * @param {String} url URL representing an image
+ * @param {Function} callback Callback; invoked with loaded image
+ * @param {Any} context optional Context to invoke callback in
+ */
+ function loadImage(url, callback, context) {
+ if (url) {
+ var img = new Image();
+ /** @ignore */
+ img.onload = function () {
+ callback && callback.call(context, img);
+ img = img.onload = null;
+ };
+ img.src = url;
+ }
+ else {
+ callback && callback.call(context, url);
+ }
+ }
+
+ /**
+ * Creates corresponding fabric instances from their object representations
+ * @static
+ * @memberOf fabric.util
+ * @method enlivenObjects
+ * @param {Array} objects Objects to enliven
+ * @param {Function} callback Callback to invoke when all objects are created
+ */
+ function enlivenObjects(objects, callback) {
+
+ function getKlass(type) {
+ return fabric[fabric.util.string.camelize(fabric.util.string.capitalize(type))];
+ }
+
+ function onLoaded() {
+ if (++numLoadedObjects === numTotalObjects) {
+ if (callback) {
+ callback(enlivenedObjects);
+ }
+ }
+ }
+
+ var enlivenedObjects = [ ],
+ numLoadedObjects = 0,
+ numTotalObjects = objects.length;
+
+ objects.forEach(function (o, index) {
+ if (!o.type) {
+ return;
+ }
+ var klass = getKlass(o.type);
+ if (klass.async) {
+ klass.fromObject(o, function (o) {
+ enlivenedObjects[index] = o;
+ onLoaded();
+ });
+ }
+ else {
+ enlivenedObjects[index] = klass.fromObject(o);
+ onLoaded();
+ }
+ });
+ }
+
+ /**
+ * Groups SVG elements (usually those retrieved from SVG document)
+ * @static
+ * @memberOf fabric.util
+ * @method groupSVGElements
+ * @param {Array} elements SVG elements to group
+ * @param {Object} [options] Options object
+ * @return {fabric.Object|fabric.PathGroup}
+ */
+ function groupSVGElements(elements, options, path) {
+ var object;
+
+ if (elements.length > 1) {
+ var hasText = elements.some(function(el) { return el.type === 'text'; });
+
+ if (hasText) {
+ object = new fabric.Group([ ], options);
+ elements.reverse().forEach(function(obj) {
+ if (obj.cx) {
+ obj.left = obj.cx;
+ }
+ if (obj.cy) {
+ obj.top = obj.cy;
+ }
+ object.addWithUpdate(obj);
+ });
+ }
+ else {
+ object = new fabric.PathGroup(elements, options);
+ }
+ }
+ else {
+ object = elements[0];
+ }
+
+ if (typeof path !== 'undefined') {
+ object.setSourcePath(path);
+ }
+ return object;
+ }
+
+ /**
+ * Populates an object with properties of another object
+ * @static
+ * @memberOf fabric.util
+ * @method populateWithProperties
+ * @param {Object} source Source object
+ * @param {Object} destination Destination object
+ * @return {Array} properties Propertie names to include
+ */
+ function populateWithProperties(source, destination, properties) {
+ if (properties && Object.prototype.toString.call(properties) === '[object Array]') {
+ for (var i = 0, len = properties.length; i < len; i++) {
+ destination[properties[i]] = source[properties[i]];
+ }
+ }
+ }
+
+ fabric.util.removeFromArray = removeFromArray;
+ fabric.util.degreesToRadians = degreesToRadians;
+ fabric.util.radiansToDegrees = radiansToDegrees;
+ fabric.util.toFixed = toFixed;
+ fabric.util.getRandomInt = getRandomInt;
+ fabric.util.falseFunction = falseFunction;
+ fabric.util.animate = animate;
+ fabric.util.requestAnimFrame = requestAnimFrame;
+ fabric.util.loadImage = loadImage;
+ fabric.util.enlivenObjects = enlivenObjects;
+ fabric.util.groupSVGElements = groupSVGElements;
+ fabric.util.populateWithProperties = populateWithProperties;
+})();
+(function() {
+
+ var slice = Array.prototype.slice;
+
+ if (!Array.prototype.indexOf) {
+ /**
+ * Finds index of an element in an array
+ * @method indexOf
+ * @param {Any} searchElement
+ * @param {Number} [fromIndex]
+ */
+ Array.prototype.indexOf = function (searchElement /*, fromIndex */ ) {
+ if (this === void 0 || this === null) {
+ throw new TypeError();
+ }
+ var t = Object(this), len = t.length >>> 0;
+ if (len === 0) {
+ return -1;
+ }
+ var n = 0;
+ if (arguments.length > 0) {
+ n = Number(arguments[1]);
+ if (n !== n) { // shortcut for verifying if it's NaN
+ n = 0;
+ }
+ else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) {
+ n = (n > 0 || -1) * Math.floor(Math.abs(n));
+ }
+ }
+ if (n >= len) {
+ return -1;
+ }
+ var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
+ for (; k < len; k++) {
+ if (k in t && t[k] === searchElement) {
+ return k;
+ }
+ }
+ return -1;
+ };
+ }
+
+ if (!Array.prototype.forEach) {
+ /**
+ * Iterates an array, invoking callback for each element
+ * @method forEach
+ * @param {Function} fn Callback to invoke for each element
+ * @param {Object} [context] Context to invoke callback in
+ */
+ Array.prototype.forEach = function(fn, context) {
+ for (var i = 0, len = this.length >>> 0; i < len; i++) {
+ if (i in this) {
+ fn.call(context, this[i], i, this);
+ }
+ }
+ };
+ }
+
+ if (!Array.prototype.map) {
+ /**
+ * Returns a result of iterating over an array, invoking callback for each element
+ * @method map
+ * @param {Function} fn Callback to invoke for each element
+ * @param {Object} [context] Context to invoke callback in
+ */
+ Array.prototype.map = function(fn, context) {
+ var result = [ ];
+ for (var i = 0, len = this.length >>> 0; i < len; i++) {
+ if (i in this) {
+ result[i] = fn.call(context, this[i], i, this);
+ }
+ }
+ return result;
+ };
+ }
+
+ if (!Array.prototype.every) {
+ /**
+ * Returns true if a callback returns truthy value for all elements in an array
+ * @method every
+ * @param {Function} fn Callback to invoke for each element
+ * @param {Object} [context] Context to invoke callback in
+ */
+ Array.prototype.every = function(fn, context) {
+ for (var i = 0, len = this.length >>> 0; i < len; i++) {
+ if (i in this && !fn.call(context, this[i], i, this)) {
+ return false;
+ }
+ }
+ return true;
+ };
+ }
+
+ if (!Array.prototype.some) {
+ /**
+ * Returns true if a callback returns truthy value for at least one element in an array
+ * @method every
+ * @param {Function} fn Callback to invoke for each element
+ * @param {Object} [context] Context to invoke callback in
+ */
+ Array.prototype.some = function(fn, context) {
+ for (var i = 0, len = this.length >>> 0; i < len; i++) {
+ if (i in this && fn.call(context, this[i], i, this)) {
+ return true;
+ }
+ }
+ return false;
+ };
+ }
+
+ if (!Array.prototype.filter) {
+ /**
+ * Returns the result of iterating over elements in an array
+ * @method filter
+ * @param {Function} fn Callback to invoke for each element
+ * @param {Object} [context] Context to invoke callback in
+ */
+ Array.prototype.filter = function(fn, context) {
+ var result = [ ], val;
+ for (var i = 0, len = this.length >>> 0; i < len; i++) {
+ if (i in this) {
+ val = this[i]; // in case fn mutates this
+ if (fn.call(context, val, i, this)) {
+ result.push(val);
+ }
+ }
+ }
+ return result;
+ };
+ }
+
+ if (!Array.prototype.reduce) {
+ /**
+ * Returns "folded" (reduced) result of iterating over elements in an array
+ * @method filter
+ * @param {Function} fn Callback to invoke for each element
+ * @param {Object} [context] Context to invoke callback in
+ */
+ Array.prototype.reduce = function(fn /*, initial*/) {
+ var len = this.length >>> 0,
+ i = 0,
+ rv;
+
+ if (arguments.length > 1) {
+ rv = arguments[1];
+ }
+ else {
+ do {
+ if (i in this) {
+ rv = this[i++];
+ break;
+ }
+ // if array contains no values, no initial value to return
+ if (++i >= len) {
+ throw new TypeError();
+ }
+ }
+ while (true);
+ }
+ for (; i < len; i++) {
+ if (i in this) {
+ rv = fn.call(null, rv, this[i], i, this);
+ }
+ }
+ return rv;
+ };
+ }
+
+ /**
+ * Invokes method on all items in a given array
+ * @method invoke
+ * @memberOf fabric.util.array
+ * @param {Array} array Array to iterate over
+ * @param {String} method Name of a method to invoke
+ */
+ function invoke(array, method) {
+ var args = slice.call(arguments, 2), result = [ ];
+ for (var i = 0, len = array.length; i < len; i++) {
+ result[i] = args.length ? array[i][method].apply(array[i], args) : array[i][method].call(array[i]);
+ }
+ return result;
+ }
+
+ /**
+ * Finds maximum value in array (not necessarily "first" one)
+ * @method max
+ * @memberOf fabric.util.array
+ * @param {Array} array Array to iterate over
+ * @param {String} byProperty
+ */
+ function max(array, byProperty) {
+ if (!array || array.length === 0) return undefined;
+
+ var i = array.length - 1,
+ result = byProperty ? array[i][byProperty] : array[i];
+ if (byProperty) {
+ while (i--) {
+ if (array[i][byProperty] >= result) {
+ result = array[i][byProperty];
+ }
+ }
+ }
+ else {
+ while (i--) {
+ if (array[i] >= result) {
+ result = array[i];
+ }
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Finds minimum value in array (not necessarily "first" one)
+ * @method min
+ * @memberOf fabric.util.array
+ * @param {Array} array Array to iterate over
+ * @param {String} byProperty
+ */
+ function min(array, byProperty) {
+ if (!array || array.length === 0) return undefined;
+
+ var i = array.length - 1,
+ result = byProperty ? array[i][byProperty] : array[i];
+
+ if (byProperty) {
+ while (i--) {
+ if (array[i][byProperty] < result) {
+ result = array[i][byProperty];
+ }
+ }
+ }
+ else {
+ while (i--) {
+ if (array[i] < result) {
+ result = array[i];
+ }
+ }
+ }
+ return result;
+ }
+
+ /** @namespace */
+ fabric.util.array = {
+ invoke: invoke,
+ min: min,
+ max: max
+ };
+
+})();
+(function(){
+
+ /**
+ * Copies all enumerable properties of one object to another
+ * @memberOf fabric.util.object
+ * @method extend
+ * @param {Object} destination Where to copy to
+ * @param {Object} source Where to copy from
+ */
+ function extend(destination, source) {
+ // JScript DontEnum bug is not taken care of
+ for (var property in source) {
+ destination[property] = source[property];
+ }
+ return destination;
+ }
+
+ /**
+ * Creates an empty object and copies all enumerable properties of another object to it
+ * @method clone
+ * @memberOf fabric.util.object
+ * @param {Object} object Object to clone
+ */
+ function clone(object) {
+ return extend({ }, object);
+ }
+
+ /** @namespace fabric.util.object */
+ fabric.util.object = {
+ extend: extend,
+ clone: clone
+ };
+
+})();
+(function() {
+
+if (!String.prototype.trim) {
+ /**
+ * Trims a string (removing whitespace from the beginning and the end)
+ * @method trim
+ * @see String#trim on MDN
+ */
+ String.prototype.trim = function () {
+ // this trim is not fully ES3 or ES5 compliant, but it should cover most cases for now
+ return this.replace(/^[\s\xA0]+/, '').replace(/[\s\xA0]+$/, '');
+ };
+}
+
+/**
+ * Camelizes a string
+ * @memberOf fabric.util.string
+ * @method camelize
+ * @param {String} string String to camelize
+ * @return {String} Camelized version of a string
+ */
+function camelize(string) {
+ return string.replace(/-+(.)?/g, function(match, character) {
+ return character ? character.toUpperCase() : '';
+ });
+}
+
+/**
+ * Capitalizes a string
+ * @memberOf fabric.util.string
+ * @method capitalize
+ * @param {String} string String to capitalize
+ * @return {String} Capitalized version of a string
+ */
+function capitalize(string) {
+ return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
+}
+
+/**
+ * Escapes XML in a string
+ * @memberOf fabric.util.string
+ * @method escapeXml
+ * @param {String} string String to escape
+ * @return {String} Escaped version of a string
+ */
+function escapeXml(string) {
+ return string.replace(/&/g, '&')
+ .replace(/"/g, '"')
+ .replace(/'/g, ''')
+ .replace(//g, '>');
+}
+
+/** @namespace */
+fabric.util.string = {
+ camelize: camelize,
+ capitalize: capitalize,
+ escapeXml: escapeXml
+};
+}());
+
+(function() {
+
+ var slice = Array.prototype.slice,
+ apply = Function.prototype.apply,
+ Dummy = function() { };
+
+ if (!Function.prototype.bind) {
+ /**
+ * Cross-browser approximation of ES5 Function.prototype.bind (not fully spec conforming)
+ * @see Function#bind on MDN
+ * @param {Object} thisArg Object to bind function to
+ * @param {Any[]} [...] Values to pass to a bound function
+ * @return {Function}
+ */
+ Function.prototype.bind = function(thisArg) {
+ var fn = this, args = slice.call(arguments, 1), bound;
+ if (args.length) {
+ bound = function() {
+ return apply.call(fn, this instanceof Dummy ? this : thisArg, args.concat(slice.call(arguments)));
+ };
+ }
+ else {
+ /** @ignore */
+ bound = function() {
+ return apply.call(fn, this instanceof Dummy ? this : thisArg, arguments);
+ };
+ }
+ Dummy.prototype = this.prototype;
+ bound.prototype = new Dummy();
+
+ return bound;
+ };
+ }
+
+})();
+(function() {
+
+ var slice = Array.prototype.slice, emptyFunction = function() { };
+
+ var IS_DONTENUM_BUGGY = (function(){
+ for (var p in { toString: 1 }) {
+ if (p === 'toString') return false;
+ }
+ return true;
+ })();
+
+ /** @ignore */
+ var addMethods = function(klass, source, parent) {
+ for (var property in source) {
+
+ if (property in klass.prototype && typeof klass.prototype[property] === 'function') {
+
+ klass.prototype[property] = (function(property) {
+ return function() {
+
+ var superclass = this.constructor.superclass;
+ this.constructor.superclass = parent;
+ var returnValue = source[property].apply(this, arguments);
+ this.constructor.superclass = superclass;
+
+ if (property !== 'initialize') {
+ return returnValue;
+ }
+ };
+ })(property);
+ }
+ else {
+ klass.prototype[property] = source[property];
+ }
+
+ if (IS_DONTENUM_BUGGY) {
+ if (source.toString !== Object.prototype.toString) {
+ klass.prototype.toString = source.toString;
+ }
+ if (source.valueOf !== Object.prototype.valueOf) {
+ klass.prototype.valueOf = source.valueOf;
+ }
+ }
+ }
+ };
+
+ function Subclass() { }
+
+ function callSuper(methodName) {
+ var fn = this.constructor.superclass.prototype[methodName];
+ return (arguments.length > 1)
+ ? fn.apply(this, slice.call(arguments, 1))
+ : fn.call(this);
+ }
+
+ /**
+ * Helper for creation of "classes". Note that pr
+ * @method createClass
+ * @param parent optional "Class" to inherit from
+ * @param properties Properties shared by all instances of this class
+ * (be careful modifying objects defined here as this would affect all instances)
+ * @memberOf fabric.util
+ */
+ function createClass() {
+ var parent = null,
+ properties = slice.call(arguments, 0);
+
+ if (typeof properties[0] === 'function') {
+ parent = properties.shift();
+ }
+ function klass() {
+ this.initialize.apply(this, arguments);
+ }
+
+ klass.superclass = parent;
+ klass.subclasses = [ ];
+
+ if (parent) {
+ Subclass.prototype = parent.prototype;
+ klass.prototype = new Subclass();
+ parent.subclasses.push(klass);
+ }
+ for (var i = 0, length = properties.length; i < length; i++) {
+ addMethods(klass, properties[i], parent);
+ }
+ if (!klass.prototype.initialize) {
+ klass.prototype.initialize = emptyFunction;
+ }
+ klass.prototype.constructor = klass;
+ klass.prototype.callSuper = callSuper;
+ return klass;
+ }
+
+ fabric.util.createClass = createClass;
+})();
+(function () {
+
+ /* EVENT HANDLING */
+
+ function areHostMethods(object) {
+ var methodNames = Array.prototype.slice.call(arguments, 1),
+ t, i, len = methodNames.length;
+ for (i = 0; i < len; i++) {
+ t = typeof object[methodNames[i]];
+ if (!(/^(?:function|object|unknown)$/).test(t)) return false;
+ }
+ return true;
+ }
+ var getUniqueId = (function () {
+ var uid = 0;
+ return function (element) {
+ return element.__uniqueID || (element.__uniqueID = 'uniqueID__' + uid++);
+ };
+ })();
+
+ /** @ignore */
+ var getElement, setElement;
+
+ (function () {
+ var elements = { };
+ /** @ignore */
+ getElement = function (uid) {
+ return elements[uid];
+ };
+ /** @ignore */
+ setElement = function (uid, element) {
+ elements[uid] = element;
+ };
+ })();
+
+ function createListener(uid, handler) {
+ return {
+ handler: handler,
+ wrappedHandler: createWrappedHandler(uid, handler)
+ };
+ }
+
+ function createWrappedHandler(uid, handler) {
+ return function (e) {
+ handler.call(getElement(uid), e || fabric.window.event);
+ };
+ }
+
+ function createDispatcher(uid, eventName) {
+ return function (e) {
+ if (handlers[uid] && handlers[uid][eventName]) {
+ var handlersForEvent = handlers[uid][eventName];
+ for (var i = 0, len = handlersForEvent.length; i < len; i++) {
+ handlersForEvent[i].call(this, e || fabric.window.event);
+ }
+ }
+ };
+ }
+
+ var shouldUseAddListenerRemoveListener = (
+ areHostMethods(fabric.document.documentElement, 'addEventListener', 'removeEventListener') &&
+ areHostMethods(fabric.window, 'addEventListener', 'removeEventListener')),
+
+ shouldUseAttachEventDetachEvent = (
+ areHostMethods(fabric.document.documentElement, 'attachEvent', 'detachEvent') &&
+ areHostMethods(fabric.window, 'attachEvent', 'detachEvent')),
+
+ // IE branch
+ listeners = { },
+
+ // DOM L0 branch
+ handlers = { },
+
+ addListener, removeListener;
+
+ if (shouldUseAddListenerRemoveListener) {
+ /** @ignore */
+ addListener = function (element, eventName, handler) {
+ element.addEventListener(eventName, handler, false);
+ };
+ /** @ignore */
+ removeListener = function (element, eventName, handler) {
+ element.removeEventListener(eventName, handler, false);
+ };
+ }
+
+ else if (shouldUseAttachEventDetachEvent) {
+ /** @ignore */
+ addListener = function (element, eventName, handler) {
+ var uid = getUniqueId(element);
+ setElement(uid, element);
+ if (!listeners[uid]) {
+ listeners[uid] = { };
+ }
+ if (!listeners[uid][eventName]) {
+ listeners[uid][eventName] = [ ];
+
+ }
+ var listener = createListener(uid, handler);
+ listeners[uid][eventName].push(listener);
+ element.attachEvent('on' + eventName, listener.wrappedHandler);
+ };
+ /** @ignore */
+ removeListener = function (element, eventName, handler) {
+ var uid = getUniqueId(element), listener;
+ if (listeners[uid] && listeners[uid][eventName]) {
+ for (var i = 0, len = listeners[uid][eventName].length; i < len; i++) {
+ listener = listeners[uid][eventName][i];
+ if (listener && listener.handler === handler) {
+ element.detachEvent('on' + eventName, listener.wrappedHandler);
+ listeners[uid][eventName][i] = null;
+ }
+ }
+ }
+ };
+ }
+ else {
+ /** @ignore */
+ addListener = function (element, eventName, handler) {
+ var uid = getUniqueId(element);
+ if (!handlers[uid]) {
+ handlers[uid] = { };
+ }
+ if (!handlers[uid][eventName]) {
+ handlers[uid][eventName] = [ ];
+ var existingHandler = element['on' + eventName];
+ if (existingHandler) {
+ handlers[uid][eventName].push(existingHandler);
+ }
+ element['on' + eventName] = createDispatcher(uid, eventName);
+ }
+ handlers[uid][eventName].push(handler);
+ };
+ /** @ignore */
+ removeListener = function (element, eventName, handler) {
+ var uid = getUniqueId(element);
+ if (handlers[uid] && handlers[uid][eventName]) {
+ var handlersForEvent = handlers[uid][eventName];
+ for (var i = 0, len = handlersForEvent.length; i < len; i++) {
+ if (handlersForEvent[i] === handler) {
+ handlersForEvent.splice(i, 1);
+ }
+ }
+ }
+ };
+ }
+
+ /**
+ * Adds an event listener to an element
+ * @mthod addListener
+ * @memberOf fabric.util
+ * @function
+ * @param {HTMLElement} element
+ * @param {String} eventName
+ * @param {Function} handler
+ */
+ fabric.util.addListener = addListener;
+
+ /**
+ * Removes an event listener from an element
+ * @mthod removeListener
+ * @memberOf fabric.util
+ * @function
+ * @param {HTMLElement} element
+ * @param {String} eventName
+ * @param {Function} handler
+ */
+ fabric.util.removeListener = removeListener;
+
+ /**
+ * Cross-browser wrapper for getting event's coordinates
+ * @method getPointer
+ * @memberOf fabric.util
+ * @param {Event} event
+ */
+ function getPointer(event) {
+ var element = event.target || event.srcElement,
+ scrollLeft = 0,
+ scrollTop = 0,
+ firstFixedAncestor;
+
+ while (element && element.parentNode && !firstFixedAncestor) {
+ element = element.parentNode;
+
+ if (element !== fabric.document && fabric.util.getElementPosition(element) === 'fixed') firstFixedAncestor = element;
+
+ scrollLeft += element.scrollLeft || 0;
+ scrollTop += element.scrollTop || 0;
+ }
+
+ return {
+ x: pointerX(event) + scrollLeft,
+ y: pointerY(event) + scrollTop
+ };
+ }
+
+ var pointerX = function(event) {
+ // looks like in IE (<9) clientX at certain point (apparently when mouseup fires on VML element)
+ // is represented as COM object, with all the consequences, like "unknown" type and error on [[Get]]
+ // need to investigate later
+ return (typeof event.clientX !== 'unknown' ? event.clientX : 0);
+ };
+
+ var pointerY = function(event) {
+ return (typeof event.clientY !== 'unknown' ? event.clientY : 0);
+ };
+
+ if (fabric.isTouchSupported) {
+ pointerX = function(event) {
+ return event.touches && event.touches[0] && event.touches[0].pageX || event.clientX;
+ };
+ pointerY = function(event) {
+ return event.touches && event.touches[0] && event.touches[0].pageY || event.clientY;
+ };
+ }
+
+ fabric.util.getPointer = getPointer;
+
+ fabric.util.object.extend(fabric.util, fabric.Observable);
+
+})();
+(function () {
+
+ /**
+ * Cross-browser wrapper for setting element's style
+ * @method setStyle
+ * @memberOf fabric.util
+ * @param {HTMLElement} element
+ * @param {Object} styles
+ * @return {HTMLElement} Element that was passed as a first argument
+ */
+ function setStyle(element, styles) {
+ var elementStyle = element.style;
+ if (!elementStyle) {
+ return element;
+ }
+ if (typeof styles === 'string') {
+ element.style.cssText += ';' + styles;
+ return styles.indexOf('opacity') > -1
+ ? setOpacity(element, styles.match(/opacity:\s*(\d?\.?\d*)/)[1])
+ : element;
+ }
+ for (var property in styles) {
+ if (property === 'opacity') {
+ setOpacity(element, styles[property]);
+ }
+ else {
+ var normalizedProperty = (property === 'float' || property === 'cssFloat')
+ ? (typeof elementStyle.styleFloat === 'undefined' ? 'cssFloat' : 'styleFloat')
+ : property;
+ elementStyle[normalizedProperty] = styles[property];
+ }
+ }
+ return element;
+ }
+
+ var parseEl = fabric.document.createElement('div'),
+ supportsOpacity = typeof parseEl.style.opacity === 'string',
+ supportsFilters = typeof parseEl.style.filter === 'string',
+ reOpacity = /alpha\s*\(\s*opacity\s*=\s*([^\)]+)\)/,
+
+ /** @ignore */
+ setOpacity = function (element) { return element; };
+
+ if (supportsOpacity) {
+ /** @ignore */
+ setOpacity = function(element, value) {
+ element.style.opacity = value;
+ return element;
+ };
+ }
+ else if (supportsFilters) {
+ /** @ignore */
+ setOpacity = function(element, value) {
+ var es = element.style;
+ if (element.currentStyle && !element.currentStyle.hasLayout) {
+ es.zoom = 1;
+ }
+ if (reOpacity.test(es.filter)) {
+ value = value >= 0.9999 ? '' : ('alpha(opacity=' + (value * 100) + ')');
+ es.filter = es.filter.replace(reOpacity, value);
+ }
+ else {
+ es.filter += ' alpha(opacity=' + (value * 100) + ')';
+ }
+ return element;
+ };
+ }
+
+ fabric.util.setStyle = setStyle;
+
+})();
+(function() {
+
+ var _slice = Array.prototype.slice;
+
+ /**
+ * Takes id and returns an element with that id (if one exists in a document)
+ * @method getById
+ * @memberOf fabric.util
+ * @param {String|HTMLElement} id
+ * @return {HTMLElement|null}
+ */
+ function getById(id) {
+ return typeof id === 'string' ? fabric.document.getElementById(id) : id;
+ }
+
+ /**
+ * Converts an array-like object (e.g. arguments or NodeList) to an array
+ * @method toArray
+ * @memberOf fabric.util
+ * @param {Object} arrayLike
+ * @return {Array}
+ */
+ var toArray = function(arrayLike) {
+ return _slice.call(arrayLike, 0);
+ };
+
+ var sliceCanConvertNodelists;
+ try {
+ sliceCanConvertNodelists = toArray(fabric.document.childNodes) instanceof Array;
+ }
+ catch(err) { }
+
+ if (!sliceCanConvertNodelists) {
+ toArray = function(arrayLike) {
+ var arr = new Array(arrayLike.length), i = arrayLike.length;
+ while (i--) {
+ arr[i] = arrayLike[i];
+ }
+ return arr;
+ };
+ }
+
+ /**
+ * Creates specified element with specified attributes
+ * @method makeElement
+ * @memberOf fabric.util
+ * @param {String} tagName Type of an element to create
+ * @param {Object} [attributes] Attributes to set on an element
+ * @return {HTMLElement} Newly created element
+ */
+ function makeElement(tagName, attributes) {
+ var el = fabric.document.createElement(tagName);
+ for (var prop in attributes) {
+ if (prop === 'class') {
+ el.className = attributes[prop];
+ }
+ else if (prop === 'for') {
+ el.htmlFor = attributes[prop];
+ }
+ else {
+ el.setAttribute(prop, attributes[prop]);
+ }
+ }
+ return el;
+ }
+
+ /**
+ * Adds class to an element
+ * @method addClass
+ * @memberOf fabric.util
+ * @param {HTMLElement} element Element to add class to
+ * @param {String} className Class to add to an element
+ */
+ function addClass(element, className) {
+ if ((' ' + element.className + ' ').indexOf(' ' + className + ' ') === -1) {
+ element.className += (element.className ? ' ' : '') + className;
+ }
+ }
+
+ /**
+ * Wraps element with another element
+ * @method wrapElement
+ * @memberOf fabric.util
+ * @param {HTMLElement} element Element to wrap
+ * @param {HTMLElement|String} wrapper Element to wrap with
+ * @param {Object} [attributes] Attributes to set on a wrapper
+ * @return {HTMLElement} wrapper
+ */
+ function wrapElement(element, wrapper, attributes) {
+ if (typeof wrapper === 'string') {
+ wrapper = makeElement(wrapper, attributes);
+ }
+ if (element.parentNode) {
+ element.parentNode.replaceChild(wrapper, element);
+ }
+ wrapper.appendChild(element);
+ return wrapper;
+ }
+
+ /**
+ * Returns offset for a given element
+ * @method getElementOffset
+ * @function
+ * @memberOf fabric.util
+ * @param {HTMLElement} element Element to get offset for
+ * @return {Object} Object with "left" and "top" properties
+ */
+ function getElementOffset(element) {
+ // TODO (kangax): need to fix this method
+ var valueT = 0, valueL = 0;
+ do {
+ valueT += element.offsetTop || 0;
+ valueL += element.offsetLeft || 0;
+ element = element.offsetParent;
+ }
+ while (element);
+ return ({ left: valueL, top: valueT });
+ }
+
+ /**
+ * Returns position of a given element
+ * @method getElementPosition
+ * @function
+ * @memberOf fabric.util
+ * @param {HTMLElement} element Element to get offset for
+ * @return {Object} position of the given element.
+ */
+ var getElementPosition;
+ if (fabric.document.defaultView && fabric.document.defaultView.getComputedStyle) {
+ getElementPosition = function (element) {
+ return fabric.document.defaultView.getComputedStyle(element, null).position;
+ };
+ }
+ else {
+ /** @ignore */
+ getElementPosition = function (element) {
+ var value = element.style.position;
+ if (!value && element.currentStyle) value = element.currentStyle.position;
+ return value;
+ };
+ }
+
+ (function () {
+ var style = fabric.document.documentElement.style;
+
+ var selectProp = 'userSelect' in style
+ ? 'userSelect'
+ : 'MozUserSelect' in style
+ ? 'MozUserSelect'
+ : 'WebkitUserSelect' in style
+ ? 'WebkitUserSelect'
+ : 'KhtmlUserSelect' in style
+ ? 'KhtmlUserSelect'
+ : '';
+
+ /**
+ * Makes element unselectable
+ * @method makeElementUnselectable
+ * @memberOf fabric.util
+ * @param {HTMLElement} element Element to make unselectable
+ * @return {HTMLElement} Element that was passed in
+ */
+ function makeElementUnselectable(element) {
+ if (typeof element.onselectstart !== 'undefined') {
+ element.onselectstart = fabric.util.falseFunction;
+ }
+ if (selectProp) {
+ element.style[selectProp] = 'none';
+ }
+ else if (typeof element.unselectable === 'string') {
+ element.unselectable = 'on';
+ }
+ return element;
+ }
+
+ /**
+ * Makes element selectable
+ * @method makeElementSelectable
+ * @memberOf fabric.util
+ * @param {HTMLElement} element Element to make selectable
+ * @return {HTMLElement} Element that was passed in
+ */
+ function makeElementSelectable(element) {
+ if (typeof element.onselectstart !== 'undefined') {
+ element.onselectstart = null;
+ }
+ if (selectProp) {
+ element.style[selectProp] = '';
+ }
+ else if (typeof element.unselectable === 'string') {
+ element.unselectable = '';
+ }
+ return element;
+ }
+
+ fabric.util.makeElementUnselectable = makeElementUnselectable;
+ fabric.util.makeElementSelectable = makeElementSelectable;
+ })();
+
+ (function() {
+
+ /**
+ * Inserts a script element with a given url into a document; invokes callback, when that script is finished loading
+ * @method getScript
+ * @memberOf fabric.util
+ * @param {String} url URL of a script to load
+ * @param {Function} callback Callback to execute when script is finished loading
+ */
+ function getScript(url, callback) {
+ var headEl = fabric.document.getElementsByTagName("head")[0],
+ scriptEl = fabric.document.createElement('script'),
+ loading = true;
+
+ scriptEl.type = 'text/javascript';
+ scriptEl.setAttribute('runat', 'server');
+
+ /** @ignore */
+ scriptEl.onload = /** @ignore */ scriptEl.onreadystatechange = function(e) {
+ if (loading) {
+ if (typeof this.readyState === 'string' &&
+ this.readyState !== 'loaded' &&
+ this.readyState !== 'complete') return;
+ loading = false;
+ callback(e || fabric.window.event);
+ scriptEl = scriptEl.onload = scriptEl.onreadystatechange = null;
+ }
+ };
+ scriptEl.src = url;
+ headEl.appendChild(scriptEl);
+ // causes issue in Opera
+ // headEl.removeChild(scriptEl);
+ }
+
+ fabric.util.getScript = getScript;
+ })();
+
+ fabric.util.getById = getById;
+ fabric.util.toArray = toArray;
+ fabric.util.makeElement = makeElement;
+ fabric.util.addClass = addClass;
+ fabric.util.wrapElement = wrapElement;
+ fabric.util.getElementOffset = getElementOffset;
+ fabric.util.getElementPosition = getElementPosition;
+
+})();
+(function(){
+
+ function addParamToUrl(url, param) {
+ return url + (/\?/.test(url) ? '&' : '?') + param;
+ }
+
+ var makeXHR = (function() {
+ var factories = [
+ function() { return new ActiveXObject("Microsoft.XMLHTTP"); },
+ function() { return new ActiveXObject("Msxml2.XMLHTTP"); },
+ function() { return new ActiveXObject("Msxml2.XMLHTTP.3.0"); },
+ function() { return new XMLHttpRequest(); }
+ ];
+ for (var i = factories.length; i--; ) {
+ try {
+ var req = factories[i]();
+ if (req) {
+ return factories[i];
+ }
+ }
+ catch (err) { }
+ }
+ })();
+
+ function emptyFn() { }
+
+ /**
+ * Cross-browser abstraction for sending XMLHttpRequest
+ * @method request
+ * @memberOf fabric.util
+ * @param {String} url URL to send XMLHttpRequest to
+ * @param {Object} [options] Options object
+ * @param {String} [options.method="GET"]
+ * @param {Function} options.onComplete Callback to invoke when request is completed
+ * @return {XMLHttpRequest} request
+ */
+ function request(url, options) {
+
+ options || (options = { });
+
+ var method = options.method ? options.method.toUpperCase() : 'GET',
+ onComplete = options.onComplete || function() { },
+ xhr = makeXHR(),
+ body;
+
+ /** @ignore */
+ xhr.onreadystatechange = function() {
+ if (xhr.readyState === 4) {
+ onComplete(xhr);
+ xhr.onreadystatechange = emptyFn;
+ }
+ };
+
+ if (method === 'GET') {
+ body = null;
+ if (typeof options.parameters === 'string') {
+ url = addParamToUrl(url, options.parameters);
+ }
+ }
+
+ xhr.open(method, url, true);
+
+ if (method === 'POST' || method === 'PUT') {
+ xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
+ }
+
+ xhr.send(body);
+ return xhr;
+ }
+
+ fabric.util.request = request;
+})();
+(function() {
+
+ /**
+ * Quadratic easing in
+ * @method easeInQuad
+ * @memberOf fabric.util.ease
+ */
+ function easeInQuad(t, b, c, d) {
+ return c*(t/=d)*t + b;
+ }
+
+ /**
+ * Quadratic easing out
+ * @method easeOutQuad
+ * @memberOf fabric.util.ease
+ */
+ function easeOutQuad(t, b, c, d) {
+ return -c *(t/=d)*(t-2) + b;
+ }
+
+ /**
+ * Quadratic easing in and out
+ * @method easeInOutQuad
+ * @memberOf fabric.util.ease
+ */
+ function easeInOutQuad(t, b, c, d) {
+ t /= (d/2);
+ if (t < 1) return c/2*t*t + b;
+ return -c/2 * ((--t)*(t-2) - 1) + b;
+ }
+
+ /**
+ * Cubic easing in
+ * @method easeInCubic
+ * @memberOf fabric.util.ease
+ */
+ function easeInCubic(t, b, c, d) {
+ return c*(t/=d)*t*t + b;
+ }
+
+ /**
+ * Cubic easing out
+ * @method easeOutCubic
+ * @memberOf fabric.util.ease
+ */
+ function easeOutCubic(t, b, c, d) {
+ return c*((t=t/d-1)*t*t + 1) + b;
+ }
+
+ /**
+ * Cubic easing in and out
+ * @method easeInOutCubic
+ * @memberOf fabric.util.ease
+ */
+ function easeInOutCubic(t, b, c, d) {
+ t /= d/2;
+ if (t < 1) return c/2*t*t*t + b;
+ return c/2*((t-=2)*t*t + 2) + b;
+ }
+
+ /**
+ * Quartic easing in
+ * @method easeInQuart
+ * @memberOf fabric.util.ease
+ */
+ function easeInQuart(t, b, c, d) {
+ return c*(t/=d)*t*t*t + b;
+ }
+
+ /**
+ * Quartic easing out
+ * @method easeOutQuart
+ * @memberOf fabric.util.ease
+ */
+ function easeOutQuart(t, b, c, d) {
+ return -c * ((t=t/d-1)*t*t*t - 1) + b;
+ }
+
+ /**
+ * Quartic easing in and out
+ * @method easeInOutQuart
+ * @memberOf fabric.util.ease
+ */
+ function easeInOutQuart(t, b, c, d) {
+ t /= d/2;
+ if (t < 1) return c/2*t*t*t*t + b;
+ return -c/2 * ((t-=2)*t*t*t - 2) + b;
+ }
+
+ /**
+ * Quintic easing in
+ * @method easeInQuint
+ * @memberOf fabric.util.ease
+ */
+ function easeInQuint(t, b, c, d) {
+ return c*(t/=d)*t*t*t*t + b;
+ }
+
+ /**
+ * Quintic easing out
+ * @method easeOutQuint
+ * @memberOf fabric.util.ease
+ */
+ function easeOutQuint(t, b, c, d) {
+ return c*((t=t/d-1)*t*t*t*t + 1) + b;
+ }
+
+ /**
+ * Quintic easing in and out
+ * @method easeInOutQuint
+ * @memberOf fabric.util.ease
+ */
+ function easeInOutQuint(t, b, c, d) {
+ t /= d/2;
+ if (t < 1) return c/2*t*t*t*t*t + b;
+ return c/2*((t-=2)*t*t*t*t + 2) + b;
+ }
+
+ /**
+ * Sinusoidal easing in
+ * @method easeInSine
+ * @memberOf fabric.util.ease
+ */
+ function easeInSine(t, b, c, d) {
+ return -c * Math.cos(t/d * (Math.PI/2)) + c + b;
+ }
+
+ /**
+ * Sinusoidal easing out
+ * @method easeOutSine
+ * @memberOf fabric.util.ease
+ */
+ function easeOutSine(t, b, c, d) {
+ return c * Math.sin(t/d * (Math.PI/2)) + b;
+ }
+
+ /**
+ * Sinusoidal easing in and out
+ * @method easeInOutSine
+ * @memberOf fabric.util.ease
+ */
+ function easeInOutSine(t, b, c, d) {
+ return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b;
+ }
+
+ /**
+ * Exponential easing in
+ * @method easeInExpo
+ * @memberOf fabric.util.ease
+ */
+ function easeInExpo(t, b, c, d) {
+ return (t===0) ? b : c * Math.pow(2, 10 * (t/d - 1)) + b;
+ }
+
+ /**
+ * Exponential easing out
+ * @method easeOutExpo
+ * @memberOf fabric.util.ease
+ */
+ function easeOutExpo(t, b, c, d) {
+ return (t===d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
+ }
+
+ /**
+ * Exponential easing in and out
+ * @method easeInOutExpo
+ * @memberOf fabric.util.ease
+ */
+ function easeInOutExpo(t, b, c, d) {
+ if (t===0) return b;
+ if (t===d) return b+c;
+ t /= d/2;
+ if (t < 1) return c/2 * Math.pow(2, 10 * (t - 1)) + b;
+ return c/2 * (-Math.pow(2, -10 * --t) + 2) + b;
+ }
+
+ /**
+ * Circular easing in
+ * @method easeInCirc
+ * @memberOf fabric.util.ease
+ */
+ function easeInCirc(t, b, c, d) {
+ return -c * (Math.sqrt(1 - (t/=d)*t) - 1) + b;
+ }
+
+ /**
+ * Circular easing out
+ * @method easeOutCirc
+ * @memberOf fabric.util.ease
+ */
+ function easeOutCirc(t, b, c, d) {
+ return c * Math.sqrt(1 - (t=t/d-1)*t) + b;
+ }
+
+ /**
+ * Circular easing in and out
+ * @method easeInOutCirc
+ * @memberOf fabric.util.ease
+ */
+ function easeInOutCirc(t, b, c, d) {
+ t /= d/2;
+ if (t < 1) return -c/2 * (Math.sqrt(1 - t*t) - 1) + b;
+ return c/2 * (Math.sqrt(1 - (t-=2)*t) + 1) + b;
+ }
+
+ /**
+ * Elastic easing in
+ * @method easeInElastic
+ * @memberOf fabric.util.ease
+ */
+ function easeInElastic(t, b, c, d) {
+ var s=1.70158;var p=0;var a=c;
+ if (t===0) return b;
+ t /= d;
+ if (t===1) return b+c;
+ if (!p) p=d*0.3;
+ if (a < Math.abs(c)) { a=c; s=p/4; }
+ else s = p/(2*Math.PI) * Math.asin (c/a);
+ return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
+ }
+
+ /**
+ * Elastic easing out
+ * @method easeOutElastic
+ * @memberOf fabric.util.ease
+ */
+ function easeOutElastic(t, b, c, d) {
+ var s=1.70158;var p=0;var a=c;
+ if (t===0) return b;
+ t /= d;
+ if (t===1) return b+c;
+ if (!p) p=d*0.3;
+ if (a < Math.abs(c)) { a=c; s=p/4; }
+ else s = p/(2*Math.PI) * Math.asin (c/a);
+ return a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b;
+ }
+
+ /**
+ * Elastic easing in and out
+ * @method easeInOutElastic
+ * @memberOf fabric.util.ease
+ */
+ function easeInOutElastic(t, b, c, d) {
+ var s=1.70158;var p=0;var a=c;
+ if (t===0) return b;
+ t /= d/2;
+ if (t===2) return b+c;
+ if (!p) p=d*(0.3*1.5);
+ if (a < Math.abs(c)) { a=c; s=p/4; }
+ else s = p/(2*Math.PI) * Math.asin (c/a);
+ if (t < 1) return -0.5*(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
+ return a*Math.pow(2,-10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )*0.5 + c + b;
+ }
+
+ /**
+ * Backwards easing in
+ * @method easeInBack
+ * @memberOf fabric.util.ease
+ */
+ function easeInBack(t, b, c, d, s) {
+ if (s === undefined) s = 1.70158;
+ return c*(t/=d)*t*((s+1)*t - s) + b;
+ }
+
+ /**
+ * Backwards easing out
+ * @method easeOutBack
+ * @memberOf fabric.util.ease
+ */
+ function easeOutBack(t, b, c, d, s) {
+ if (s === undefined) s = 1.70158;
+ return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
+ }
+
+ /**
+ * Backwards easing in and out
+ * @method easeInOutBack
+ * @memberOf fabric.util.ease
+ */
+ function easeInOutBack(t, b, c, d, s) {
+ if (s === undefined) s = 1.70158;
+ t /= d/2;
+ if (t < 1) return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b;
+ return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b;
+ }
+
+ /**
+ * Bouncing easing in
+ * @method easeInBounce
+ * @memberOf fabric.util.ease
+ */
+ function easeInBounce(t, b, c, d) {
+ return c - easeOutBounce (d-t, 0, c, d) + b;
+ }
+
+ /**
+ * Bouncing easing out
+ * @method easeOutBounce
+ * @memberOf fabric.util.ease
+ */
+ function easeOutBounce(t, b, c, d) {
+ if ((t/=d) < (1/2.75)) {
+ return c*(7.5625*t*t) + b;
+ } else if (t < (2/2.75)) {
+ return c*(7.5625*(t-=(1.5/2.75))*t + 0.75) + b;
+ } else if (t < (2.5/2.75)) {
+ return c*(7.5625*(t-=(2.25/2.75))*t + 0.9375) + b;
+ } else {
+ return c*(7.5625*(t-=(2.625/2.75))*t + 0.984375) + b;
+ }
+ }
+
+ /**
+ * Bouncing easing in and out
+ * @method easeInOutBounce
+ * @memberOf fabric.util.ease
+ */
+ function easeInOutBounce(t, b, c, d) {
+ if (t < d/2) return easeInBounce (t*2, 0, c, d) * 0.5 + b;
+ return easeOutBounce (t*2-d, 0, c, d) * 0.5 + c*0.5 + b;
+ }
+
+ /**
+ * See Easing Equations by Robert Penner
+ * @namespace fabric.util.ease
+ */
+ fabric.util.ease = {
+ easeInQuad: easeInQuad,
+ easeOutQuad: easeOutQuad,
+ easeInOutQuad: easeInOutQuad,
+ easeInCubic: easeInCubic,
+ easeOutCubic: easeOutCubic,
+ easeInOutCubic: easeInOutCubic,
+ easeInQuart: easeInQuart,
+ easeOutQuart: easeOutQuart,
+ easeInOutQuart: easeInOutQuart,
+ easeInQuint: easeInQuint,
+ easeOutQuint: easeOutQuint,
+ easeInOutQuint: easeInOutQuint,
+ easeInSine: easeInSine,
+ easeOutSine: easeOutSine,
+ easeInOutSine: easeInOutSine,
+ easeInExpo: easeInExpo,
+ easeOutExpo: easeOutExpo,
+ easeInOutExpo: easeInOutExpo,
+ easeInCirc: easeInCirc,
+ easeOutCirc: easeOutCirc,
+ easeInOutCirc: easeInOutCirc,
+ easeInElastic: easeInElastic,
+ easeOutElastic: easeOutElastic,
+ easeInOutElastic: easeInOutElastic,
+ easeInBack: easeInBack,
+ easeOutBack: easeOutBack,
+ easeInOutBack: easeInOutBack,
+ easeInBounce: easeInBounce,
+ easeOutBounce: easeOutBounce,
+ easeInOutBounce: easeInOutBounce
+ };
+
+}());
+(function(global) {
+
+ "use strict";
+
+ /**
+ * @name fabric
+ * @namespace
+ */
+
+ var fabric = global.fabric || (global.fabric = { }),
+ extend = fabric.util.object.extend,
+ capitalize = fabric.util.string.capitalize,
+ clone = fabric.util.object.clone;
+
+ var attributesMap = {
+ 'cx': 'left',
+ 'x': 'left',
+ 'cy': 'top',
+ 'y': 'top',
+ 'r': 'radius',
+ 'fill-opacity': 'opacity',
+ 'fill-rule': 'fillRule',
+ 'stroke-width': 'strokeWidth',
+ 'transform': 'transformMatrix',
+ 'text-decoration': 'textDecoration',
+ 'font-size': 'fontSize',
+ 'font-weight': 'fontWeight',
+ 'font-style': 'fontStyle',
+ 'font-family': 'fontFamily'
+ };
+
+ function normalizeAttr(attr) {
+ // transform attribute names
+ if (attr in attributesMap) {
+ return attributesMap[attr];
+ }
+ return attr;
+ }
+
+ /**
+ * Returns an object of attributes' name/value, given element and an array of attribute names;
+ * Parses parent "g" nodes recursively upwards.
+ * @static
+ * @memberOf fabric
+ * @method parseAttributes
+ * @param {DOMElement} element Element to parse
+ * @param {Array} attributes Array of attributes to parse
+ * @return {Object} object containing parsed attributes' names/values
+ */
+ function parseAttributes(element, attributes) {
+
+ if (!element) {
+ return;
+ }
+
+ var value,
+ parsed,
+ parentAttributes = { };
+
+ // if there's a parent container (`g` node), parse its attributes recursively upwards
+ if (element.parentNode && /^g$/i.test(element.parentNode.nodeName)) {
+ parentAttributes = fabric.parseAttributes(element.parentNode, attributes);
+ }
+
+ var ownAttributes = attributes.reduce(function(memo, attr) {
+ value = element.getAttribute(attr);
+ parsed = parseFloat(value);
+ if (value) {
+ // "normalize" attribute values
+ if ((attr === 'fill' || attr === 'stroke') && value === 'none') {
+ value = '';
+ }
+ if (attr === 'fill-rule') {
+ value = (value === 'evenodd') ? 'destination-over' : value;
+ }
+ if (attr === 'transform') {
+ value = fabric.parseTransformAttribute(value);
+ }
+ attr = normalizeAttr(attr);
+ memo[attr] = isNaN(parsed) ? value : parsed;
+ }
+ return memo;
+ }, { });
+
+ // add values parsed from style, which take precedence over attributes
+ // (see: http://www.w3.org/TR/SVG/styling.html#UsingPresentationAttributes)
+
+ ownAttributes = extend(ownAttributes, extend(getGlobalStylesForElement(element), fabric.parseStyleAttribute(element)));
+ return extend(parentAttributes, ownAttributes);
+ }
+
+ /**
+ * Parses "transform" attribute, returning an array of values
+ * @static
+ * @function
+ * @memberOf fabric
+ * @method parseTransformAttribute
+ * @param attributeValue {String} string containing attribute value
+ * @return {Array} array of 6 elements representing transformation matrix
+ */
+ fabric.parseTransformAttribute = (function() {
+ function rotateMatrix(matrix, args) {
+ var angle = args[0];
+
+ matrix[0] = Math.cos(angle);
+ matrix[1] = Math.sin(angle);
+ matrix[2] = -Math.sin(angle);
+ matrix[3] = Math.cos(angle);
+ }
+
+ function scaleMatrix(matrix, args) {
+ var multiplierX = args[0],
+ multiplierY = (args.length === 2) ? args[1] : args[0];
+
+ matrix[0] = multiplierX;
+ matrix[3] = multiplierY;
+ }
+
+ function skewXMatrix(matrix, args) {
+ matrix[2] = args[0];
+ }
+
+ function skewYMatrix(matrix, args) {
+ matrix[1] = args[0];
+ }
+
+ function translateMatrix(matrix, args) {
+ matrix[4] = args[0];
+ if (args.length === 2) {
+ matrix[5] = args[1];
+ }
+ }
+
+ // identity matrix
+ var iMatrix = [
+ 1, // a
+ 0, // b
+ 0, // c
+ 1, // d
+ 0, // e
+ 0 // f
+ ],
+
+ // == begin transform regexp
+ number = '(?:[-+]?\\d+(?:\\.\\d+)?(?:e[-+]?\\d+)?)',
+ comma_wsp = '(?:\\s+,?\\s*|,\\s*)',
+
+ skewX = '(?:(skewX)\\s*\\(\\s*(' + number + ')\\s*\\))',
+ skewY = '(?:(skewY)\\s*\\(\\s*(' + number + ')\\s*\\))',
+ rotate = '(?:(rotate)\\s*\\(\\s*(' + number + ')(?:' + comma_wsp + '(' + number + ')' + comma_wsp + '(' + number + '))?\\s*\\))',
+ scale = '(?:(scale)\\s*\\(\\s*(' + number + ')(?:' + comma_wsp + '(' + number + '))?\\s*\\))',
+ translate = '(?:(translate)\\s*\\(\\s*(' + number + ')(?:' + comma_wsp + '(' + number + '))?\\s*\\))',
+
+ matrix = '(?:(matrix)\\s*\\(\\s*' +
+ '(' + number + ')' + comma_wsp +
+ '(' + number + ')' + comma_wsp +
+ '(' + number + ')' + comma_wsp +
+ '(' + number + ')' + comma_wsp +
+ '(' + number + ')' + comma_wsp +
+ '(' + number + ')' +
+ '\\s*\\))',
+
+ transform = '(?:' +
+ matrix + '|' +
+ translate + '|' +
+ scale + '|' +
+ rotate + '|' +
+ skewX + '|' +
+ skewY +
+ ')',
+
+ transforms = '(?:' + transform + '(?:' + comma_wsp + transform + ')*' + ')',
+
+ transform_list = '^\\s*(?:' + transforms + '?)\\s*$',
+
+ // http://www.w3.org/TR/SVG/coords.html#TransformAttribute
+ reTransformList = new RegExp(transform_list),
+ // == end transform regexp
+
+ reTransform = new RegExp(transform);
+
+ return function(attributeValue) {
+
+ // start with identity matrix
+ var matrix = iMatrix.concat();
+
+ // return if no argument was given or
+ // an argument does not match transform attribute regexp
+ if (!attributeValue || (attributeValue && !reTransformList.test(attributeValue))) {
+ return matrix;
+ }
+
+ attributeValue.replace(reTransform, function(match) {
+
+ var m = new RegExp(transform).exec(match).filter(function (match) {
+ return (match !== '' && match != null);
+ }),
+ operation = m[1],
+ args = m.slice(2).map(parseFloat);
+
+ switch(operation) {
+ case 'translate':
+ translateMatrix(matrix, args);
+ break;
+ case 'rotate':
+ rotateMatrix(matrix, args);
+ break;
+ case 'scale':
+ scaleMatrix(matrix, args);
+ break;
+ case 'skewX':
+ skewXMatrix(matrix, args);
+ break;
+ case 'skewY':
+ skewYMatrix(matrix, args);
+ break;
+ case 'matrix':
+ matrix = args;
+ break;
+ }
+ });
+ return matrix;
+ };
+ })();
+
+ /**
+ * Parses "points" attribute, returning an array of values
+ * @static
+ * @memberOf fabric
+ * @method parsePointsAttribute
+ * @param points {String} points attribute string
+ * @return {Array} array of points
+ */
+ function parsePointsAttribute(points) {
+
+ // points attribute is required and must not be empty
+ if (!points) return null;
+
+ points = points.trim();
+ var asPairs = points.indexOf(',') > -1;
+
+ points = points.split(/\s+/);
+ var parsedPoints = [ ], i, len;
+
+ // points could look like "10,20 30,40" or "10 20 30 40"
+ if (asPairs) {
+ i = 0;
+ len = points.length;
+ for (; i < len; i++) {
+ var pair = points[i].split(',');
+ parsedPoints.push({ x: parseFloat(pair[0]), y: parseFloat(pair[1]) });
+ }
+ }
+ else {
+ i = 0;
+ len = points.length;
+ for (; i < len; i+=2) {
+ parsedPoints.push({ x: parseFloat(points[i]), y: parseFloat(points[i+1]) });
+ }
+ }
+
+ // odd number of points is an error
+ if (parsedPoints.length % 2 !== 0) {
+ // return null;
+ }
+
+ return parsedPoints;
+ }
+
+ /**
+ * Parses "style" attribute, retuning an object with values
+ * @static
+ * @memberOf fabric
+ * @method parseStyleAttribute
+ * @param {SVGElement} element Element to parse
+ * @return {Object} Objects with values parsed from style attribute of an element
+ */
+ function parseStyleAttribute(element) {
+ var oStyle = { },
+ style = element.getAttribute('style');
+
+ if (!style) return oStyle;
+
+ if (typeof style === 'string') {
+ style = style.replace(/;$/, '').split(';').forEach(function (current) {
+
+ var attr = current.split(':');
+ var value = attr[1].trim();
+ var parsed = parseFloat(value);
+
+ oStyle[normalizeAttr(attr[0].trim().toLowerCase())] = isNaN(parsed) ? value : parsed;
+ });
+ }
+ else {
+ for (var prop in style) {
+ if (typeof style[prop] === 'undefined') continue;
+
+ var parsed = parseFloat(style[prop]);
+ oStyle[normalizeAttr(prop.toLowerCase())] = isNaN(parsed) ? style[prop] : parsed;
+ }
+ }
+
+ return oStyle;
+ }
+
+ function resolveGradients(instances) {
+ for (var i = instances.length; i--; ) {
+ var instanceFillValue = instances[i].get('fill');
+
+ if (/^url\(/.test(instanceFillValue)) {
+
+ var gradientId = instanceFillValue.slice(5, instanceFillValue.length - 1);
+
+ if (fabric.gradientDefs[gradientId]) {
+ instances[i].set('fill',
+ fabric.Gradient.fromElement(fabric.gradientDefs[gradientId], instances[i]));
+ }
+ }
+ }
+ }
+
+ /**
+ * Transforms an array of svg elements to corresponding fabric.* instances
+ * @static
+ * @memberOf fabric
+ * @method parseElements
+ * @param {Array} elements Array of elements to parse
+ * @param {Function} callback Being passed an array of fabric instances (transformed from SVG elements)
+ * @param {Object} [options] Options object
+ * @param {Function} [reviver] Method for further parsing of SVG elements, called after each fabric object created.
+ */
+ function parseElements(elements, callback, options, reviver) {
+ var instances = new Array(elements.length), i = elements.length;
+
+ function checkIfDone() {
+ if (--i === 0) {
+ instances = instances.filter(function(el) {
+ return el != null;
+ });
+ resolveGradients(instances);
+ callback(instances);
+ }
+ }
+
+ for (var index = 0, el, len = elements.length; index < len; index++) {
+ el = elements[index];
+ var klass = fabric[capitalize(el.tagName)];
+ if (klass && klass.fromElement) {
+ try {
+ if (klass.async) {
+ klass.fromElement(el, (function(index, el) {
+ return function(obj) {
+ reviver && reviver(el, obj);
+ instances.splice(index, 0, obj);
+ checkIfDone();
+ };
+ })(index), options);
+ }
+ else {
+ var obj = klass.fromElement(el, options);
+ reviver && reviver(el, obj);
+ instances.splice(index, 0, obj);
+ checkIfDone();
+ }
+ }
+ catch(e) {
+ fabric.log(e.message || e);
+ }
+ }
+ else {
+ checkIfDone();
+ }
+ }
+ }
+
+ /**
+ * Returns CSS rules for a given SVG document
+ * @static
+ * @function
+ * @memberOf fabric
+ * @method getCSSRules
+ * @param {SVGDocument} doc SVG document to parse
+ * @return {Object} CSS rules of this document
+ */
+ function getCSSRules(doc) {
+ var styles = doc.getElementsByTagName('style'),
+ allRules = { },
+ rules;
+
+ // very crude parsing of style contents
+ for (var i = 0, len = styles.length; i < len; i++) {
+ var styleContents = styles[0].textContent;
+
+ // remove comments
+ styleContents = styleContents.replace(/\/\*[\s\S]*?\*\//g, '');
+
+ rules = styleContents.match(/[^{]*\{[\s\S]*?\}/g);
+ rules = rules.map(function(rule) { return rule.trim(); });
+
+ rules.forEach(function(rule) {
+ var match = rule.match(/([\s\S]*?)\s*\{([^}]*)\}/);
+ rule = match[1];
+ var declaration = match[2].trim(),
+ propertyValuePairs = declaration.replace(/;$/, '').split(/\s*;\s*/);
+
+ if (!allRules[rule]) {
+ allRules[rule] = { };
+ }
+
+ for (var i = 0, len = propertyValuePairs.length; i < len; i++) {
+ var pair = propertyValuePairs[i].split(/\s*:\s*/),
+ property = pair[0],
+ value = pair[1];
+
+ allRules[rule][property] = value;
+ }
+ });
+ }
+
+ return allRules;
+ }
+
+ /**
+ * @private
+ */
+ function getGlobalStylesForElement(element) {
+ var nodeName = element.nodeName,
+ className = element.getAttribute('class'),
+ id = element.getAttribute('id'),
+ styles = { };
+
+ for (var rule in fabric.cssRules) {
+ var ruleMatchesElement = (className && new RegExp('^\\.' + className).test(rule)) ||
+ (id && new RegExp('^#' + id).test(rule)) ||
+ (new RegExp('^' + nodeName).test(rule));
+
+ if (ruleMatchesElement) {
+ for (var property in fabric.cssRules[rule]) {
+ styles[property] = fabric.cssRules[rule][property];
+ }
+ }
+ }
+
+ return styles;
+ }
+
+ /**
+ * Parses an SVG document, converts it to an array of corresponding fabric.* instances and passes them to a callback
+ * @static
+ * @function
+ * @memberOf fabric
+ * @method parseSVGDocument
+ * @param {SVGDocument} doc SVG document to parse
+ * @param {Function} callback Callback to call when parsing is finished; It's being passed an array of elements (parsed from a document).
+ * @param {Function} [reviver] Method for further parsing of SVG elements, called after each fabric object created.
+ */
+ fabric.parseSVGDocument = (function() {
+
+ var reAllowedSVGTagNames = /^(path|circle|polygon|polyline|ellipse|rect|line|image|text)$/;
+
+ // http://www.w3.org/TR/SVG/coords.html#ViewBoxAttribute
+ // \d doesn't quite cut it (as we need to match an actual float number)
+
+ // matches, e.g.: +14.56e-12, etc.
+ var reNum = '(?:[-+]?\\d+(?:\\.\\d+)?(?:e[-+]?\\d+)?)';
+
+ var reViewBoxAttrValue = new RegExp(
+ '^' +
+ '\\s*(' + reNum + '+)\\s*,?' +
+ '\\s*(' + reNum + '+)\\s*,?' +
+ '\\s*(' + reNum + '+)\\s*,?' +
+ '\\s*(' + reNum + '+)\\s*' +
+ '$'
+ );
+
+ function hasAncestorWithNodeName(element, nodeName) {
+ while (element && (element = element.parentNode)) {
+ if (nodeName.test(element.nodeName)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ return function(doc, callback, reviver) {
+ if (!doc) return;
+
+ var startTime = new Date(),
+ descendants = fabric.util.toArray(doc.getElementsByTagName('*'));
+
+ if (descendants.length === 0) {
+ // we're likely in node, where "o3-xml" library fails to gEBTN("*")
+ // https://github.com/ajaxorg/node-o3-xml/issues/21
+ descendants = doc.selectNodes("//*[name(.)!='svg']");
+ var arr = [ ];
+ for (var i = 0, len = descendants.length; i < len; i++) {
+ arr[i] = descendants[i];
+ }
+ descendants = arr;
+ }
+
+ var elements = descendants.filter(function(el) {
+ return reAllowedSVGTagNames.test(el.tagName) &&
+ !hasAncestorWithNodeName(el, /^(?:pattern|defs)$/); // http://www.w3.org/TR/SVG/struct.html#DefsElement
+ });
+
+ if (!elements || (elements && !elements.length)) return;
+
+ var viewBoxAttr = doc.getAttribute('viewBox'),
+ widthAttr = doc.getAttribute('width'),
+ heightAttr = doc.getAttribute('height'),
+ width = null,
+ height = null,
+ minX,
+ minY;
+
+ if (viewBoxAttr && (viewBoxAttr = viewBoxAttr.match(reViewBoxAttrValue))) {
+ minX = parseInt(viewBoxAttr[1], 10);
+ minY = parseInt(viewBoxAttr[2], 10);
+ width = parseInt(viewBoxAttr[3], 10);
+ height = parseInt(viewBoxAttr[4], 10);
+ }
+
+ // values of width/height attributes overwrite those extracted from viewbox attribute
+ width = widthAttr ? parseFloat(widthAttr) : width;
+ height = heightAttr ? parseFloat(heightAttr) : height;
+
+ var options = {
+ width: width,
+ height: height
+ };
+
+ fabric.gradientDefs = fabric.getGradientDefs(doc);
+ fabric.cssRules = getCSSRules(doc);
+
+ // Precedence of rules: style > class > attribute
+
+ fabric.parseElements(elements, function(instances) {
+ fabric.documentParsingTime = new Date() - startTime;
+ if (callback) {
+ callback(instances, options);
+ }
+ }, clone(options), reviver);
+ };
+ })();
+
+ /**
+ * Used for caching SVG documents (loaded via `fabric.Canvas#loadSVGFromURL`)
+ * @property
+ * @namespace
+ */
+ var svgCache = {
+
+ /**
+ * @method has
+ * @param {String} name
+ * @param {Function} callback
+ */
+ has: function (name, callback) {
+ callback(false);
+ },
+
+ /**
+ * @method get
+ * @param {String} url
+ * @param {Function} callback
+ */
+ get: function () {
+ /* NOOP */
+ },
+
+ /**
+ * @method set
+ * @param {String} url
+ * @param {Object} object
+ */
+ set: function () {
+ /* NOOP */
+ }
+ };
+
+ /**
+ * Takes url corresponding to an SVG document, and parses it into a set of fabric objects
+ * @method loadSVGFromURL
+ * @memberof fabric
+ * @param {String} url
+ * @param {Function} callback
+ * @param {Function} [reviver] Method for further parsing of SVG elements, called after each fabric object created.
+ */
+ function loadSVGFromURL(url, callback, reviver) {
+
+ url = url.replace(/^\n\s*/, '').trim();
+
+ svgCache.has(url, function (hasUrl) {
+ if (hasUrl) {
+ svgCache.get(url, function (value) {
+ var enlivedRecord = _enlivenCachedObject(value);
+ callback(enlivedRecord.objects, enlivedRecord.options);
+ });
+ }
+ else {
+ new fabric.util.request(url, {
+ method: 'get',
+ onComplete: onComplete
+ });
+ }
+ });
+
+ function onComplete(r) {
+
+ var xml = r.responseXML;
+ if (!xml.documentElement && fabric.window.ActiveXObject && r.responseText) {
+ xml = new ActiveXObject('Microsoft.XMLDOM');
+ xml.async = 'false';
+ //IE chokes on DOCTYPE
+ xml.loadXML(r.responseText.replace(//i,''));
+ }
+ if (!xml.documentElement) return;
+
+ fabric.parseSVGDocument(xml.documentElement, function (results, options) {
+ svgCache.set(url, {
+ objects: fabric.util.array.invoke(results, 'toObject'),
+ options: options
+ });
+ callback(results, options);
+ }, reviver);
+ }
+ }
+
+ /**
+ * @method _enlivenCachedObject
+ */
+ function _enlivenCachedObject(cachedObject) {
+
+ var objects = cachedObject.objects,
+ options = cachedObject.options;
+
+ objects = objects.map(function (o) {
+ return fabric[capitalize(o.type)].fromObject(o);
+ });
+
+ return ({ objects: objects, options: options });
+ }
+
+ /**
+ * Takes string corresponding to an SVG document, and parses it into a set of fabric objects
+ * @method loadSVGFromString
+ * @memberof fabric
+ * @param {String} string
+ * @param {Function} callback
+ * @param {Function} [reviver] Method for further parsing of SVG elements, called after each fabric object created.
+ */
+ function loadSVGFromString(string, callback, reviver) {
+ string = string.trim();
+ var doc;
+ if (typeof DOMParser !== 'undefined') {
+ var parser = new DOMParser();
+ if (parser && parser.parseFromString) {
+ doc = parser.parseFromString(string, 'text/xml');
+ }
+ }
+ else if (fabric.window.ActiveXObject) {
+ doc = new ActiveXObject('Microsoft.XMLDOM');
+ doc.async = 'false';
+ //IE chokes on DOCTYPE
+ doc.loadXML(string.replace(//i,''));
+ }
+
+ fabric.parseSVGDocument(doc.documentElement, function (results, options) {
+ callback(results, options);
+ }, reviver);
+ }
+
+ /**
+ * Creates markup containing SVG font faces
+ * @method createSVGFontFacesMarkup
+ * @param {Array} objects Array of fabric objects
+ * @return {String}
+ */
+ function createSVGFontFacesMarkup(objects) {
+ var markup = '';
+
+ for (var i = 0, len = objects.length; i < len; i++) {
+ if (objects[i].type !== 'text' || !objects[i].path) continue;
+
+ markup += [
+ '@font-face {',
+ 'font-family: ', objects[i].fontFamily, '; ',
+ 'src: url(\'', objects[i].path, '\')',
+ '}'
+ ].join('');
+ }
+
+ if (markup) {
+ markup = [
+ '',
+ '',
+ ''
+ ].join('');
+ }
+
+ return markup;
+ }
+
+ extend(fabric, {
+
+ parseAttributes: parseAttributes,
+ parseElements: parseElements,
+ parseStyleAttribute: parseStyleAttribute,
+ parsePointsAttribute: parsePointsAttribute,
+ getCSSRules: getCSSRules,
+
+ loadSVGFromURL: loadSVGFromURL,
+ loadSVGFromString: loadSVGFromString,
+
+ createSVGFontFacesMarkup: createSVGFontFacesMarkup
+ });
+
+})(typeof exports !== 'undefined' ? exports : this);
+
+(function() {
+
+ function getColorStopFromStyle(el) {
+ var style = el.getAttribute('style');
+
+ if (style) {
+ var keyValuePairs = style.split(/\s*;\s*/);
+
+ if (keyValuePairs[keyValuePairs.length-1] === '') {
+ keyValuePairs.pop();
+ }
+
+ for (var i = keyValuePairs.length; i--; ) {
+
+ var split = keyValuePairs[i].split(/\s*:\s*/),
+ key = split[0].trim(),
+ value = split[1].trim();
+
+ if (key === 'stop-color') {
+ return value;
+ }
+ }
+ }
+ }
+
+ /**
+ * Gradient class
+ * @class Gradient
+ * @memberOf fabric
+ */
+ fabric.Gradient = fabric.util.createClass(/** @scope fabric.Gradient.prototype */ {
+
+ /**
+ * Constructor
+ * @method initialize
+ * @param [options] Options object with x1, y1, x2, y2 and colorStops
+ * @return {fabric.Gradient} thisArg
+ */
+ initialize: function(options) {
+
+ options || (options = { });
+
+ this.x1 = options.x1 || 0;
+ this.y1 = options.y1 || 0;
+ this.x2 = options.x2 || 0;
+ this.y2 = options.y2 || 0;
+
+ this.colorStops = options.colorStops;
+ },
+
+ /**
+ * Returns object representation of a gradient
+ * @method toObject
+ * @return {Object}
+ */
+ toObject: function() {
+ return {
+ x1: this.x1,
+ x2: this.x2,
+ y1: this.y1,
+ y2: this.y2,
+ colorStops: this.colorStops
+ };
+ },
+
+ /**
+ * Returns an instance of CanvasGradient
+ * @method toLiveGradient
+ * @param ctx
+ * @return {CanvasGradient}
+ */
+ toLiveGradient: function(ctx) {
+ var gradient = ctx.createLinearGradient(
+ this.x1, this.y1, this.x2 || ctx.canvas.width, this.y2);
+
+ for (var position in this.colorStops) {
+ var colorValue = this.colorStops[position];
+ gradient.addColorStop(parseFloat(position), colorValue);
+ }
+
+ return gradient;
+ }
+ });
+
+ fabric.util.object.extend(fabric.Gradient, {
+
+ /**
+ * Returns {@link fabric.Gradient} instance from an SVG element
+ * @method fromElement
+ * @static
+ * @memberof fabric.Gradient
+ * @see http://www.w3.org/TR/SVG/pservers.html#LinearGradientElement
+ */
+ fromElement: function(el, instance) {
+
+ /**
+ * @example:
+ *
+ *
+ *
+ *
+ *
+ *
+ * OR
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+ var colorStopEls = el.getElementsByTagName('stop'),
+ offset,
+ colorStops = { },
+ coords = {
+ x1: el.getAttribute('x1') || 0,
+ y1: el.getAttribute('y1') || 0,
+ x2: el.getAttribute('x2') || '100%',
+ y2: el.getAttribute('y2') || 0
+ };
+
+ for (var i = colorStopEls.length; i--; ) {
+ el = colorStopEls[i];
+ offset = el.getAttribute('offset');
+
+ // convert percents to absolute values
+ offset = parseFloat(offset) / (/%$/.test(offset) ? 100 : 1);
+ colorStops[offset] = getColorStopFromStyle(el) || el.getAttribute('stop-color');
+ }
+
+ _convertPercentUnitsToValues(instance, coords);
+
+ return new fabric.Gradient({
+ x1: coords.x1,
+ y1: coords.y1,
+ x2: coords.x2,
+ y2: coords.y2,
+ colorStops: colorStops
+ });
+ },
+
+ /**
+ * Returns {@link fabric.Gradient} instance from its object representation
+ * @method forObject
+ * @static
+ * @param obj
+ * @param [options]
+ * @memberof fabric.Gradient
+ */
+ forObject: function(obj, options) {
+ options || (options = { });
+ _convertPercentUnitsToValues(obj, options);
+ return new fabric.Gradient(options);
+ }
+ });
+
+ function _convertPercentUnitsToValues(object, options) {
+ for (var prop in options) {
+ if (typeof options[prop] === 'string' && /^\d+%$/.test(options[prop])) {
+ var percents = parseFloat(options[prop], 10);
+ if (prop === 'x1' || prop === 'x2') {
+ options[prop] = object.width * percents / 100;
+ }
+ else if (prop === 'y1' || prop === 'y2') {
+ options[prop] = object.height * percents / 100;
+ }
+ }
+ // normalize rendering point (should be from top/left corner rather than center of the shape)
+ if (prop === 'x1' || prop === 'x2') {
+ options[prop] -= object.width / 2;
+ }
+ else if (prop === 'y1' || prop === 'y2') {
+ options[prop] -= object.height / 2;
+ }
+ }
+ }
+
+ /**
+ * Parses an SVG document, returning all of the gradient declarations found in it
+ * @static
+ * @function
+ * @memberOf fabric
+ * @method getGradientDefs
+ * @param {SVGDocument} doc SVG document to parse
+ * @return {Object} Gradient definitions; key corresponds to element id, value -- to gradient definition element
+ */
+ function getGradientDefs(doc) {
+ var linearGradientEls = doc.getElementsByTagName('linearGradient'),
+ radialGradientEls = doc.getElementsByTagName('radialGradient'),
+ el, i,
+ gradientDefs = { };
+
+ i = linearGradientEls.length;
+ for (; i--; ) {
+ el = linearGradientEls[i];
+ gradientDefs[el.getAttribute('id')] = el;
+ }
+
+ i = radialGradientEls.length;
+ for (; i--; ) {
+ el = radialGradientEls[i];
+ gradientDefs[el.getAttribute('id')] = el;
+ }
+
+ return gradientDefs;
+ }
+
+ fabric.getGradientDefs = getGradientDefs;
+
+})();
+(function(global) {
+
+ "use strict";
+
+ /* Adaptation of work of Kevin Lindsey (kevin@kevlindev.com) */
+
+ var fabric = global.fabric || (global.fabric = { });
+
+ if (fabric.Point) {
+ fabric.warn('fabric.Point is already defined');
+ return;
+ }
+
+ fabric.Point = Point;
+
+ /**
+ * Point class
+ * @name Point
+ * @memberOf fabric
+ * @constructor
+ * @param {Number} x
+ * @param {Number} y
+ * @return {fabric.Point} thisArg
+ */
+ function Point(x, y) {
+ if (arguments.length > 0) {
+ this.init(x, y);
+ }
+ }
+
+ Point.prototype = /** @scope fabric.Point.prototype */ {
+
+ constructor: Point,
+
+ /**
+ * Constructor
+ * @method init
+ * @param {Number} x left offset
+ * @param {Number} y top offset
+ */
+ init: function (x, y) {
+ this.x = x;
+ this.y = y;
+ },
+
+ /**
+ * Adds another point to this one and returns another one
+ * @method add
+ * @param {fabric.Point} that
+ * @return {fabric.Point} new Point instance with added values
+ */
+ add: function (that) {
+ return new Point(this.x + that.x, this.y + that.y);
+ },
+
+ /**
+ * Adds another point to this one
+ * @method addEquals
+ * @param {fabric.Point} that
+ * @return {fabric.Point} thisArg
+ */
+ addEquals: function (that) {
+ this.x += that.x;
+ this.y += that.y;
+ return this;
+ },
+
+ /**
+ * Adds value to this point and returns a new one
+ * @method scalarAdd
+ * @param {Number} scalar
+ * @return {fabric.Point} new Point with added value
+ */
+ scalarAdd: function (scalar) {
+ return new Point(this.x + scalar, this.y + scalar);
+ },
+
+ /**
+ * Adds value to this point
+ * @method scalarAddEquals
+ * @param {Number} scalar
+ * @param {fabric.Point} thisArg
+ */
+ scalarAddEquals: function (scalar) {
+ this.x += scalar;
+ this.y += scalar;
+ return this;
+ },
+
+ /**
+ * Subtracts another point from this point and returns a new one
+ * @method subtract
+ * @param {fabric.Point} that
+ * @return {fabric.Point} new Point object with subtracted values
+ */
+ subtract: function (that) {
+ return new Point(this.x - that.x, this.y - that.y);
+ },
+
+ /**
+ * Subtracts another point from this point
+ * @method subtractEquals
+ * @param {fabric.Point} that
+ * @return {fabric.Point} thisArg
+ */
+ subtractEquals: function (that) {
+ this.x -= that.x;
+ this.y -= that.y;
+ return this;
+ },
+
+ /**
+ * Subtracts value from this point and returns a new one
+ * @method scalarSubtract
+ * @param {Number} scalar
+ * @return {fabric.Point}
+ */
+ scalarSubtract: function (scalar) {
+ return new Point(this.x - scalar, this.y - scalar);
+ },
+
+ /**
+ * Subtracts value from this point
+ * @method scalarSubtractEquals
+ * @param {Number} scalar
+ * @return {fabric.Point} thisArg
+ */
+ scalarSubtractEquals: function (scalar) {
+ this.x -= scalar;
+ this.y -= scalar;
+ return this;
+ },
+
+ /**
+ * Miltiplies this point by a value and returns a new one
+ * @method multiply
+ * @param {Number} scalar
+ * @return {fabric.Point}
+ */
+ multiply: function (scalar) {
+ return new Point(this.x * scalar, this.y * scalar);
+ },
+
+ /**
+ * Miltiplies this point by a value
+ * @method multiplyEquals
+ * @param {Number} scalar
+ * @return {fabric.Point} thisArg
+ */
+ multiplyEquals: function (scalar) {
+ this.x *= scalar;
+ this.y *= scalar;
+ return this;
+ },
+
+ /**
+ * Divides this point by a value and returns a new one
+ * @method divide
+ * @param {Number} scalar
+ * @return {fabric.Point}
+ */
+ divide: function (scalar) {
+ return new Point(this.x / scalar, this.y / scalar);
+ },
+
+ /**
+ * Divides this point by a value
+ * @method divideEquals
+ * @param {Number} scalar
+ * @return {fabric.Point} thisArg
+ */
+ divideEquals: function (scalar) {
+ this.x /= scalar;
+ this.y /= scalar;
+ return this;
+ },
+
+ /**
+ * Returns true if this point is equal to another one
+ * @method eq
+ * @param {fabric.Point} that
+ * @return {Boolean}
+ */
+ eq: function (that) {
+ return (this.x === that.x && this.y === that.y);
+ },
+
+ /**
+ * Returns true if this point is less than another one
+ * @method lt
+ * @param {fabric.Point} that
+ * @return {Boolean}
+ */
+ lt: function (that) {
+ return (this.x < that.x && this.y < that.y);
+ },
+
+ /**
+ * Returns true if this point is less than or equal to another one
+ * @method lte
+ * @param {fabric.Point} that
+ * @return {Boolean}
+ */
+ lte: function (that) {
+ return (this.x <= that.x && this.y <= that.y);
+ },
+
+ /**
+ * Returns true if this point is greater another one
+ * @method gt
+ * @param {fabric.Point} that
+ * @return {Boolean}
+ */
+ gt: function (that) {
+ return (this.x > that.x && this.y > that.y);
+ },
+
+ /**
+ * Returns true if this point is greater than or equal to another one
+ * @method gte
+ * @param {fabric.Point} that
+ * @return {Boolean}
+ */
+ gte: function (that) {
+ return (this.x >= that.x && this.y >= that.y);
+ },
+
+ /**
+ * Returns new point which is the result of linear interpolation with this one and another one
+ * @method lerp
+ * @param {fabric.Point} that
+ * @param {Number} t
+ * @return {fabric.Point}
+ */
+ lerp: function (that, t) {
+ return new Point(this.x + (that.x - this.x) * t, this.y + (that.y - this.y) * t);
+ },
+
+ /**
+ * Returns distance from this point and another one
+ * @method distanceFrom
+ * @param {fabric.Point} that
+ * @return {Number}
+ */
+ distanceFrom: function (that) {
+ var dx = this.x - that.x,
+ dy = this.y - that.y;
+ return Math.sqrt(dx * dx + dy * dy);
+ },
+
+ /**
+ * Returns the point between this point and another one
+ * @method midPointFrom
+ * @param {fabric.Point} that
+ * @return {fabric.Point}
+ */
+ midPointFrom: function (that) {
+ return new Point(this.x + (that.x - this.x)/2, this.y + (that.y - this.y)/2);
+ },
+
+ /**
+ * Returns a new point which is the min of this and another one
+ * @method min
+ * @param {fabric.Point} that
+ * @return {fabric.Point}
+ */
+ min: function (that) {
+ return new Point(Math.min(this.x, that.x), Math.min(this.y, that.y));
+ },
+
+ /**
+ * Returns a new point which is the max of this and another one
+ * @method max
+ * @param {fabric.Point} that
+ * @return {fabric.Point}
+ */
+ max: function (that) {
+ return new Point(Math.max(this.x, that.x), Math.max(this.y, that.y));
+ },
+
+ /**
+ * Returns string representation of this point
+ * @method toString
+ * @return {String}
+ */
+ toString: function () {
+ return this.x + "," + this.y;
+ },
+
+ /**
+ * Sets x/y of this point
+ * @method setXY
+ * @param {Number} x
+ * @return {Number} y
+ */
+ setXY: function (x, y) {
+ this.x = x;
+ this.y = y;
+ },
+
+ /**
+ * Sets x/y of this point from another point
+ * @method setFromPoint
+ * @param {fabric.Point} that
+ */
+ setFromPoint: function (that) {
+ this.x = that.x;
+ this.y = that.y;
+ },
+
+ /**
+ * Swaps x/y of this point and another point
+ * @method setFromPoint
+ * @param {fabric.Point} that
+ */
+ swap: function (that) {
+ var x = this.x,
+ y = this.y;
+ this.x = that.x;
+ this.y = that.y;
+ that.x = x;
+ that.y = y;
+ }
+ };
+
+})(typeof exports !== 'undefined' ? exports : this);
+
+(function(global) {
+
+ "use strict";
+
+ /* Adaptation of work of Kevin Lindsey (kevin@kevlindev.com) */
+
+ var fabric = global.fabric || (global.fabric = { });
+
+ if (fabric.Intersection) {
+ fabric.warn('fabric.Intersection is already defined');
+ return;
+ }
+
+ /**
+ * Intersection class
+ * @class Intersection
+ * @memberOf fabric
+ */
+ function Intersection(status) {
+ if (arguments.length > 0) {
+ this.init(status);
+ }
+ }
+
+ fabric.Intersection = Intersection;
+
+ fabric.Intersection.prototype = /** @scope fabric.Intersection.prototype */ {
+
+ /**
+ * Constructor
+ * @method init
+ * @param {String} status
+ */
+ init: function (status) {
+ this.status = status;
+ this.points = [];
+ },
+
+ /**
+ * Appends a point to intersection
+ * @method appendPoint
+ * @param {fabric.Point} point
+ */
+ appendPoint: function (point) {
+ this.points.push(point);
+ },
+
+ /**
+ * Appends points to intersection
+ * @method appendPoints
+ * @param {Array} points
+ */
+ appendPoints: function (points) {
+ this.points = this.points.concat(points);
+ }
+ };
+
+ /**
+ * Checks if one line intersects another
+ * @static
+ * @method intersectLineLine
+ * @param {fabric.Point} a1
+ * @param {fabric.Point} a2
+ * @param {fabric.Point} b1
+ * @param {fabric.Point} b2
+ * @return {fabric.Intersection}
+ */
+ fabric.Intersection.intersectLineLine = function (a1, a2, b1, b2) {
+ var result,
+ ua_t = (b2.x - b1.x) * (a1.y - b1.y) - (b2.y - b1.y) * (a1.x - b1.x),
+ ub_t = (a2.x - a1.x) * (a1.y - b1.y) - (a2.y - a1.y) * (a1.x - b1.x),
+ u_b = (b2.y - b1.y) * (a2.x - a1.x) - (b2.x - b1.x) * (a2.y - a1.y);
+ if (u_b !== 0) {
+ var ua = ua_t / u_b,
+ ub = ub_t / u_b;
+ if (0 <= ua && ua <= 1 && 0 <= ub && ub <= 1) {
+ result = new Intersection("Intersection");
+ result.points.push(new fabric.Point(a1.x + ua * (a2.x - a1.x), a1.y + ua * (a2.y - a1.y)));
+ }
+ else {
+ result = new Intersection("No Intersection");
+ }
+ }
+ else {
+ if (ua_t === 0 || ub_t === 0) {
+ result = new Intersection("Coincident");
+ }
+ else {
+ result = new Intersection("Parallel");
+ }
+ }
+ return result;
+ };
+
+ /**
+ * Checks if line intersects polygon
+ * @method intersectLinePolygon
+ * @static
+ * @param {fabric.Point} a1
+ * @param {fabric.Point} a2
+ * @param {Array} points
+ * @return {fabric.Intersection}
+ */
+ fabric.Intersection.intersectLinePolygon = function(a1,a2,points){
+ var result = new Intersection("No Intersection"),
+ length = points.length;
+
+ for (var i = 0; i < length; i++) {
+ var b1 = points[i],
+ b2 = points[(i+1) % length],
+ inter = Intersection.intersectLineLine(a1, a2, b1, b2);
+
+ result.appendPoints(inter.points);
+ }
+ if (result.points.length > 0) {
+ result.status = "Intersection";
+ }
+ return result;
+ };
+
+ /**
+ * Checks if polygon intersects another polygon
+ * @method intersectPolygonPolygon
+ * @static
+ * @param {Array} points1
+ * @param {Array} points2
+ * @return {fabric.Intersection}
+ */
+ fabric.Intersection.intersectPolygonPolygon = function (points1, points2) {
+ var result = new Intersection("No Intersection"),
+ length = points1.length;
+
+ for (var i = 0; i < length; i++) {
+ var a1 = points1[i],
+ a2 = points1[(i+1) % length],
+ inter = Intersection.intersectLinePolygon(a1, a2, points2);
+
+ result.appendPoints(inter.points);
+ }
+ if (result.points.length > 0) {
+ result.status = "Intersection";
+ }
+ return result;
+ };
+
+ /**
+ * Checks if polygon intersects rectangle
+ * @method intersectPolygonRectangle
+
+ * @static
+ * @param {Array} points
+ * @param {Number} r1
+ * @param {Number} r2
+ * @return {fabric.Intersection}
+ */
+ fabric.Intersection.intersectPolygonRectangle = function (points, r1, r2) {
+ var min = r1.min(r2),
+ max = r1.max(r2),
+ topRight = new fabric.Point(max.x, min.y),
+ bottomLeft = new fabric.Point(min.x, max.y),
+ inter1 = Intersection.intersectLinePolygon(min, topRight, points),
+ inter2 = Intersection.intersectLinePolygon(topRight, max, points),
+ inter3 = Intersection.intersectLinePolygon(max, bottomLeft, points),
+ inter4 = Intersection.intersectLinePolygon(bottomLeft, min, points),
+ result = new Intersection("No Intersection");
+
+ result.appendPoints(inter1.points);
+ result.appendPoints(inter2.points);
+ result.appendPoints(inter3.points);
+ result.appendPoints(inter4.points);
+
+ if (result.points.length > 0) {
+ result.status = "Intersection";
+ }
+ return result;
+ };
+
+})(typeof exports !== 'undefined' ? exports : this);
+(function(global) {
+
+ "use strict";
+
+ var fabric = global.fabric || (global.fabric = { });
+
+ if (fabric.Color) {
+ fabric.warn('fabric.Color is already defined.');
+ return;
+ }
+
+ /**
+ * Color class
+ * The purpose of {@link fabric.Color} is to abstract and encapsulate common color operations;
+ * {@link fabric.Color} is a constructor and creates instances of {@link fabric.Color} objects.
+ *
+ * @class Color
+ * @memberOf fabric
+ * @param {String} color optional in hex or rgb(a) format
+ * @return {fabric.Color} thisArg
+ */
+ function Color(color) {
+ if (!color) {
+ this.setSource([0, 0, 0, 1]);
+ }
+ else {
+ this._tryParsingColor(color);
+ }
+ }
+
+ fabric.Color = Color;
+
+ fabric.Color.prototype = /** @scope fabric.Color.prototype */ {
+
+ /**
+ * @private
+ * @method _tryParsingColor
+ */
+ _tryParsingColor: function(color) {
+ var source = Color.sourceFromHex(color);
+ if (!source) {
+ source = Color.sourceFromRgb(color);
+ }
+ if (source) {
+ this.setSource(source);
+ }
+ },
+
+ /**
+ * Returns source of this color (where source is an array representation; ex: [200, 200, 100, 1])
+ * @method getSource
+ * @return {Array}
+ */
+ getSource: function() {
+ return this._source;
+ },
+
+ /**
+ * Sets source of this color (where source is an array representation; ex: [200, 200, 100, 1])
+ * @method setSource
+ * @param {Array} source
+ */
+ setSource: function(source) {
+ this._source = source;
+ },
+
+ /**
+ * Returns color represenation in RGB format
+ * @method toRgb
+ * @return {String} ex: rgb(0-255,0-255,0-255)
+ */
+ toRgb: function() {
+ var source = this.getSource();
+ return 'rgb(' + source[0] + ',' + source[1] + ',' + source[2] + ')';
+ },
+
+ /**
+ * Returns color represenation in RGBA format
+ * @method toRgba
+ * @return {String} ex: rgba(0-255,0-255,0-255,0-1)
+ */
+ toRgba: function() {
+ var source = this.getSource();
+ return 'rgba(' + source[0] + ',' + source[1] + ',' + source[2] + ',' + source[3] + ')';
+ },
+
+ /**
+ * Returns color represenation in HEX format
+ * @method toHex
+ * @return {String} ex: FF5555
+ */
+ toHex: function() {
+ var source = this.getSource();
+
+ var r = source[0].toString(16);
+ r = (r.length === 1) ? ('0' + r) : r;
+
+ var g = source[1].toString(16);
+ g = (g.length === 1) ? ('0' + g) : g;
+
+ var b = source[2].toString(16);
+ b = (b.length === 1) ? ('0' + b) : b;
+
+ return r.toUpperCase() + g.toUpperCase() + b.toUpperCase();
+ },
+
+ /**
+ * Gets value of alpha channel for this color
+ * @method getAlpha
+ * @return {Number} 0-1
+ */
+ getAlpha: function() {
+ return this.getSource()[3];
+ },
+
+ /**
+ * Sets value of alpha channel for this color
+ * @method setAlpha
+ * @param {Number} 0-1
+ * @return {fabric.Color} thisArg
+ */
+ setAlpha: function(alpha) {
+ var source = this.getSource();
+ source[3] = alpha;
+ this.setSource(source);
+ return this;
+ },
+
+ /**
+ * Transforms color to its grayscale representation
+ * @method toGrayscale
+ * @return {fabric.Color} thisArg
+ */
+ toGrayscale: function() {
+ var source = this.getSource(),
+ average = parseInt((source[0] * 0.3 + source[1] * 0.59 + source[2] * 0.11).toFixed(0), 10),
+ currentAlpha = source[3];
+ this.setSource([average, average, average, currentAlpha]);
+ return this;
+ },
+
+ /**
+ * Transforms color to its black and white representation
+ * @method toGrayscale
+ * @return {fabric.Color} thisArg
+ */
+ toBlackWhite: function(threshold) {
+ var source = this.getSource(),
+ average = (source[0] * 0.3 + source[1] * 0.59 + source[2] * 0.11).toFixed(0),
+ currentAlpha = source[3];
+
+ threshold = threshold || 127;
+
+ average = (Number(average) < Number(threshold)) ? 0 : 255;
+ this.setSource([average, average, average, currentAlpha]);
+ return this;
+ },
+
+ /**
+ * Overlays color with another color
+ * @method overlayWith
+ * @param {String|fabric.Color} otherColor
+ * @return {fabric.Color} thisArg
+ */
+ overlayWith: function(otherColor) {
+ if (!(otherColor instanceof Color)) {
+ otherColor = new Color(otherColor);
+ }
+
+ var result = [],
+ alpha = this.getAlpha(),
+ otherAlpha = 0.5,
+ source = this.getSource(),
+ otherSource = otherColor.getSource();
+
+ for (var i = 0; i < 3; i++) {
+ result.push(Math.round((source[i] * (1 - otherAlpha)) + (otherSource[i] * otherAlpha)));
+ }
+
+ result[3] = alpha;
+ this.setSource(result);
+ return this;
+ }
+ };
+
+ /**
+ * Regex matching color in RGB or RGBA formats (ex: rgb(0, 0, 0), rgb(255, 100, 10, 0.5), rgb(1,1,1))
+ * @static
+ * @field
+ */
+ fabric.Color.reRGBa = /^rgba?\((\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})(?:\s*,\s*(\d+(?:\.\d+)?))?\)$/;
+
+ /**
+ * Regex matching color in HEX format (ex: #FF5555, 010155, aff)
+ * @static
+ * @field
+ */
+ fabric.Color.reHex = /^#?([0-9a-f]{6}|[0-9a-f]{3})$/i;
+
+ /**
+ * Returns new color object, when given a color in RGB format
+ * @method fromRgb
+ * @param {String} color ex: rgb(0-255,0-255,0-255)
+ * @return {fabric.Color}
+ */
+ fabric.Color.fromRgb = function(color) {
+ return Color.fromSource(Color.sourceFromRgb(color));
+ };
+
+ /**
+ * Returns array represenatation (ex: [100, 100, 200, 1]) of a color that's in RGB or RGBA format
+ * @method sourceFromRgb
+ * @param {String} color ex: rgb(0-255,0-255,0-255)
+ * @return {Array} source
+ */
+ fabric.Color.sourceFromRgb = function(color) {
+ var match = color.match(Color.reRGBa);
+ if (match) {
+ return [
+ parseInt(match[1], 10),
+ parseInt(match[2], 10),
+ parseInt(match[3], 10),
+ match[4] ? parseFloat(match[4]) : 1
+ ];
+ }
+ };
+
+ /**
+ * Returns new color object, when given a color in RGBA format
+ * @static
+ * @function
+ * @method fromRgba
+ * @param {String} color
+ * @return {fabric.Color}
+ */
+ fabric.Color.fromRgba = Color.fromRgb;
+
+ /**
+ * Returns new color object, when given a color in HEX format
+ * @static
+ * @method fromHex
+ * @return {fabric.Color}
+ */
+ fabric.Color.fromHex = function(color) {
+ return Color.fromSource(Color.sourceFromHex(color));
+ };
+
+ /**
+ * Returns array represenatation (ex: [100, 100, 200, 1]) of a color that's in HEX format
+ * @static
+ * @method sourceFromHex
+ * @param {String} color ex: FF5555
+ * @return {Array} source
+ */
+ fabric.Color.sourceFromHex = function(color) {
+ if (color.match(Color.reHex)) {
+ var value = color.slice(color.indexOf('#') + 1),
+ isShortNotation = (value.length === 3),
+ r = isShortNotation ? (value.charAt(0) + value.charAt(0)) : value.substring(0, 2),
+ g = isShortNotation ? (value.charAt(1) + value.charAt(1)) : value.substring(2, 4),
+ b = isShortNotation ? (value.charAt(2) + value.charAt(2)) : value.substring(4, 6);
+
+ return [
+ parseInt(r, 16),
+ parseInt(g, 16),
+ parseInt(b, 16),
+ 1
+ ];
+ }
+ };
+
+ /**
+ * Returns new color object, when given color in array representation (ex: [200, 100, 100, 0.5])
+ * @static
+ * @method fromSource
+ * @return {fabric.Color}
+ */
+ fabric.Color.fromSource = function(source) {
+ var oColor = new Color();
+ oColor.setSource(source);
+ return oColor;
+ };
+
+})(typeof exports !== 'undefined' ? exports : this);
+(function () {
+
+ "use strict";
+
+ if (fabric.StaticCanvas) {
+ fabric.warn('fabric.StaticCanvas is already defined.');
+ return;
+ }
+
+ // aliases for faster resolution
+ var extend = fabric.util.object.extend,
+ getElementOffset = fabric.util.getElementOffset,
+ removeFromArray = fabric.util.removeFromArray,
+ removeListener = fabric.util.removeListener,
+
+ CANVAS_INIT_ERROR = new Error('Could not initialize `canvas` element');
+
+ /**
+ * Static canvas class
+ * @class fabric.StaticCanvas
+ * @constructor
+ * @param {HTMLElement | String} el <canvas> element to initialize instance on
+ * @param {Object} [options] Options object
+ */
+ fabric.StaticCanvas = function (el, options) {
+ options || (options = { });
+
+ this._initStatic(el, options);
+ fabric.StaticCanvas.activeInstance = this;
+ };
+
+ extend(fabric.StaticCanvas.prototype, fabric.Observable);
+
+ extend(fabric.StaticCanvas.prototype, /** @scope fabric.StaticCanvas.prototype */ {
+
+ /**
+ * Background color of canvas instance
+ * @property
+ * @type String
+ */
+ backgroundColor: 'rgba(0, 0, 0, 0)',
+
+ /**
+ * Background image of canvas instance
+ * Should be set via `setBackgroundImage`
+ * @property
+ * @type String
+ */
+ backgroundImage: '',
+
+ /**
+ * Opacity of the background image of the canvas instance
+ * @property
+ * @type Float
+ */
+ backgroundImageOpacity: 1.0,
+
+ /**
+ * Indicates whether the background image should be stretched to fit the
+ * dimensions of the canvas instance.
+ * @property
+ * @type Boolean
+ */
+ backgroundImageStretch: true,
+
+ /**
+ * Overlay image of canvas instance
+ * Should be set via `setOverlayImage`
+ * @property
+ * @type String
+ */
+ overlayImage: '',
+
+ /**
+ * Left offset of overlay image (if present)
+ * @property
+ * @type Number
+ */
+ overlayImageLeft: 0,
+
+ /**
+ * Top offset of overlay image (if present)
+ * @property
+ * @type Number
+ */
+ overlayImageTop: 0,
+
+ /**
+ * Indicates whether toObject/toDatalessObject should include default values
+ * @property
+ * @type Boolean
+ */
+ includeDefaultValues: true,
+
+ /**
+ * Indicates whether objects' state should be saved
+ * @property
+ * @type Boolean
+ */
+ stateful: true,
+
+ /**
+ * Indicates whether {@link fabric.Canvas.prototype.add} should also re-render canvas.
+ * Disabling this option could give a great performance boost when adding a lot of objects to canvas at once
+ * (followed by a manual rendering after addition)
+ * @property
+ * @type Boolean
+ */
+ renderOnAddition: true,
+
+ /**
+ * Function that determines clipping of entire canvas area
+ * Being passed context as first argument. See clipping canvas area in https://github.com/kangax/fabric.js/wiki/FAQ
+ * @property
+ * @type Function
+ */
+ clipTo: null,
+
+ /**
+ * Indicates whether object controls (borders/corners) are rendered above overlay image
+ * @property
+ * @type Boolean
+ */
+ controlsAboveOverlay: false,
+
+ /**
+ * Callback; invoked right before object is about to be scaled/rotated
+ * @method onBeforeScaleRotate
+ * @param {fabric.Object} target Object that's about to be scaled/rotated
+ */
+ onBeforeScaleRotate: function () {
+ /* NOOP */
+ },
+
+ /**
+ * @method _initStatic
+ * @private
+ */
+ _initStatic: function(el, options) {
+ this._objects = [];
+
+ this._createLowerCanvas(el);
+ this._initOptions(options);
+
+ if (options.overlayImage) {
+ this.setOverlayImage(options.overlayImage, this.renderAll.bind(this));
+ }
+ if (options.backgroundImage) {
+ this.setBackgroundImage(options.backgroundImage, this.renderAll.bind(this));
+ }
+ this.calcOffset();
+ },
+
+ /**
+ * Calculates canvas element offset relative to the document
+ * This method is also attached as "resize" event handler of window
+ * @method calcOffset
+ * @return {fabric.Canvas} instance
+ * @chainable
+ */
+ calcOffset: function () {
+ this._offset = getElementOffset(this.lowerCanvasEl);
+ return this;
+ },
+
+ /**
+ * Sets overlay image for this canvas
+ * @method setOverlayImage
+ * @param {String} url url of an image to set overlay to
+ * @param {Function} callback callback to invoke when image is loaded and set as an overlay
+ * @param {Object} [options] optional options to set for the overlay image
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ setOverlayImage: function (url, callback, options) { // TODO (kangax): test callback
+ fabric.util.loadImage(url, function(img) {
+ this.overlayImage = img;
+ if (options && ('overlayImageLeft' in options)) {
+ this.overlayImageLeft = options.overlayImageLeft;
+ }
+ if (options && ('overlayImageTop' in options)) {
+ this.overlayImageTop = options.overlayImageTop;
+ }
+ callback && callback();
+ }, this);
+
+ return this;
+ },
+
+ /**
+ * Sets background image for this canvas
+ * @method setBackgroundImage
+ * @param {String} url url of an image to set background to
+ * @param {Function} callback callback to invoke when image is loaded and set as background
+ * @param {Object} [options] optional options to set for the background image
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ setBackgroundImage: function (url, callback, options) {
+ fabric.util.loadImage(url, function(img) {
+ this.backgroundImage = img;
+ if (options && ('backgroundImageOpacity' in options)) {
+ this.backgroundImageOpacity = options.backgroundImageOpacity;
+ }
+ if (options && ('backgroundImageStretch' in options)) {
+ this.backgroundImageStretch = options.backgroundImageStretch;
+ }
+ callback && callback();
+ }, this);
+
+ return this;
+ },
+
+ /**
+ * @private
+ * @method _createCanvasElement
+ */
+ _createCanvasElement: function() {
+ var element = fabric.document.createElement('canvas');
+ if (!element.style) {
+ element.style = { };
+ }
+ if (!element) {
+ throw CANVAS_INIT_ERROR;
+ }
+ this._initCanvasElement(element);
+ return element;
+ },
+
+ /**
+ * @method _initCanvasElement
+ * @param {HTMLElement} element
+ */
+ _initCanvasElement: function(element) {
+ if (typeof element.getContext === 'undefined' &&
+ typeof G_vmlCanvasManager !== 'undefined' &&
+ G_vmlCanvasManager.initElement) {
+
+ G_vmlCanvasManager.initElement(element);
+ }
+ if (typeof element.getContext === 'undefined') {
+ throw CANVAS_INIT_ERROR;
+ }
+ },
+
+ /**
+ * @method _initOptions
+ * @param {Object} [options]
+ */
+ _initOptions: function (options) {
+ for (var prop in options) {
+ this[prop] = options[prop];
+ }
+
+ this.width = parseInt(this.lowerCanvasEl.width, 10) || 0;
+ this.height = parseInt(this.lowerCanvasEl.height, 10) || 0;
+
+ if (!this.lowerCanvasEl.style) return;
+
+ this.lowerCanvasEl.style.width = this.width + 'px';
+ this.lowerCanvasEl.style.height = this.height + 'px';
+ },
+
+ /**
+ * Creates a bottom canvas
+ * @method _createLowerCanvas
+ */
+ _createLowerCanvas: function (canvasEl) {
+ this.lowerCanvasEl = fabric.util.getById(canvasEl) || this._createCanvasElement();
+ this._initCanvasElement(this.lowerCanvasEl);
+
+ fabric.util.addClass(this.lowerCanvasEl, 'lower-canvas');
+
+ if (this.interactive) {
+ this._applyCanvasStyle(this.lowerCanvasEl);
+ }
+
+ this.contextContainer = this.lowerCanvasEl.getContext('2d');
+ },
+
+ /**
+ * Returns canvas width (in px)
+ * @method getWidth
+ * @return {Number}
+ */
+ getWidth: function () {
+ return this.width;
+ },
+
+ /**
+ * Returns canvas height (in px)
+ * @method getHeight
+ * @return {Number}
+ */
+ getHeight: function () {
+ return this.height;
+ },
+
+ /**
+ * Sets width of this canvas instance
+ * @method setWidth
+ * @param {Number} width value to set width to
+ * @return {fabric.Canvas} instance
+ * @chainable true
+ */
+ setWidth: function (value) {
+ return this._setDimension('width', value);
+ },
+
+ /**
+ * Sets height of this canvas instance
+ * @method setHeight
+ * @param {Number} height value to set height to
+ * @return {fabric.Canvas} instance
+ * @chainable true
+ */
+ setHeight: function (value) {
+ return this._setDimension('height', value);
+ },
+
+ /**
+ * Sets dimensions (width, height) of this canvas instance
+ * @method setDimensions
+ * @param {Object} dimensions
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ setDimensions: function(dimensions) {
+ for (var prop in dimensions) {
+ this._setDimension(prop, dimensions[prop]);
+ }
+ return this;
+ },
+
+ /**
+ * Helper for setting width/height
+ * @private
+ * @method _setDimensions
+ * @param {String} prop property (width|height)
+ * @param {Number} value value to set property to
+ * @return {fabric.Canvas} instance
+ * @chainable true
+ */
+ _setDimension: function (prop, value) {
+ this.lowerCanvasEl[prop] = value;
+ this.lowerCanvasEl.style[prop] = value + 'px';
+
+ if (this.upperCanvasEl) {
+ this.upperCanvasEl[prop] = value;
+ this.upperCanvasEl.style[prop] = value + 'px';
+ }
+
+ if (this.cacheCanvasEl) {
+ this.cacheCanvasEl[prop] = value;
+ }
+
+ if (this.wrapperEl) {
+ this.wrapperEl.style[prop] = value + 'px';
+ }
+
+ this[prop] = value;
+
+ this.calcOffset();
+ this.renderAll();
+
+ return this;
+ },
+
+ /**
+ * Returns <canvas> element corresponding to this instance
+ * @method getElement
+ * @return {HTMLCanvasElement}
+ */
+ getElement: function () {
+ return this.lowerCanvasEl;
+ },
+
+ /**
+ * Returns currently selected object, if any
+ * @method getActiveObject
+ * @return {fabric.Object}
+ */
+ getActiveObject: function() {
+ return null;
+ },
+
+ /**
+ * Returns currently selected group of object, if any
+ * @method getActiveGroup
+ * @return {fabric.Group}
+ */
+ getActiveGroup: function() {
+ return null;
+ },
+
+ /**
+ * Given a context, renders an object on that context
+ * @param ctx {Object} context to render object on
+ * @param object {Object} object to render
+ * @private
+ */
+ _draw: function (ctx, object) {
+ if (!object) return;
+
+ if (this.controlsAboveOverlay) {
+ var hasBorders = object.hasBorders, hasCorners = object.hasCorners;
+ object.hasBorders = object.hasCorners = false;
+ object.render(ctx);
+ object.hasBorders = hasBorders;
+ object.hasCorners = hasCorners;
+ }
+ else {
+ object.render(ctx);
+ }
+ },
+
+ /**
+ * Adds objects to canvas, then renders canvas (if `renderOnAddition` is not `false`).
+ * Objects should be instances of (or inherit from) fabric.Object
+ * @method add
+ * @param [...] Zero or more fabric instances
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ add: function () {
+ this._objects.push.apply(this._objects, arguments);
+ for (var i = arguments.length; i--; ) {
+ this._initObject(arguments[i]);
+ }
+ this.renderOnAddition && this.renderAll();
+ return this;
+ },
+
+ /**
+ * @private
+ * @method _initObject
+ */
+ _initObject: function(obj) {
+ this.stateful && obj.setupState();
+ obj.setCoords();
+ obj.canvas = this;
+ this.fire('object:added', { target: obj });
+ obj.fire('added');
+ },
+
+ /**
+ * Inserts an object to canvas at specified index and renders canvas.
+ * An object should be an instance of (or inherit from) fabric.Object
+ * @method insertAt
+ * @param object {Object} Object to insert
+ * @param index {Number} index to insert object at
+ * @param nonSplicing {Boolean} when `true`, no splicing (shifting) of objects occurs
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ insertAt: function (object, index, nonSplicing) {
+ if (nonSplicing) {
+ this._objects[index] = object;
+ }
+ else {
+ this._objects.splice(index, 0, object);
+ }
+ this._initObject(object);
+ this.renderOnAddition && this.renderAll();
+ return this;
+ },
+
+ /**
+ * Returns an array of objects this instance has
+ * @method getObjects
+ * @return {Array}
+ */
+ getObjects: function () {
+ return this._objects;
+ },
+
+ /**
+ * Clears specified context of canvas element
+ * @method clearContext
+ * @param context {Object} ctx context to clear
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ clearContext: function(ctx) {
+ ctx.clearRect(0, 0, this.width, this.height);
+ return this;
+ },
+
+ /**
+ * Returns context of canvas where objects are drawn
+ * @method getContext
+ * @return {CanvasRenderingContext2D}
+ */
+ getContext: function () {
+ return this.contextContainer;
+ },
+
+ /**
+ * Clears all contexts (background, main, top) of an instance
+ * @method clear
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ clear: function () {
+ this._objects.length = 0;
+ this.clearContext(this.contextContainer);
+ if (this.contextTop) {
+ this.clearContext(this.contextTop);
+ }
+ this.renderAll();
+ return this;
+ },
+
+ /**
+ * Renders both the top canvas and the secondary container canvas.
+ * @method renderAll
+ * @param allOnTop {Boolean} optional Whether we want to force all images to be rendered on the top canvas
+ * @return {fabric.Canvas} instance
+ * @chainable
+ */
+ renderAll: function (allOnTop) {
+
+ var canvasToDrawOn = this[(allOnTop === true && this.interactive) ? 'contextTop' : 'contextContainer'];
+
+ if (this.contextTop) {
+ this.clearContext(this.contextTop);
+ }
+
+ if (!allOnTop) {
+ this.clearContext(canvasToDrawOn);
+ }
+
+ var activeGroup = this.getActiveGroup();
+
+ if (this.clipTo) {
+ this._clipCanvas(canvasToDrawOn);
+ }
+
+ canvasToDrawOn.fillStyle = this.backgroundColor;
+ canvasToDrawOn.fillRect(0, 0, this.width, this.height);
+
+ if (typeof this.backgroundImage === 'object') {
+ this._drawBackroundImage(canvasToDrawOn);
+ }
+
+ this.fire('before:render');
+
+ for (var i = 0, length = this._objects.length; i < length; ++i) {
+ if (!activeGroup ||
+ (activeGroup && this._objects[i] && !activeGroup.contains(this._objects[i]))) {
+ this._draw(canvasToDrawOn, this._objects[i]);
+ }
+ }
+
+ // delegate rendering to group selection (if one exists)
+ if (activeGroup) {
+ //Store objects in group preserving order, then replace
+ var sortedObjects = [];
+ this.forEachObject(function (object) {
+ if (activeGroup.contains(object)) {
+ sortedObjects.push(object);
+ }
+ });
+ activeGroup._set('objects', sortedObjects);
+ this._draw(canvasToDrawOn, activeGroup);
+ }
+
+ if (this.clipTo) {
+ canvasToDrawOn.restore();
+ }
+
+ if (this.overlayImage) {
+ canvasToDrawOn.drawImage(this.overlayImage, this.overlayImageLeft, this.overlayImageTop);
+ }
+
+ if (this.controlsAboveOverlay) {
+ this.drawControls(canvasToDrawOn);
+ }
+
+ this.fire('after:render');
+
+ return this;
+ },
+
+ /**
+ * @private
+ * @method _clipCanvas
+ */
+ _clipCanvas: function(canvasToDrawOn) {
+ canvasToDrawOn.save();
+ canvasToDrawOn.beginPath();
+ this.clipTo(canvasToDrawOn);
+ canvasToDrawOn.clip();
+ },
+
+ /**
+ * @private
+ * @method _drawBackroundImage
+ */
+ _drawBackroundImage: function(canvasToDrawOn) {
+ canvasToDrawOn.save();
+ canvasToDrawOn.globalAlpha = this.backgroundImageOpacity;
+
+ if (this.backgroundImageStretch) {
+ canvasToDrawOn.drawImage(this.backgroundImage, 0, 0, this.width, this.height);
+ }
+ else {
+ canvasToDrawOn.drawImage(this.backgroundImage, 0, 0);
+ }
+ canvasToDrawOn.restore();
+ },
+
+ /**
+ * Method to render only the top canvas.
+ * Also used to render the group selection box.
+ * @method renderTop
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ renderTop: function () {
+ var ctx = this.contextTop || this.contextContainer;
+ this.clearContext(ctx);
+
+ // we render the top context - last object
+ if (this.selection && this._groupSelector) {
+ this._drawSelection();
+ }
+
+ // delegate rendering to group selection if one exists
+ // used for drawing selection borders/corners
+ var activeGroup = this.getActiveGroup();
+ if (activeGroup) {
+ activeGroup.render(ctx);
+ }
+
+ if (this.overlayImage) {
+ ctx.drawImage(this.overlayImage, this.overlayImageLeft, this.overlayImageTop);
+ }
+
+ this.fire('after:render');
+
+ return this;
+ },
+
+ /**
+ * Draws objects' controls (borders/corners)
+ * @method drawControls
+ * @param {Object} ctx context to render controls on
+ */
+ drawControls: function(ctx) {
+ var activeGroup = this.getActiveGroup();
+ if (activeGroup) {
+ ctx.save();
+ fabric.Group.prototype.transform.call(activeGroup, ctx);
+ activeGroup.drawBorders(ctx).drawCorners(ctx);
+ ctx.restore();
+ }
+ else {
+ for (var i = 0, len = this._objects.length; i < len; ++i) {
+ if (!this._objects[i] || !this._objects[i].active) continue;
+
+ ctx.save();
+ fabric.Object.prototype.transform.call(this._objects[i], ctx);
+ this._objects[i].drawBorders(ctx).drawCorners(ctx);
+ ctx.restore();
+
+ this.lastRenderedObjectWithControlsAboveOverlay = this._objects[i];
+ }
+ }
+ },
+
+ /**
+ * Exports canvas element to a dataurl image.
+ * @method toDataURL
+ * @param {String} format the format of the output image. Either "jpeg" or "png".
+ * @param {Number} quality quality level (0..1)
+ * @return {String}
+ */
+ toDataURL: function (format, quality) {
+ var canvasEl = this.upperCanvasEl || this.lowerCanvasEl;
+
+ this.renderAll(true);
+ var data = (fabric.StaticCanvas.supports('toDataURLWithQuality'))
+ ? canvasEl.toDataURL('image/' + format, quality)
+ : canvasEl.toDataURL('image/' + format);
+ this.renderAll();
+ return data;
+ },
+
+ /**
+ * Exports canvas element to a dataurl image (allowing to change image size via multiplier).
+ * @method toDataURLWithMultiplier
+ * @param {String} format (png|jpeg)
+ * @param {Number} multiplier
+ * @param {Number} quality (0..1)
+ * @return {String}
+ */
+ toDataURLWithMultiplier: function (format, multiplier, quality) {
+
+ var origWidth = this.getWidth(),
+ origHeight = this.getHeight(),
+ scaledWidth = origWidth * multiplier,
+ scaledHeight = origHeight * multiplier,
+ activeObject = this.getActiveObject(),
+ activeGroup = this.getActiveGroup(),
+
+ ctx = this.contextTop || this.contextContainer;
+
+ this.setWidth(scaledWidth).setHeight(scaledHeight);
+ ctx.scale(multiplier, multiplier);
+
+ if (activeGroup) {
+ // not removing group due to complications with restoring it with correct state afterwords
+ this._tempRemoveBordersCornersFromGroup(activeGroup);
+ }
+ else if (activeObject && this.deactivateAll) {
+ this.deactivateAll();
+ }
+
+ // restoring width, height for `renderAll` to draw
+ // background properly (while context is scaled)
+ this.width = origWidth;
+ this.height = origHeight;
+
+ this.renderAll(true);
+
+ var dataURL = this.toDataURL(format, quality);
+
+ ctx.scale(1 / multiplier, 1 / multiplier);
+ this.setWidth(origWidth).setHeight(origHeight);
+
+ if (activeGroup) {
+ this._restoreBordersCornersOnGroup(activeGroup);
+ }
+ else if (activeObject && this.setActiveObject) {
+ this.setActiveObject(activeObject);
+ }
+
+ this.renderAll();
+
+ return dataURL;
+ },
+
+ /**
+ * @private
+ * @method _tempRemoveBordersCornersFromGroup
+ */
+ _tempRemoveBordersCornersFromGroup: function(group) {
+ group.origHideCorners = group.hideCorners;
+ group.origBorderColor = group.borderColor;
+
+ group.hideCorners = true;
+ group.borderColor = 'rgba(0,0,0,0)';
+
+ group.forEachObject(function(o) {
+ o.origBorderColor = o.borderColor;
+ o.borderColor = 'rgba(0,0,0,0)';
+ });
+ },
+
+ /**
+ * @private
+ * @method _restoreBordersCornersOnGroup
+ */
+ _restoreBordersCornersOnGroup: function(group) {
+ group.hideCorners = group.origHideCorners;
+ group.borderColor = group.origBorderColor;
+
+ group.forEachObject(function(o) {
+ o.borderColor = o.origBorderColor;
+ delete o.origBorderColor;
+ });
+ },
+
+ /**
+ * Returns coordinates of a center of canvas.
+ * Returned value is an object with top and left properties
+ * @method getCenter
+ * @return {Object} object with "top" and "left" number values
+ */
+ getCenter: function () {
+ return {
+ top: this.getHeight() / 2,
+ left: this.getWidth() / 2
+ };
+ },
+
+ /**
+ * Centers object horizontally.
+ * @method centerObjectH
+ * @param {fabric.Object} object Object to center
+ * @return {fabric.Canvas} thisArg
+ */
+ centerObjectH: function (object) {
+ object.set('left', this.getCenter().left);
+ this.renderAll();
+ return this;
+ },
+
+ /**
+ * Centers object vertically.
+ * @method centerObjectH
+ * @param {fabric.Object} object Object to center
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ centerObjectV: function (object) {
+ object.set('top', this.getCenter().top);
+ this.renderAll();
+ return this;
+ },
+
+ /**
+ * Centers object vertically and horizontally.
+ * @method centerObject
+ * @param {fabric.Object} object Object to center
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ centerObject: function (object) {
+ return this.centerObjectH(object).centerObjectV(object);
+ },
+
+ /**
+ * Returs dataless JSON representation of canvas
+ * @method toDatalessJSON
+ * @param {Array} propertiesToInclude
+ * @return {String} json string
+ */
+ toDatalessJSON: function (propertiesToInclude) {
+ return this.toDatalessObject(propertiesToInclude);
+ },
+
+ /**
+ * Returns object representation of canvas
+ * @method toObject
+ * @param {Array} propertiesToInclude
+ * @return {Object} object representation of an instance
+ */
+ toObject: function (propertiesToInclude) {
+ return this._toObjectMethod('toObject', propertiesToInclude);
+ },
+
+ /**
+ * Returns dataless object representation of canvas
+ * @method toDatalessObject
+ * @param {Array} propertiesToInclude
+ * @return {Object} object representation of an instance
+ */
+ toDatalessObject: function (propertiesToInclude) {
+ return this._toObjectMethod('toDatalessObject', propertiesToInclude);
+ },
+
+ /**
+ * @private
+ * @method _toObjectMethod
+ */
+ _toObjectMethod: function (methodName, propertiesToInclude) {
+ var data = {
+ objects: this._objects.map(function (instance) {
+ // TODO (kangax): figure out how to clean this up
+ var originalValue;
+ if (!this.includeDefaultValues) {
+ originalValue = instance.includeDefaultValues;
+ instance.includeDefaultValues = false;
+ }
+ var object = instance[methodName](propertiesToInclude);
+ if (!this.includeDefaultValues) {
+ instance.includeDefaultValues = originalValue;
+ }
+ return object;
+ }, this),
+ background: this.backgroundColor
+ };
+ if (this.backgroundImage) {
+ data.backgroundImage = this.backgroundImage.src;
+ data.backgroundImageOpacity = this.backgroundImageOpacity;
+ data.backgroundImageStretch = this.backgroundImageStretch;
+ }
+ if (this.overlayImage) {
+ data.overlayImage = this.overlayImage.src;
+ data.overlayImageLeft = this.overlayImageLeft;
+ data.overlayImageTop = this.overlayImageTop;
+ }
+ fabric.util.populateWithProperties(this, data, propertiesToInclude);
+ return data;
+ },
+
+ /**
+ * Returns SVG representation of canvas
+ * @function
+ * @method toSVG
+ * @return {String}
+ */
+ toSVG: function() {
+ var markup = [
+ '',
+ '',
+ '');
+
+ return markup.join('');
+ },
+
+ /**
+ * Returns true if canvas contains no objects
+ * @method isEmpty
+ * @return {Boolean} true if canvas is empty
+ */
+ isEmpty: function () {
+ return this._objects.length === 0;
+ },
+
+ /**
+ * Removes an object from canvas and returns it
+ * @method remove
+ * @param object {Object} Object to remove
+ * @return {Object} removed object
+ */
+ remove: function (object) {
+ removeFromArray(this._objects, object);
+ if (this.getActiveObject() === object) {
+
+ // removing active object should fire "selection:cleared" events
+ this.fire('before:selection:cleared', { target: object });
+ this.discardActiveObject();
+ this.fire('selection:cleared');
+ }
+ this.renderAll();
+ return object;
+ },
+
+ /**
+ * Moves an object to the bottom of the stack of drawn objects
+ * @method sendToBack
+ * @param object {fabric.Object} Object to send to back
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ sendToBack: function (object) {
+ removeFromArray(this._objects, object);
+ this._objects.unshift(object);
+ return this.renderAll();
+ },
+
+ /**
+ * Moves an object to the top of the stack of drawn objects
+ * @method bringToFront
+ * @param object {fabric.Object} Object to send
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ bringToFront: function (object) {
+ removeFromArray(this._objects, object);
+ this._objects.push(object);
+ return this.renderAll();
+ },
+
+ /**
+ * Moves an object one level down in stack of drawn objects
+ * @method sendBackwards
+ * @param object {fabric.Object} Object to send
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ sendBackwards: function (object) {
+ var idx = this._objects.indexOf(object),
+ nextIntersectingIdx = idx;
+
+ // if object is not on the bottom of stack
+ if (idx !== 0) {
+
+ // traverse down the stack looking for the nearest intersecting object
+ for (var i=idx-1; i>=0; --i) {
+
+ var isIntersecting = object.intersectsWithObject(this._objects[i]) ||
+ object.isContainedWithinObject(this._objects[i]) ||
+ this._objects[i].isContainedWithinObject(object);
+
+ if (isIntersecting) {
+ nextIntersectingIdx = i;
+ break;
+ }
+ }
+ removeFromArray(this._objects, object);
+ this._objects.splice(nextIntersectingIdx, 0, object);
+ }
+ return this.renderAll();
+ },
+
+ /**
+ * Moves an object one level up in stack of drawn objects
+ * @method bringForward
+ * @param object {fabric.Object} Object to send
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ bringForward: function (object) {
+ var objects = this.getObjects(),
+ idx = objects.indexOf(object),
+ nextIntersectingIdx = idx;
+
+
+ // if object is not on top of stack (last item in an array)
+ if (idx !== objects.length-1) {
+
+ // traverse up the stack looking for the nearest intersecting object
+ for (var i = idx + 1, l = this._objects.length; i < l; ++i) {
+
+ var isIntersecting = object.intersectsWithObject(objects[i]) ||
+ object.isContainedWithinObject(this._objects[i]) ||
+ this._objects[i].isContainedWithinObject(object);
+
+ if (isIntersecting) {
+ nextIntersectingIdx = i;
+ break;
+ }
+ }
+ removeFromArray(objects, object);
+ objects.splice(nextIntersectingIdx, 0, object);
+ }
+ this.renderAll();
+ },
+
+ /**
+ * Returns object at specified index
+ * @method item
+ * @param {Number} index
+ * @return {fabric.Object}
+ */
+ item: function (index) {
+ return this.getObjects()[index];
+ },
+
+ /**
+ * Returns number representation of an instance complexity
+ * @method complexity
+ * @return {Number} complexity
+ */
+ complexity: function () {
+ return this.getObjects().reduce(function (memo, current) {
+ memo += current.complexity ? current.complexity() : 0;
+ return memo;
+ }, 0);
+ },
+
+ /**
+ * Iterates over all objects, invoking callback for each one of them
+ * @method forEachObject
+ * @return {fabric.Canvas} thisArg
+ */
+ forEachObject: function(callback, context) {
+ var objects = this.getObjects(),
+ i = objects.length;
+ while (i--) {
+ callback.call(context, objects[i], i, objects);
+ }
+ return this;
+ },
+
+ /**
+ * Clears a canvas element and removes all event handlers.
+ * @method dispose
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ dispose: function () {
+ this.clear();
+ if (this.interactive) {
+ removeListener(this.upperCanvasEl, 'mousedown', this._onMouseDown);
+ removeListener(this.upperCanvasEl, 'mousemove', this._onMouseMove);
+ removeListener(fabric.window, 'resize', this._onResize);
+ }
+ return this;
+ },
+
+ /**
+ * @private
+ * @method _resizeImageToFit
+ * @param {HTMLImageElement} imgEl
+ */
+ _resizeImageToFit: function (imgEl) {
+
+ var imageWidth = imgEl.width || imgEl.offsetWidth,
+ widthScaleFactor = this.getWidth() / imageWidth;
+
+ // scale image down so that it has original dimensions when printed in large resolution
+ if (imageWidth) {
+ imgEl.width = imageWidth * widthScaleFactor;
+ }
+ }
+ });
+
+ /**
+ * Returns a string representation of an instance
+ * @method toString
+ * @return {String} string representation of an instance
+ */
+ fabric.StaticCanvas.prototype.toString = function () { // Assign explicitly since `extend` doesn't take care of DontEnum bug yet
+ return '#';
+ };
+
+ extend(fabric.StaticCanvas, /** @scope fabric.StaticCanvas */ {
+
+ /**
+ * @static
+ * @property EMPTY_JSON
+ * @type String
+ */
+ EMPTY_JSON: '{"objects": [], "background": "white"}',
+
+ /**
+ * Takes <canvas> element and transforms its data in such way that it becomes grayscale
+ * @static
+ * @method toGrayscale
+ * @param {HTMLCanvasElement} canvasEl
+ */
+ toGrayscale: function (canvasEl) {
+ var context = canvasEl.getContext('2d'),
+ imageData = context.getImageData(0, 0, canvasEl.width, canvasEl.height),
+ data = imageData.data,
+ iLen = imageData.width,
+ jLen = imageData.height,
+ index, average, i, j;
+
+ for (i = 0; i < iLen; i++) {
+ for (j = 0; j < jLen; j++) {
+
+ index = (i * 4) * jLen + (j * 4);
+ average = (data[index] + data[index + 1] + data[index + 2]) / 3;
+
+ data[index] = average;
+ data[index + 1] = average;
+ data[index + 2] = average;
+ }
+ }
+
+ context.putImageData(imageData, 0, 0);
+ },
+
+ /**
+ * Provides a way to check support of some of the canvas methods
+ * (either those of HTMLCanvasElement itself, or rendering context)
+ *
+ * @method supports
+ * @param methodName {String} Method to check support for;
+ * Could be one of "getImageData", "toDataURL" or "toDataURLWithQuality"
+ * @return {Boolean | null} `true` if method is supported (or at least exists),
+ * `null` if canvas element or context can not be initialized
+ */
+ supports: function (methodName) {
+ var el = fabric.document.createElement('canvas');
+
+ if (typeof G_vmlCanvasManager !== 'undefined') {
+ G_vmlCanvasManager.initElement(el);
+ }
+ if (!el || !el.getContext) {
+ return null;
+ }
+
+ var ctx = el.getContext('2d');
+ if (!ctx) {
+ return null;
+ }
+
+ switch (methodName) {
+
+ case 'getImageData':
+ return typeof ctx.getImageData !== 'undefined';
+
+ case 'toDataURL':
+ return typeof el.toDataURL !== 'undefined';
+
+ case 'toDataURLWithQuality':
+ try {
+ el.toDataURL('image/jpeg', 0);
+ return true;
+ }
+ catch (e) { }
+ return false;
+
+ default:
+ return null;
+ }
+ }
+ });
+
+ /**
+ * Returs JSON representation of canvas
+ * @function
+ * @method toJSON
+ * @return {String} json string
+ */
+ fabric.StaticCanvas.prototype.toJSON = fabric.StaticCanvas.prototype.toObject;
+
+})();
+
+(function(global) {
+
+ "use strict";
+
+ var fabric = global.fabric || (global.fabric = { });
+
+ var utilMin = fabric.util.array.min,
+ utilMax = fabric.util.array.max;
+
+ if (fabric.FreeDrawing) {
+ fabric.warn('fabric.FreeDrawing is already defined');
+ return;
+ }
+
+ /**
+ * Free drawing class
+ * Free Drawer handles scribbling on a fabric canvas
+ * It converts the hand writting to a SVG Path and adds this path to the canvas
+ *
+ * @class FreeDrawing
+ * @memberOf fabric
+ */
+ fabric.FreeDrawing = fabric.util.createClass( /** @scope fabric.FreeDrawing.prototype */ {
+
+ /**
+ * Constructor
+ * @metod initialize
+ * @param fabricCanvas {fabric.Canvas}
+ * @return {fabric.FreeDrawing}
+ */
+ initialize: function(fabricCanvas) {
+ this.canvas = fabricCanvas;
+ this._points = [];
+ },
+
+ /**
+ * @private
+ * @method _addPoint
+ *
+ */
+ _addPoint: function(point) {
+ this._points.push(point);
+ },
+
+ /**
+ * Clear points array and set contextTop canvas
+ * style.
+ *
+ * @private
+ * @method _reset
+ *
+ */
+ _reset: function() {
+ this._points.length = 0;
+ var ctx = this.canvas.contextTop;
+
+ // set freehanddrawing line canvas parameters
+ ctx.strokeStyle = this.canvas.freeDrawingColor;
+ ctx.lineWidth = this.canvas.freeDrawingLineWidth;
+ ctx.lineCap = ctx.lineJoin = 'round';
+ },
+
+ /**
+ * @method _prepareForDrawing
+ */
+ _prepareForDrawing: function(pointer) {
+
+ this.canvas._isCurrentlyDrawing = true;
+ this.canvas.discardActiveObject().renderAll();
+
+ var p = new fabric.Point(pointer.x, pointer.y);
+ this._reset();
+ this._addPoint(p);
+ this.canvas.contextTop.moveTo(p.x, p.y);
+ },
+
+ /**
+ * @private
+ * @method _captureDrawingPath
+ *
+ * @param point {pointer} (fabric.util.pointer) actual mouse position
+ * related to the canvas.
+ */
+ _captureDrawingPath: function(pointer) {
+ var pointerPoint = new fabric.Point(pointer.x, pointer.y);
+ this._addPoint(pointerPoint);
+ },
+
+ /**
+ * Draw a smooth path on the topCanvas using
+ * quadraticCurveTo.
+ *
+ * @private
+ * @method _render
+ *
+ */
+ _render: function() {
+ var ctx = this.canvas.contextTop;
+ ctx.beginPath();
+
+ var p1 = this._points[0];
+ var p2 = this._points[1];
+
+ ctx.moveTo(p1.x, p1.y);
+
+ for (var i = 1, len = this._points.length; i < len; i++) {
+ // we pick the point between pi+1 & pi+2 as the
+ // end point and p1 as our control point.
+ var midPoint = p1.midPointFrom(p2);
+ ctx.quadraticCurveTo(p1.x, p1.y, midPoint.x, midPoint.y);
+
+ p1 = this._points[i];
+ p2 = this._points[i+1];
+ }
+ // Draw last line as a straight line while
+ // we wait for the next point to be able to calculate
+ // the bezier control point
+ ctx.lineTo(p1.x, p1.y);
+ ctx.stroke();
+ },
+
+ /**
+ * Return an SVG path based on our
+ * captured points and their boundinb box.
+ *
+ * @private
+ * @method _getSVGPathData
+ *
+ */
+ _getSVGPathData: function() {
+ this.box = this.getPathBoundingBox(this._points);
+ return this.convertPointsToSVGPath(
+ this._points, this.box.minx, this.box.maxx, this.box.miny, this.box.maxy);
+ },
+
+ /**
+ * Returns bounding box of a path based on given points
+ * @method getPathBoundingBox
+ * @param {Array} points
+ * @return {Object} object with minx, miny, maxx, maxy
+ */
+ getPathBoundingBox: function(points) {
+ var xBounds = [],
+ yBounds = [],
+ p1 = points[0],
+ p2 = points[1],
+ startPoint = p1;
+
+ for (var i = 1, len = points.length; i < len; i++) {
+ var midPoint = p1.midPointFrom(p2);
+ // with startPoint, p1 as control point, midpoint as end point
+ xBounds.push(startPoint.x);
+ xBounds.push(midPoint.x);
+ yBounds.push(startPoint.y);
+ yBounds.push(midPoint.y);
+
+ p1 = points[i];
+ p2 = points[i+1];
+ startPoint = midPoint;
+ } // end for
+
+ xBounds.push(p1.x);
+ yBounds.push(p1.y);
+
+ return {
+ minx: utilMin(xBounds),
+ miny: utilMin(yBounds),
+ maxx: utilMax(xBounds),
+ maxy: utilMax(yBounds)
+ };
+ },
+
+ /**
+ * Converts points to SVG path
+ * @method convertPointsToSVGPath
+ * @param {Array} points Array of points
+ * @return {String} SVG path
+ */
+ convertPointsToSVGPath: function(points, minX, maxX, minY, maxY) {
+ var path = [];
+ var p1 = new fabric.Point(points[0].x - minX, points[0].y - minY);
+ var p2 = new fabric.Point(points[1].x - minX, points[1].y - minY);
+
+ path.push('M ', points[0].x - minX, ' ', points[0].y - minY, ' ');
+ for (var i = 1, len = points.length; i < len; i++) {
+ var midPoint = p1.midPointFrom(p2);
+ // p1 is our bezier control point
+ // midpoint is our endpoint
+ // start point is p(i-1) value.
+ path.push('Q ', p1.x, ' ', p1.y, ' ', midPoint.x, ' ', midPoint.y, ' ');
+ p1 = new fabric.Point(points[i].x - minX, points[i].y - minY);
+ if ((i+1) < points.length) {
+ p2 = new fabric.Point(points[i+1].x - minX, points[i+1].y - minY);
+ }
+ }
+ path.push('L ', p1.x, ' ', p1.y, ' ');
+ return path;
+ },
+
+ /**
+ * On mouseup after drawing the path on contextTop canvas
+ * we use the points captured to create an new fabric path object
+ * and add it to the fabric canvas.
+ *
+ * @method _finalizeAndAddPath
+ */
+ _finalizeAndAddPath: function() {
+ this.canvas._isCurrentlyDrawing = false;
+ var ctx = this.canvas.contextTop;
+ ctx.closePath();
+ var path = this._getSVGPathData();
+ path = path.join('');
+
+ if (path === "M 0 0 Q 0 0 0 0 L 0 0") {
+ // do not create 0 width/height paths, as they are
+ // rendered inconsistently across browsers
+ // Firefox 4, for example, renders a dot,
+ // whereas Chrome 10 renders nothing
+ this.canvas.renderAll();
+ return;
+ }
+
+ var p = new fabric.Path(path);
+ p.fill = null;
+ p.stroke = this.canvas.freeDrawingColor;
+ p.strokeWidth = this.canvas.freeDrawingLineWidth;
+ this.canvas.add(p);
+
+ // set path origin coordinates based on our bounding box
+ var originLeft = this.box.minx + (this.box.maxx - this.box.minx) /2;
+ var originTop = this.box.miny + (this.box.maxy - this.box.miny) /2;
+
+ this.canvas.contextTop.arc(originLeft, originTop, 3, 0, Math.PI * 2, false);
+
+ p.set({ left: originLeft, top: originTop });
+
+ // does not change position
+ p.setCoords();
+
+ this.canvas.renderAll();
+
+ // fire event 'path' created
+ this.canvas.fire('path:created', { path: p });
+ }
+ });
+
+})(typeof exports !== 'undefined' ? exports : this);
+
+(function() {
+
+ var extend = fabric.util.object.extend,
+ getPointer = fabric.util.getPointer,
+ addListener = fabric.util.addListener,
+ removeListener = fabric.util.removeListener,
+ degreesToRadians = fabric.util.degreesToRadians,
+ radiansToDegrees = fabric.util.radiansToDegrees,
+ cursorMap = {
+ 'tr': 'ne-resize',
+ 'br': 'se-resize',
+ 'bl': 'sw-resize',
+ 'tl': 'nw-resize',
+ 'ml': 'w-resize',
+ 'mt': 'n-resize',
+ 'mr': 'e-resize',
+ 'mb': 's-resize'
+ },
+
+ sqrt = Math.sqrt,
+ pow = Math.pow,
+ atan2 = Math.atan2,
+ abs = Math.abs,
+ min = Math.min,
+ max = Math.max,
+
+ STROKE_OFFSET = 0.5;
+
+ /**
+ * Canvas class
+ * @class fabric.Canvas
+ * @constructor
+ * @extends fabric.StaticCanvas
+ * @param {HTMLElement | String} el <canvas> element to initialize instance on
+ * @param {Object} [options] Options object
+ */
+ fabric.Canvas = function(el, options) {
+ options || (options = { });
+
+ this._initStatic(el, options);
+ this._initInteractive();
+ this._createCacheCanvas();
+
+ fabric.Canvas.activeInstance = this;
+ };
+
+ function ProtoProxy(){ }
+ ProtoProxy.prototype = fabric.StaticCanvas.prototype;
+ fabric.Canvas.prototype = new ProtoProxy();
+
+ var InteractiveMethods = /** @scope fabric.Canvas.prototype */ {
+
+ /**
+ * Indicates that canvas is interactive. This property should not be changed.
+ * @property
+ * @type Boolean
+ */
+ interactive: true,
+
+ /**
+ * Indicates whether group selection should be enabled
+ * @property
+ * @type Boolean
+ */
+ selection: true,
+
+ /**
+ * Color of selection
+ * @property
+ * @type String
+ */
+ selectionColor: 'rgba(100, 100, 255, 0.3)', // blue
+
+ /**
+ * Default dash array pattern
+ * If not empty the selection border is dashed
+ * @property
+ * @type Array
+ */
+ selectionDashArray: [ ],
+
+ /**
+ * Color of the border of selection (usually slightly darker than color of selection itself)
+ * @property
+ * @type String
+ */
+ selectionBorderColor: 'rgba(255, 255, 255, 0.3)',
+
+ /**
+ * Width of a line used in object/group selection
+ * @property
+ * @type Number
+ */
+ selectionLineWidth: 1,
+
+ /**
+ * Color of the line used in free drawing mode
+ * @property
+ * @type String
+ */
+ freeDrawingColor: 'rgb(0, 0, 0)',
+
+ /**
+ * Width of a line used in free drawing mode
+ * @property
+ * @type Number
+ */
+ freeDrawingLineWidth: 1,
+
+ /**
+ * Default cursor value used when hovering over an object on canvas
+ * @property
+ * @type String
+ */
+ hoverCursor: 'move',
+
+ /**
+ * Default cursor value used when moving an object on canvas
+ * @property
+ * @type String
+ */
+ moveCursor: 'move',
+
+ /**
+ * Default cursor value used for the entire canvas
+ * @property
+ * @type String
+ */
+ defaultCursor: 'default',
+
+ /**
+ * Cursor value used for rotation point
+ * @property
+ * @type String
+ */
+ rotationCursor: 'crosshair',
+
+ /**
+ * Default element class that's given to wrapper (div) element of canvas
+ * @property
+ * @type String
+ */
+ containerClass: 'canvas-container',
+
+ /**
+ * When true, object detection happens on per-pixel basis rather than on per-bounding-box
+ * @property
+ * @type Boolean
+ */
+ perPixelTargetFind: false,
+
+ /**
+ * Number of pixels around target pixel to tolerate (consider active) during object detection
+ * @property
+ * @type Number
+ */
+ targetFindTolerance: 0,
+
+ /**
+ * @method _initInteractive
+ * @private
+ */
+ _initInteractive: function() {
+ this._currentTransform = null;
+ this._groupSelector = null;
+ this.freeDrawing = fabric.FreeDrawing && new fabric.FreeDrawing(this);
+ this._initWrapperElement();
+ this._createUpperCanvas();
+ this._initEvents();
+ this.calcOffset();
+ },
+
+ /**
+ * Adds mouse listeners to canvas
+ * @method _initEvents
+ * @private
+ * See configuration documentation for more details.
+ */
+ _initEvents: function () {
+ var _this = this;
+
+ this._onMouseDown = function (e) {
+ _this.__onMouseDown(e);
+
+ addListener(fabric.document, 'mouseup', _this._onMouseUp);
+ fabric.isTouchSupported && addListener(fabric.document, 'touchend', _this._onMouseUp);
+
+ addListener(fabric.document, 'mousemove', _this._onMouseMove);
+ fabric.isTouchSupported && addListener(fabric.document, 'touchmove', _this._onMouseMove);
+
+ removeListener(_this.upperCanvasEl, 'mousemove', _this._onMouseMove);
+ fabric.isTouchSupported && removeListener(_this.upperCanvasEl, 'touchmove', _this._onMouseMove);
+ };
+
+ this._onMouseUp = function (e) {
+ _this.__onMouseUp(e);
+
+ removeListener(fabric.document, 'mouseup', _this._onMouseUp);
+ fabric.isTouchSupported && removeListener(fabric.document, 'touchend', _this._onMouseUp);
+
+ removeListener(fabric.document, 'mousemove', _this._onMouseMove);
+ fabric.isTouchSupported && removeListener(fabric.document, 'touchmove', _this._onMouseMove);
+
+ addListener(_this.upperCanvasEl, 'mousemove', _this._onMouseMove);
+ fabric.isTouchSupported && addListener(_this.upperCanvasEl, 'touchmove', _this._onMouseMove);
+ };
+
+ this._onMouseMove = function (e) {
+ e.preventDefault && e.preventDefault();
+ _this.__onMouseMove(e);
+ };
+
+ this._onResize = function () {
+ _this.calcOffset();
+ };
+
+
+ addListener(fabric.window, 'resize', this._onResize);
+
+ if (fabric.isTouchSupported) {
+ addListener(this.upperCanvasEl, 'touchstart', this._onMouseDown);
+ addListener(this.upperCanvasEl, 'touchmove', this._onMouseMove);
+ }
+ else {
+ addListener(this.upperCanvasEl, 'mousedown', this._onMouseDown);
+ addListener(this.upperCanvasEl, 'mousemove', this._onMouseMove);
+ }
+ },
+
+ /**
+ * Method that defines the actions when mouse is released on canvas.
+ * The method resets the currentTransform parameters, store the image corner
+ * position in the image object and render the canvas on top.
+ * @method __onMouseUp
+ * @param {Event} e Event object fired on mouseup
+ *
+ */
+ __onMouseUp: function (e) {
+
+ var target;
+
+ if (this.isDrawingMode && this._isCurrentlyDrawing) {
+ this.freeDrawing._finalizeAndAddPath();
+ this.fire('mouse:up', { e: e });
+ return;
+ }
+
+ if (this._currentTransform) {
+
+ var transform = this._currentTransform;
+
+ target = transform.target;
+ if (target._scaling) {
+ target._scaling = false;
+ }
+
+ // determine the new coords everytime the image changes its position
+ var i = this._objects.length;
+ while (i--) {
+ this._objects[i].setCoords();
+ }
+
+ target.isMoving = false;
+
+ // only fire :modified event if target coordinates were changed during mousedown-mouseup
+ if (this.stateful && target.hasStateChanged()) {
+ this.fire('object:modified', { target: target });
+ target.fire('modified');
+ }
+ }
+
+ this._currentTransform = null;
+
+ if (this._groupSelector) {
+ // group selection was completed, determine its bounds
+ this._findSelectedObjects(e);
+ }
+ var activeGroup = this.getActiveGroup();
+ if (activeGroup) {
+ activeGroup.setObjectsCoords();
+ activeGroup.set('isMoving', false);
+ this._setCursor(this.defaultCursor);
+ }
+
+ // clear selection
+ this._groupSelector = null;
+ this.renderAll();
+
+ this._setCursorFromEvent(e, target);
+
+ // fix for FF
+ this._setCursor('');
+
+ var _this = this;
+ setTimeout(function () {
+ _this._setCursorFromEvent(e, target);
+ }, 50);
+
+ this.fire('mouse:up', { target: target, e: e });
+ target && target.fire('mouseup', { e: e });
+ },
+
+ /**
+ * Method that defines the actions when mouse is clic ked on canvas.
+ * The method inits the currentTransform parameters and renders all the
+ * canvas so the current image can be placed on the top canvas and the rest
+ * in on the container one.
+ * @method __onMouseDown
+ * @param e {Event} Event object fired on mousedown
+ *
+ */
+ __onMouseDown: function (e) {
+
+ var pointer;
+
+ // accept only left clicks
+ var isLeftClick = 'which' in e ? e.which === 1 : e.button === 1;
+ if (!isLeftClick && !fabric.isTouchSupported) return;
+
+ if (this.isDrawingMode) {
+ pointer = this.getPointer(e);
+ this.freeDrawing._prepareForDrawing(pointer);
+
+ // capture coordinates immediately;
+ // this allows to draw dots (when movement never occurs)
+ this.freeDrawing._captureDrawingPath(pointer);
+
+ this.fire('mouse:down', { e: e });
+ return;
+ }
+
+ // ignore if some object is being transformed at this moment
+ if (this._currentTransform) return;
+
+ var target = this.findTarget(e),
+ activeGroup = this.getActiveGroup(),
+ corner;
+
+ pointer = this.getPointer(e);
+
+ if (this._shouldClearSelection(e)) {
+
+ this._groupSelector = {
+ ex: pointer.x,
+ ey: pointer.y,
+ top: 0,
+ left: 0
+ };
+
+ this.deactivateAllWithDispatch();
+ }
+ else {
+ // determine if it's a drag or rotate case
+ // rotate and scale will happen at the same time
+ this.stateful && target.saveState();
+
+ if ((corner = target._findTargetCorner(e, this._offset))) {
+ this.onBeforeScaleRotate(target);
+ }
+
+ var shouldHandleGroupLogic = e.shiftKey && (activeGroup || this.getActiveObject()) && this.selection;
+ if (shouldHandleGroupLogic) {
+ this._handleGroupLogic(e, target);
+ target = this.getActiveGroup();
+ }
+ else {
+ if (target !== this.getActiveGroup()) {
+ this.deactivateAll();
+ }
+ this.setActiveObject(target, e);
+ }
+
+ this._setupCurrentTransform(e, target);
+ }
+ // we must renderAll so that active image is placed on the top canvas
+ this.renderAll();
+
+ this.fire('mouse:down', { target: target, e: e });
+ target && target.fire('mousedown', { e: e });
+ },
+
+ /**
+ * Method that defines the actions when mouse is hovering the canvas.
+ * The currentTransform parameter will definde whether the user is rotating/scaling/translating
+ * an image or neither of them (only hovering). A group selection is also possible and would cancel
+ * all any other type of action.
+ * In case of an image transformation only the top canvas will be rendered.
+ * @method __onMouseMove
+ * @param e {Event} Event object fired on mousemove
+ *
+ */
+ __onMouseMove: function (e) {
+
+ var target, pointer;
+
+ if (this.isDrawingMode) {
+ if (this._isCurrentlyDrawing) {
+ pointer = this.getPointer(e);
+ this.freeDrawing._captureDrawingPath(pointer);
+
+ // redraw curve
+ // clear top canvas
+ this.clearContext(this.contextTop);
+ this.freeDrawing._render(this.contextTop);
+ }
+ this.fire('mouse:move', { e: e });
+ return;
+ }
+
+ var groupSelector = this._groupSelector;
+
+ // We initially clicked in an empty area, so we draw a box for multiple selection.
+ if (groupSelector !== null) {
+ pointer = getPointer(e);
+
+ groupSelector.left = pointer.x - this._offset.left - groupSelector.ex;
+ groupSelector.top = pointer.y - this._offset.top - groupSelector.ey;
+ this.renderTop();
+ }
+ else if (!this._currentTransform) {
+
+ // alias style to elimintate unnecessary lookup
+ var style = this.upperCanvasEl.style;
+
+ // Here we are hovering the canvas then we will determine
+ // what part of the pictures we are hovering to change the caret symbol.
+ // We won't do that while dragging or rotating in order to improve the
+ // performance.
+ target = this.findTarget(e);
+
+ if (!target) {
+ // image/text was hovered-out from, we remove its borders
+ for (var i = this._objects.length; i--; ) {
+ if (this._objects[i] && !this._objects[i].active) {
+ this._objects[i].setActive(false);
+ }
+ }
+ style.cursor = this.defaultCursor;
+ }
+ else {
+ // set proper cursor
+ this._setCursorFromEvent(e, target);
+ }
+ }
+ else {
+ // object is being transformed (scaled/rotated/moved/etc.)
+ pointer = getPointer(e);
+
+ var x = pointer.x,
+ y = pointer.y;
+
+ this._currentTransform.target.isMoving = true;
+
+ if (this._currentTransform.action === 'rotate') {
+ // rotate object only if shift key is not pressed
+ // and if it is not a group we are transforming
+
+ if (!e.shiftKey) {
+ this._rotateObject(x, y);
+
+ this.fire('object:rotating', {
+ target: this._currentTransform.target,
+ e: e
+ });
+ this._currentTransform.target.fire('rotating', { e: e });
+ }
+ if (!this._currentTransform.target.hasRotatingPoint) {
+ this._scaleObject(x, y);
+ this.fire('object:scaling', {
+ target: this._currentTransform.target,
+ e: e
+ });
+ this._currentTransform.target.fire('scaling', { e: e });
+ }
+ }
+ else if (this._currentTransform.action === 'scale') {
+ this._scaleObject(x, y);
+ this.fire('object:scaling', {
+ target: this._currentTransform.target,
+ e: e
+ });
+ this._currentTransform.target.fire('scaling', { e: e });
+ }
+ else if (this._currentTransform.action === 'scaleX') {
+ this._scaleObject(x, y, 'x');
+
+ this.fire('object:scaling', {
+ target: this._currentTransform.target,
+ e: e
+ });
+ this._currentTransform.target.fire('scaling', { e: e });
+ }
+ else if (this._currentTransform.action === 'scaleY') {
+ this._scaleObject(x, y, 'y');
+
+ this.fire('object:scaling', {
+ target: this._currentTransform.target,
+ e: e
+ });
+ this._currentTransform.target.fire('scaling', { e: e });
+ }
+ else {
+ this._translateObject(x, y);
+
+ this.fire('object:moving', {
+ target: this._currentTransform.target,
+ e: e
+ });
+
+ this._setCursor(this.moveCursor);
+
+ this._currentTransform.target.fire('moving', { e: e });
+ }
+ // only commit here. when we are actually moving the pictures
+ this.renderAll();
+ }
+ this.fire('mouse:move', { target: target, e: e });
+ target && target.fire('mousemove', { e: e });
+ },
+
+ /**
+ * Applies one implementation of 'point inside polygon' algorithm
+ * @method containsPoint
+ * @param e { Event } event object
+ * @param target { fabric.Object } object to test against
+ * @return {Boolean} true if point contains within area of given object
+ */
+ containsPoint: function (e, target) {
+ var pointer = this.getPointer(e),
+ xy = this._normalizePointer(target, pointer),
+ x = xy.x,
+ y = xy.y;
+
+ // http://www.geog.ubc.ca/courses/klink/gis.notes/ncgia/u32.html
+ // http://idav.ucdavis.edu/~okreylos/TAship/Spring2000/PointInPolygon.html
+
+ // we iterate through each object. If target found, return it.
+ var iLines = target._getImageLines(target.oCoords),
+ xpoints = target._findCrossPoints(x, y, iLines);
+
+ // if xcount is odd then we clicked inside the object
+ // For the specific case of square images xcount === 1 in all true cases
+ if ((xpoints && xpoints % 2 === 1) || target._findTargetCorner(e, this._offset)) {
+ return true;
+ }
+ return false;
+ },
+
+ /**
+ * @private
+ * @method _normalizePointer
+ */
+ _normalizePointer: function (object, pointer) {
+
+ var activeGroup = this.getActiveGroup(),
+ x = pointer.x,
+ y = pointer.y;
+
+ var isObjectInGroup = (
+ activeGroup &&
+ object.type !== 'group' &&
+ activeGroup.contains(object)
+ );
+
+ if (isObjectInGroup) {
+ x -= activeGroup.left;
+ y -= activeGroup.top;
+ }
+ return { x: x, y: y };
+ },
+
+ /**
+ * @private
+ * @method _isTargetTransparent
+ */
+ _isTargetTransparent: function (target, x, y) {
+ var cacheContext = this.contextCache;
+
+ var hasBorders = target.hasBorders, transparentCorners = target.transparentCorners;
+ target.hasBorders = target.transparentCorners = false;
+
+ this._draw(cacheContext, target);
+
+ target.hasBorders = hasBorders;
+ target.transparentCorners = transparentCorners;
+
+ // If tolerance is > 0 adjust start coords to take into account. If moves off Canvas fix to 0
+ if (this.targetFindTolerance > 0) {
+ if (x > this.targetFindTolerance) {
+ x -= this.targetFindTolerance;
+ }
+ else {
+ x = 0;
+ }
+ if (y > this.targetFindTolerance) {
+ y -= this.targetFindTolerance;
+ }
+ else {
+ y = 0;
+ }
+ }
+
+ var isTransparent = true;
+ var imageData = cacheContext.getImageData(
+ x, y, (this.targetFindTolerance * 2) || 1, (this.targetFindTolerance * 2) || 1);
+
+ // Split image data - for tolerance > 1, pixelDataSize = 4;
+ for (var i = 3; i < imageData.data.length; i += 4) {
+ var temp = imageData.data[i];
+ isTransparent = temp <= 0;
+ if (isTransparent === false) break; //Stop if colour found
+ }
+
+ imageData = null;
+ this.clearContext(cacheContext);
+ return isTransparent;
+ },
+
+ /**
+ * @private
+ * @method _shouldClearSelection
+ */
+ _shouldClearSelection: function (e) {
+ var target = this.findTarget(e),
+ activeGroup = this.getActiveGroup();
+ return (
+ !target || (
+ target &&
+ activeGroup &&
+ !activeGroup.contains(target) &&
+ activeGroup !== target &&
+ !e.shiftKey
+ )
+ );
+ },
+
+ /**
+ * @private
+ * @method _setupCurrentTransform
+ */
+ _setupCurrentTransform: function (e, target) {
+ var action = 'drag',
+ corner,
+ pointer = getPointer(e);
+
+ if ((corner = target._findTargetCorner(e, this._offset))) {
+ action = (corner === 'ml' || corner === 'mr')
+ ? 'scaleX'
+ : (corner === 'mt' || corner === 'mb')
+ ? 'scaleY'
+ : corner === 'mtr'
+ ? 'rotate'
+ : (target.hasRotatingPoint)
+ ? 'scale'
+ : 'rotate';
+ }
+
+ this._currentTransform = {
+ target: target,
+ action: action,
+ scaleX: target.scaleX,
+ scaleY: target.scaleY,
+ offsetX: pointer.x - target.left,
+ offsetY: pointer.y - target.top,
+ ex: pointer.x,
+ ey: pointer.y,
+ left: target.left,
+ top: target.top,
+ theta: degreesToRadians(target.angle),
+ width: target.width * target.scaleX
+ };
+
+ this._currentTransform.original = {
+ left: target.left,
+ top: target.top
+ };
+ },
+
+ /**
+ * @private
+ * @method _handleGroupLogic
+ */
+ _handleGroupLogic: function (e, target) {
+ if (target === this.getActiveGroup()) {
+ // if it's a group, find target again, this time skipping group
+ target = this.findTarget(e, true);
+ // if even object is not found, bail out
+ if (!target || target.isType('group')) {
+ return;
+ }
+ }
+ var activeGroup = this.getActiveGroup();
+ if (activeGroup) {
+ if (activeGroup.contains(target)) {
+ activeGroup.removeWithUpdate(target);
+ this._resetObjectTransform(activeGroup);
+ target.setActive(false);
+ if (activeGroup.size() === 1) {
+ // remove group alltogether if after removal it only contains 1 object
+ this.discardActiveGroup();
+ }
+ }
+ else {
+ activeGroup.addWithUpdate(target);
+ this._resetObjectTransform(activeGroup);
+ }
+ this.fire('selection:created', { target: activeGroup, e: e });
+ activeGroup.setActive(true);
+ }
+ else {
+ // group does not exist
+ if (this._activeObject) {
+ // only if there's an active object
+ if (target !== this._activeObject) {
+ // and that object is not the actual target
+ var group = new fabric.Group([ this._activeObject, target ]);
+ this.setActiveGroup(group);
+ activeGroup = this.getActiveGroup();
+ }
+ }
+ // activate target object in any case
+ target.setActive(true);
+ }
+
+ if (activeGroup) {
+ activeGroup.saveCoords();
+ }
+ },
+
+ /**
+ * Translates object by "setting" its left/top
+ * @method _translateObject
+ * @param x {Number} pointer's x coordinate
+ * @param y {Number} pointer's y coordinate
+ */
+ _translateObject: function (x, y) {
+ var target = this._currentTransform.target;
+
+ if (!target.get('lockMovementX')) {
+ target.set('left', x - this._currentTransform.offsetX);
+ }
+ if (!target.get('lockMovementY')) {
+ target.set('top', y - this._currentTransform.offsetY);
+ }
+ },
+
+ /**
+ * Scales object by invoking its scaleX/scaleY methods
+ * @method _scaleObject
+ * @param x {Number} pointer's x coordinate
+ * @param y {Number} pointer's y coordinate
+ * @param by {String} Either 'x' or 'y' - specifies dimension constraint by which to scale an object.
+ * When not provided, an object is scaled by both dimensions equally
+ */
+ _scaleObject: function (x, y, by) {
+ var t = this._currentTransform,
+ offset = this._offset,
+ target = t.target;
+
+ var lockScalingX = target.get('lockScalingX'),
+ lockScalingY = target.get('lockScalingY');
+
+ if (lockScalingX && lockScalingY) return;
+
+ var lastLen = sqrt(pow(t.ey - t.top - offset.top, 2) + pow(t.ex - t.left - offset.left, 2)),
+ curLen = sqrt(pow(y - t.top - offset.top, 2) + pow(x - t.left - offset.left, 2));
+
+ target._scaling = true;
+
+ if (!by) {
+ if (!lockScalingX) {
+ target.set('scaleX', t.scaleX * curLen/lastLen);
+ }
+ if (!lockScalingY) {
+ target.set('scaleY', t.scaleY * curLen/lastLen);
+ }
+ }
+ else if (by === 'x' && !target.get('lockUniScaling')) {
+ lockScalingX || target.set('scaleX', t.scaleX * curLen/lastLen);
+ }
+ else if (by === 'y' && !target.get('lockUniScaling')) {
+ lockScalingY || target.set('scaleY', t.scaleY * curLen/lastLen);
+ }
+ },
+
+ /**
+ * Rotates object by invoking its rotate method
+ * @method _rotateObject
+ * @param x {Number} pointer's x coordinate
+ * @param y {Number} pointer's y coordinate
+ */
+ _rotateObject: function (x, y) {
+
+ var t = this._currentTransform,
+ o = this._offset;
+
+ if (t.target.get('lockRotation')) return;
+
+ var lastAngle = atan2(t.ey - t.top - o.top, t.ex - t.left - o.left),
+ curAngle = atan2(y - t.top - o.top, x - t.left - o.left);
+
+ t.target.angle = radiansToDegrees(curAngle - lastAngle + t.theta);
+ },
+
+ /**
+ * @method _setCursor
+ */
+ _setCursor: function (value) {
+ this.upperCanvasEl.style.cursor = value;
+ },
+
+ /**
+ * @private
+ * @method _resetObjectTransform:
+ */
+ _resetObjectTransform: function (target) {
+ target.scaleX = 1;
+ target.scaleY = 1;
+ target.setAngle(0);
+ },
+
+ /**
+ * Sets the cursor depending on where the canvas is being hovered.
+ * Note: very buggy in Opera
+ * @method _setCursorFromEvent
+ * @param e {Event} Event object
+ * @param target {Object} Object that the mouse is hovering, if so.
+ */
+ _setCursorFromEvent: function (e, target) {
+ var s = this.upperCanvasEl.style;
+ if (!target) {
+ s.cursor = this.defaultCursor;
+ return false;
+ }
+ else {
+ var activeGroup = this.getActiveGroup();
+ // only show proper corner when group selection is not active
+ var corner = !!target._findTargetCorner
+ && (!activeGroup || !activeGroup.contains(target))
+ && target._findTargetCorner(e, this._offset);
+
+ if (!corner) {
+ s.cursor = this.hoverCursor;
+ }
+ else {
+ if (corner in cursorMap) {
+ s.cursor = cursorMap[corner];
+ } else if (corner === 'mtr' && target.hasRotatingPoint) {
+ s.cursor = this.rotationCursor;
+ } else {
+ s.cursor = this.defaultCursor;
+ return false;
+ }
+ }
+ }
+ return true;
+ },
+
+ /**
+ * @method _drawSelection
+ * @private
+ */
+ _drawSelection: function () {
+ var ctx = this.contextTop,
+ groupSelector = this._groupSelector,
+ left = groupSelector.left,
+ top = groupSelector.top,
+ aleft = abs(left),
+ atop = abs(top);
+
+ ctx.fillStyle = this.selectionColor;
+
+ ctx.fillRect(
+ groupSelector.ex - ((left > 0) ? 0 : -left),
+ groupSelector.ey - ((top > 0) ? 0 : -top),
+ aleft,
+ atop
+ );
+
+ ctx.lineWidth = this.selectionLineWidth;
+ ctx.strokeStyle = this.selectionBorderColor;
+
+ // selection border
+ if (this.selectionDashArray.length > 1) {
+ var px = groupSelector.ex + STROKE_OFFSET - ((left > 0) ? 0: aleft);
+ var py = groupSelector.ey + STROKE_OFFSET - ((top > 0) ? 0: atop);
+ ctx.beginPath();
+ this.drawDashedLine(ctx, px, py, px+aleft, py, this.selectionDashArray);
+ this.drawDashedLine(ctx, px, py+atop-1, px+aleft, py+atop-1, this.selectionDashArray);
+ this.drawDashedLine(ctx, px, py, px, py+atop, this.selectionDashArray);
+ this.drawDashedLine(ctx, px+aleft-1, py, px+aleft-1, py+atop, this.selectionDashArray);
+ ctx.closePath();
+ ctx.stroke();
+ }
+ else {
+ ctx.strokeRect(
+ groupSelector.ex + STROKE_OFFSET - ((left > 0) ? 0 : aleft),
+ groupSelector.ey + STROKE_OFFSET - ((top > 0) ? 0 : atop),
+ aleft,
+ atop
+ );
+ }
+ },
+
+ /**
+ * Draws a dashed line between two points
+ *
+ * This method is used to draw dashed line around selection area.
+ * See dotted stroke in canvas
+ *
+ * @method drawDashedLine
+ * @param ctx {Canvas} context
+ * @param x {Number} start x coordinate
+ * @param y {Number} start y coordinate
+ * @param x2 {Number} end x coordinate
+ * @param y2 {Number} end y coordinate
+ * @param da {Array} dash array pattern
+ */
+ drawDashedLine: function(ctx, x, y, x2, y2, da) {
+ var dx = x2 - x,
+ dy = y2 - y,
+ len = Math.sqrt(dx*dx + dy*dy),
+ rot = Math.atan2(dy, dx),
+ dc = da.length,
+ di = 0,
+ draw = true;
+
+ ctx.save();
+ ctx.translate(x, y);
+ ctx.moveTo(0, 0);
+ ctx.rotate(rot);
+
+ x = 0;
+ while (len > x) {
+ x += da[di++ % dc];
+ if (x > len) {
+ x = len;
+ }
+ ctx[draw ? 'lineTo' : 'moveTo'](x, 0);
+ draw = !draw;
+ }
+
+ ctx.restore();
+ },
+
+ /**
+ * @private
+ * @method _findSelectedObjects
+ */
+ _findSelectedObjects: function (e) {
+ var group = [ ],
+ x1 = this._groupSelector.ex,
+ y1 = this._groupSelector.ey,
+ x2 = x1 + this._groupSelector.left,
+ y2 = y1 + this._groupSelector.top,
+ currentObject,
+ selectionX1Y1 = new fabric.Point(min(x1, x2), min(y1, y2)),
+ selectionX2Y2 = new fabric.Point(max(x1, x2), max(y1, y2));
+
+ for (var i = 0, len = this._objects.length; i < len; ++i) {
+ currentObject = this._objects[i];
+
+ if (!currentObject) continue;
+
+ if (currentObject.intersectsWithRect(selectionX1Y1, selectionX2Y2) ||
+ currentObject.isContainedWithinRect(selectionX1Y1, selectionX2Y2)) {
+
+ if (this.selection && currentObject.selectable) {
+ currentObject.setActive(true);
+ group.push(currentObject);
+ }
+ }
+ }
+
+ // do not create group for 1 element only
+ if (group.length === 1) {
+ this.setActiveObject(group[0], e);
+ }
+ else if (group.length > 1) {
+ group = new fabric.Group(group);
+ this.setActiveGroup(group);
+ group.saveCoords();
+ this.fire('selection:created', { target: group });
+ }
+
+ this.renderAll();
+ },
+
+ /**
+ * Method that determines what object we are clicking on
+ * @method findTarget
+ * @param {Event} e mouse event
+ * @param {Boolean} skipGroup when true, group is skipped and only objects are traversed through
+ */
+ findTarget: function (e, skipGroup) {
+
+ var target,
+ pointer = this.getPointer(e);
+
+ if (this.controlsAboveOverlay &&
+ this.lastRenderedObjectWithControlsAboveOverlay &&
+ this.containsPoint(e, this.lastRenderedObjectWithControlsAboveOverlay)) {
+ target = this.lastRenderedObjectWithControlsAboveOverlay;
+ return target;
+ }
+
+ // first check current group (if one exists)
+ var activeGroup = this.getActiveGroup();
+ if (activeGroup && !skipGroup && this.containsPoint(e, activeGroup)) {
+ target = activeGroup;
+ return target;
+ }
+
+ // then check all of the objects on canvas
+ // Cache all targets where their bounding box contains point.
+ var possibleTargets = [];
+ for (var i = this._objects.length; i--; ) {
+ if (this._objects[i] && this.containsPoint(e, this._objects[i])) {
+ if (this.perPixelTargetFind || this._objects[i].perPixelTargetFind) {
+ possibleTargets[possibleTargets.length] = this._objects[i];
+ }
+ else {
+ target = this._objects[i];
+ this.relatedTarget = target;
+ break;
+ }
+ }
+ }
+ for (var j = 0, len = possibleTargets.length; j < len; j++) {
+ pointer = this.getPointer(e);
+ var isTransparent = this._isTargetTransparent(possibleTargets[j], pointer.x, pointer.y);
+ if (!isTransparent) {
+ target = possibleTargets[j];
+ this.relatedTarget = target;
+ break;
+ }
+ }
+ if (target && target.selectable) {
+ return target;
+ }
+ },
+
+ /**
+ * Returns pointer coordinates relative to canvas.
+ * @method getPointer
+ * @param {Event} e
+ * @return {Object} object with "x" and "y" number values
+ */
+ getPointer: function (e) {
+ var pointer = getPointer(e);
+ return {
+ x: pointer.x - this._offset.left,
+ y: pointer.y - this._offset.top
+ };
+ },
+
+ /**
+ * @private
+ * @method _createUpperCanvas
+ * @param {HTMLElement|String} canvasEl Canvas element
+ * @throws {CANVAS_INIT_ERROR} If canvas can not be initialized
+ */
+ _createUpperCanvas: function () {
+ this.upperCanvasEl = this._createCanvasElement();
+ this.upperCanvasEl.className = 'upper-canvas';
+
+ this.wrapperEl.appendChild(this.upperCanvasEl);
+
+ this._applyCanvasStyle(this.upperCanvasEl);
+ this.contextTop = this.upperCanvasEl.getContext('2d');
+ },
+
+ /**
+ * @private
+ * @method _createCacheCanvas
+ */
+ _createCacheCanvas: function () {
+ this.cacheCanvasEl = this._createCanvasElement();
+ this.cacheCanvasEl.setAttribute('width', this.width);
+ this.cacheCanvasEl.setAttribute('height', this.height);
+ this.contextCache = this.cacheCanvasEl.getContext('2d');
+ },
+
+ /**
+ * @private
+ * @method _initWrapperElement
+ * @param {Number} width
+ * @param {Number} height
+ */
+ _initWrapperElement: function () {
+ this.wrapperEl = fabric.util.wrapElement(this.lowerCanvasEl, 'div', {
+ 'class': this.containerClass
+ });
+ fabric.util.setStyle(this.wrapperEl, {
+ width: this.getWidth() + 'px',
+ height: this.getHeight() + 'px',
+ position: 'relative'
+ });
+ fabric.util.makeElementUnselectable(this.wrapperEl);
+ },
+
+ /**
+ * @private
+ * @method _applyCanvasStyle
+ * @param {Element} element
+ */
+ _applyCanvasStyle: function (element) {
+ var width = this.getWidth() || element.width,
+ height = this.getHeight() || element.height;
+
+ fabric.util.setStyle(element, {
+ position: 'absolute',
+ width: width + 'px',
+ height: height + 'px',
+ left: 0,
+ top: 0
+ });
+ element.width = width;
+ element.height = height;
+ fabric.util.makeElementUnselectable(element);
+ },
+
+ /**
+ * Returns context of canvas where object selection is drawn
+ * @method getSelectionContext
+ * @return {CanvasRenderingContext2D}
+ */
+ getSelectionContext: function() {
+ return this.contextTop;
+ },
+
+ /**
+ * Returns <canvas> element on which object selection is drawn
+ * @method getSelectionElement
+ * @return {HTMLCanvasElement}
+ */
+ getSelectionElement: function () {
+ return this.upperCanvasEl;
+ },
+
+ /**
+ * Sets given object as active
+ * @method setActiveObject
+ * @param object {fabric.Object} Object to set as an active one
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ setActiveObject: function (object, e) {
+ if (this._activeObject) {
+ this._activeObject.setActive(false);
+ }
+ this._activeObject = object;
+ object.setActive(true);
+
+ this.renderAll();
+
+ this.fire('object:selected', { target: object, e: e });
+ object.fire('selected', { e: e });
+ return this;
+ },
+
+ /**
+ * Returns currently active object
+ * @method getActiveObject
+ * @return {fabric.Object} active object
+ */
+ getActiveObject: function () {
+ return this._activeObject;
+ },
+
+ /**
+ * Discards currently active object
+ * @method discardActiveObject
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ discardActiveObject: function () {
+ if (this._activeObject) {
+ this._activeObject.setActive(false);
+ }
+ this._activeObject = null;
+ return this;
+ },
+
+ /**
+ * Sets active group to a speicified one
+ * @method setActiveGroup
+ * @param {fabric.Group} group Group to set as a current one
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ setActiveGroup: function (group) {
+ this._activeGroup = group;
+ if (group) {
+ group.canvas = this;
+ group.setActive(true);
+ }
+ return this;
+ },
+
+ /**
+ * Returns currently active group
+ * @method getActiveGroup
+ * @return {fabric.Group} Current group
+ */
+ getActiveGroup: function () {
+ return this._activeGroup;
+ },
+
+ /**
+ * Removes currently active group
+ * @method discardActiveGroup
+ * @return {fabric.Canvas} thisArg
+ */
+ discardActiveGroup: function () {
+ var g = this.getActiveGroup();
+ if (g) {
+ g.destroy();
+ }
+ return this.setActiveGroup(null);
+ },
+
+ /**
+ * Deactivates all objects by calling their setActive(false)
+ * @method deactivateAll
+ * @return {fabric.Canvas} thisArg
+ */
+ deactivateAll: function () {
+ var allObjects = this.getObjects(),
+ i = 0,
+ len = allObjects.length;
+ for ( ; i < len; i++) {
+ allObjects[i].setActive(false);
+ }
+ this.discardActiveGroup();
+ this.discardActiveObject();
+ return this;
+ },
+
+ /**
+ * Deactivates all objects and dispatches appropriate events
+ * @method deactivateAllWithDispatch
+ * @return {fabric.Canvas} thisArg
+ */
+ deactivateAllWithDispatch: function () {
+ var activeObject = this.getActiveGroup() || this.getActiveObject();
+ if (activeObject) {
+ this.fire('before:selection:cleared', { target: activeObject });
+ }
+ this.deactivateAll();
+ if (activeObject) {
+ this.fire('selection:cleared');
+ }
+ return this;
+ }
+ };
+
+ fabric.Canvas.prototype.toString = fabric.StaticCanvas.prototype.toString;
+ extend(fabric.Canvas.prototype, InteractiveMethods);
+
+ // iterating manually to workaround Opera's bug
+ // where "prototype" property is enumerable and overrides existing prototype
+ for (var prop in fabric.StaticCanvas) {
+ if (prop !== 'prototype') {
+ fabric.Canvas[prop] = fabric.StaticCanvas[prop];
+ }
+ }
+
+ if (fabric.isTouchSupported) {
+ fabric.Canvas.prototype._setCursorFromEvent = function() { };
+ }
+
+ /**
+ * @class fabric.Element
+ * @alias fabric.Canvas
+ * @deprecated Use {@link fabric.Canvas} instead.
+ * @constructor
+ */
+ fabric.Element = fabric.Canvas;
+})();
+fabric.util.object.extend(fabric.StaticCanvas.prototype, {
+
+ /**
+ * Animation duration (in ms) for fx* methods
+ * @type Number
+ */
+ FX_DURATION: 500,
+
+ /**
+ * Centers object horizontally with animation.
+ * @method fxCenterObjectH
+ * @param {fabric.Object} object Object to center
+ * @param {Object} [callbacks] Callbacks object with optional "onComplete" and/or "onChange" properties
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ fxCenterObjectH: function (object, callbacks) {
+ callbacks = callbacks || { };
+
+ var empty = function() { },
+ onComplete = callbacks.onComplete || empty,
+ onChange = callbacks.onChange || empty,
+ _this = this;
+
+ fabric.util.animate({
+ startValue: object.get('left'),
+ endValue: this.getCenter().left,
+ duration: this.FX_DURATION,
+ onChange: function(value) {
+ object.set('left', value);
+ _this.renderAll();
+ onChange();
+ },
+ onComplete: function() {
+ object.setCoords();
+ onComplete();
+ }
+ });
+
+ return this;
+ },
+
+ /**
+ * Centers object vertically with animation.
+ * @method fxCenterObjectV
+ * @param {fabric.Object} object Object to center
+ * @param {Object} [callbacks] Callbacks object with optional "onComplete" and/or "onChange" properties
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ fxCenterObjectV: function (object, callbacks) {
+ callbacks = callbacks || { };
+
+ var empty = function() { },
+ onComplete = callbacks.onComplete || empty,
+ onChange = callbacks.onChange || empty,
+ _this = this;
+
+ fabric.util.animate({
+ startValue: object.get('top'),
+ endValue: this.getCenter().top,
+ duration: this.FX_DURATION,
+ onChange: function(value) {
+ object.set('top', value);
+ _this.renderAll();
+ onChange();
+ },
+ onComplete: function() {
+ object.setCoords();
+ onComplete();
+ }
+ });
+
+ return this;
+ },
+
+ /**
+ * Same as `fabric.Canvas#remove` but animated
+ * @method fxRemove
+ * @param {fabric.Object} object Object to remove
+ * @param {Function} callback Callback, invoked on effect completion
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ fxRemove: function (object, callbacks) {
+ callbacks = callbacks || { };
+
+ var empty = function() { },
+ onComplete = callbacks.onComplete || empty,
+ onChange = callbacks.onChange || empty,
+ _this = this;
+
+ fabric.util.animate({
+ startValue: object.get('opacity'),
+ endValue: 0,
+ duration: this.FX_DURATION,
+ onStart: function() {
+ object.setActive(false);
+ },
+ onChange: function(value) {
+ object.set('opacity', value);
+ _this.renderAll();
+ onChange();
+ },
+ onComplete: function () {
+ _this.remove(object);
+ onComplete();
+ }
+ });
+
+ return this;
+ }
+});
+fabric.util.object.extend(fabric.StaticCanvas.prototype, {
+
+ /**
+ * Populates canvas with data from the specified dataless JSON
+ * JSON format must conform to the one of `fabric.Canvas#toDatalessJSON`
+ * @method loadFromDatalessJSON
+ * @param {String|Object} json JSON string or object
+ * @param {Function} callback Callback, invoked when json is parsed
+ * and corresponding objects (e.g: fabric.Image)
+ * are initialized
+ * @return {fabric.Canvas} instance
+ * @chainable
+ */
+ loadFromDatalessJSON: function (json, callback) {
+
+ if (!json) {
+ return;
+ }
+
+ // serialize if it wasn't already
+ var serialized = (typeof json === 'string')
+ ? JSON.parse(json)
+ : json;
+
+ if (!serialized || (serialized && !serialized.objects)) return;
+
+ this.clear();
+
+ // TODO: test this
+ this.backgroundColor = serialized.background;
+ this._enlivenDatalessObjects(serialized.objects, callback);
+ },
+
+ /**
+ * @method _enlivenDatalessObjects
+ * @param {Array} objects
+ * @param {Function} callback
+ */
+ _enlivenDatalessObjects: function (objects, callback) {
+
+ /** @ignore */
+ function onObjectLoaded(object, index) {
+ _this.insertAt(object, index, true);
+ object.setCoords();
+ if (++numLoadedObjects === numTotalObjects) {
+ callback && callback();
+ }
+ }
+
+ /** @ignore */
+ function loadObject(obj, index) {
+
+ var pathProp = obj.paths ? 'paths' : 'path';
+ var path = obj[pathProp];
+
+ delete obj[pathProp];
+
+ if (typeof path !== 'string') {
+ if (obj.type === 'image' || obj.type === 'group') {
+ fabric[fabric.util.string.capitalize(obj.type)].fromObject(obj, function (o) {
+ onObjectLoaded(o, index);
+ });
+ }
+ else {
+ var klass = fabric[fabric.util.string.camelize(fabric.util.string.capitalize(obj.type))];
+ if (!klass || !klass.fromObject) return;
+
+ // restore path
+ if (path) {
+ obj[pathProp] = path;
+ }
+ onObjectLoaded(klass.fromObject(obj), index);
+ }
+ }
+ else {
+ if (obj.type === 'image') {
+ fabric.util.loadImage(path, function (image) {
+ var oImg = new fabric.Image(image);
+
+ oImg.setSourcePath(path);
+
+ fabric.util.object.extend(oImg, obj);
+ oImg.setAngle(obj.angle);
+
+ onObjectLoaded(oImg, index);
+ });
+ }
+ else if (obj.type === 'text') {
+
+ if (obj.useNative) {
+ onObjectLoaded(fabric.Text.fromObject(obj), index);
+ }
+ else {
+ obj.path = path;
+ var object = fabric.Text.fromObject(obj);
+ /** @ignore */
+ var onscriptload = function () {
+ // TODO (kangax): find out why Opera refuses to work without this timeout
+ if (Object.prototype.toString.call(fabric.window.opera) === '[object Opera]') {
+ setTimeout(function () {
+ onObjectLoaded(object, index);
+ }, 500);
+ }
+ else {
+ onObjectLoaded(object, index);
+ }
+ };
+
+ fabric.util.getScript(path, onscriptload);
+ }
+ }
+ else {
+ fabric.loadSVGFromURL(path, function (elements) {
+ var object = fabric.util.groupSVGElements(elements, obj, path);
+
+ // copy parameters from serialied json to object (left, top, scaleX, scaleY, etc.)
+ // skip this step if an object is a PathGroup, since we already passed it options object before
+ if (!(object instanceof fabric.PathGroup)) {
+ fabric.util.object.extend(object, obj);
+ if (typeof obj.angle !== 'undefined') {
+ object.setAngle(obj.angle);
+ }
+ }
+
+ onObjectLoaded(object, index);
+ });
+ }
+ }
+ }
+
+ var _this = this,
+ numLoadedObjects = 0,
+ numTotalObjects = objects.length;
+
+ if (numTotalObjects === 0 && callback) {
+ callback();
+ }
+
+ try {
+ objects.forEach(loadObject, this);
+ }
+ catch(e) {
+ fabric.log(e.message);
+ }
+ },
+
+ /**
+ * Populates canvas with data from the specified JSON
+ * JSON format must conform to the one of `fabric.Canvas#toJSON`
+ * @method loadFromJSON
+ * @param {String|Object} json JSON string or object
+ * @param {Function} callback Callback, invoked when json is parsed
+ * and corresponding objects (e.g: fabric.Image)
+ * are initialized
+ * @return {fabric.Canvas} instance
+ * @chainable
+ */
+ loadFromJSON: function (json, callback) {
+ if (!json) return;
+
+ // serialize if it wasn't already
+ var serialized = (typeof json === 'string')
+ ? JSON.parse(json)
+ : json;
+
+ if (!serialized || (serialized && !serialized.objects)) return;
+
+ this.clear();
+ var _this = this;
+ this._enlivenObjects(serialized.objects, function () {
+ _this.backgroundColor = serialized.background;
+
+ if (serialized.backgroundImage) {
+ _this.setBackgroundImage(serialized.backgroundImage, function() {
+
+ _this.backgroundImageOpacity = serialized.backgroundImageOpacity;
+ _this.backgroundImageStretch = serialized.backgroundImageStretch;
+
+ _this.renderAll();
+
+ callback && callback();
+ });
+ return;
+ }
+ if (serialized.overlayImage) {
+ _this.setOverlayImage(serialized.overlayImage, function() {
+
+ _this.overlayImageLeft = serialized.overlayImageLeft || 0;
+ _this.overlayImageTop = serialized.overlayImageTop || 0;
+
+ _this.renderAll();
+
+ callback && callback();
+ });
+ return;
+ }
+ callback && callback();
+ });
+
+ return this;
+ },
+
+ /**
+ * @method _enlivenObjects
+ * @param {Array} objects
+ * @param {Function} callback
+ */
+ _enlivenObjects: function (objects, callback) {
+ var _this = this;
+ fabric.util.enlivenObjects(objects, function(enlivenedObjects) {
+ enlivenedObjects.forEach(function(obj, index) {
+ _this.insertAt(obj, index, true);
+ });
+ callback && callback();
+ });
+ },
+
+ /**
+ * @private
+ * @method _toDataURL
+ * @param {String} format
+ * @param {Function} callback
+ */
+ _toDataURL: function (format, callback) {
+ this.clone(function (clone) {
+ callback(clone.toDataURL(format));
+ });
+ },
+
+ /**
+ * @private
+ * @method _toDataURLWithMultiplier
+ * @param {String} format
+ * @param {Number} multiplier
+ * @param {Function} callback
+ */
+ _toDataURLWithMultiplier: function (format, multiplier, callback) {
+ this.clone(function (clone) {
+ callback(clone.toDataURLWithMultiplier(format, multiplier));
+ });
+ },
+
+ /**
+ * Clones canvas instance
+ * @method clone
+ * @param {Object} [callback] Receives cloned instance as a first argument
+ */
+ clone: function (callback) {
+ var data = JSON.stringify(this);
+ this.cloneWithoutData(function(clone) {
+ clone.loadFromJSON(data, function() {
+ callback && callback(clone);
+ });
+ });
+ },
+
+ /**
+ * Clones canvas instance without cloning existing data.
+ * This essentially copies canvas dimensions, clipping properties, etc.
+ * but leaves data empty (so that you can populate it with your own)
+ * @method cloneWithoutData
+ * @param {Object} [callback] Receives cloned instance as a first argument
+ */
+ cloneWithoutData: function(callback) {
+ var el = fabric.document.createElement('canvas');
+
+ el.width = this.getWidth();
+ el.height = this.getHeight();
+
+ var clone = new fabric.Canvas(el);
+ clone.clipTo = this.clipTo;
+ if (this.backgroundImage) {
+ clone.setBackgroundImage(this.backgroundImage.src, function() {
+ clone.renderAll();
+ callback && callback(clone);
+ });
+ clone.backgroundImageOpacity = this.backgroundImageOpacity;
+ clone.backgroundImageStretch = this.backgroundImageStretch;
+ }
+ else {
+ callback && callback(clone);
+ }
+ }
+});
+(function(global) {
+
+ "use strict";
+
+ var fabric = global.fabric || (global.fabric = { }),
+ extend = fabric.util.object.extend,
+ toFixed = fabric.util.toFixed,
+ capitalize = fabric.util.string.capitalize,
+ getPointer = fabric.util.getPointer,
+ degreesToRadians = fabric.util.degreesToRadians;
+
+ if (fabric.Object) {
+ return;
+ }
+
+ var Image = global.Image;
+ try {
+ var NodeImage = (typeof require !== 'undefined') && require('canvas').Image;
+ if (NodeImage) {
+ Image = NodeImage;
+ }
+ }
+ catch(err) {
+ fabric.log(err);
+ }
+
+ /**
+ * Root object class from which all 2d shape classes inherit from
+ * @class Object
+ * @memberOf fabric
+ */
+ fabric.Object = fabric.util.createClass(/** @scope fabric.Object.prototype */ {
+
+ /**
+ * Type of an object (rect, circle, path, etc)
+ * @property
+ * @type String
+ */
+ type: 'object',
+
+ /**
+ * Object top offset
+ * @property
+ * @type Number
+ */
+ top: 0,
+
+ /**
+ * Object left offset
+ * @property
+ * @type Number
+ */
+ left: 0,
+
+ /**
+ * Object width
+ * @property
+ * @type Number
+ */
+ width: 0,
+
+ /**
+ * Object height
+ * @property
+ * @type Number
+ */
+ height: 0,
+
+ /**
+ * Object scale factor (horizontal)
+ * @property
+ * @type Number
+ */
+ scaleX: 1,
+
+ /**
+ * Object scale factor (vertical)
+ * @property
+ * @type Number
+ */
+ scaleY: 1,
+
+ /**
+ * When true, an object is rendered as flipped horizontally
+ * @property
+ * @type Boolean
+ */
+ flipX: false,
+
+ /**
+ * When true, an object is rendered as flipped vertically
+ * @property
+ * @type Boolean
+ */
+ flipY: false,
+
+ /**
+ * Opacity of an object
+ * @property
+ * @type Number
+ */
+ opacity: 1,
+
+ /**
+ * Angle of rotation of an object
+ * @property
+ * @type Number
+ */
+ angle: 0,
+
+ /**
+ * Size of object's corners
+ * @property
+ * @type Number
+ */
+ cornerSize: 12,
+
+ /**
+ * When true, object's corners are rendered as transparent inside (i.e. stroke instead of fill)
+ * @property
+ * @type Boolean
+ */
+ transparentCorners: true,
+
+ /**
+ * Padding between object and its borders
+ * @property
+ * @type Number
+ */
+ padding: 0,
+
+ /**
+ * Border color of an object (when it's active)
+ * @property
+ * @type String
+ */
+ borderColor: 'rgba(102,153,255,0.75)',
+
+ /**
+ * Corner color of an object (when it's active)
+ * @property
+ * @type String
+ */
+ cornerColor: 'rgba(102,153,255,0.5)',
+
+ /**
+ * Color of object's fill
+ * @property
+ * @type String
+ */
+ fill: 'rgb(0,0,0)',
+
+ /**
+ * Fill rule used to fill an object
+ * @property
+ * @type String
+ */
+ fillRule: 'source-over',
+
+ /**
+ * Overlay fill (takes precedence over fill value)
+ * @property
+ * @type String
+ */
+ overlayFill: null,
+
+ /**
+ * When `true`, an object is rendered via stroke
+ * @property
+ * @type String
+ */
+ stroke: null,
+
+ /**
+ * Width of a stroke used to render this object
+ * @property
+ * @type Number
+ */
+ strokeWidth: 1,
+
+ /**
+ * Array specifying dash pattern of an object's stroke
+ * @property
+ * @type Array
+ */
+ strokeDashArray: null,
+
+ /**
+ * Opacity of a border when moving an object
+ * @property
+ * @type Number
+ */
+ borderOpacityWhenMoving: 0.4,
+
+ /**
+ * Border scale factor
+ * @property
+ * @type Number
+ */
+ borderScaleFactor: 1,
+
+ /**
+ * Transform matrix
+ * @property
+ * @type Array
+ */
+ transformMatrix: null,
+
+ /**
+ * When set to `false`, an object can not be selected for modification (using either point-click-based or group-based selection)
+ * @property
+ * @type Boolean
+ */
+ selectable: true,
+
+ /**
+ * When set to `false`, object's controls are not displayed and can not be used to manipulate object
+ * @property
+ * @type Boolean
+ */
+ hasControls: true,
+
+ /**
+ * When set to `false`, object's borders are not rendered
+ * @property
+ * @type Boolean
+ */
+ hasBorders: true,
+
+ /**
+ * When set to `false`, object's rotating point will not be visible or selectable
+ * @property
+ * @type Boolean
+ */
+ hasRotatingPoint: false,
+
+ /**
+ * Offset for object's rotating point (when enabled)
+ * @property
+ * @type Number
+ */
+ rotatingPointOffset: 40,
+
+ /**
+ * When set to `true`, objects are "found" on canvas on per-pixel basis rather than according to bounding box
+ * @property
+ * @type Boolean
+ */
+ perPixelTargetFind: false,
+
+ /**
+ * When false, default values are not included in serialization result
+ * @property
+ * @type Boolean
+ */
+ includeDefaultValues: true,
+
+ /**
+ * List of properties to consider when checking if state of an object is changed (fabric.Object#hasStateChanged);
+ * as well as for history (undo/redo) purposes
+ * @property
+ * @type Array
+ */
+ stateProperties: (
+ 'top left width height scaleX scaleY flipX flipY ' +
+ 'angle opacity cornerSize fill overlayFill ' +
+ 'stroke strokeWidth strokeDashArray fillRule ' +
+ 'borderScaleFactor transformMatrix selectable'
+ ).split(' '),
+
+ /**
+ * Constructor
+ * @method initialize
+ * @param {Object} [options] Options object
+ */
+ initialize: function(options) {
+ if (options) {
+ this.setOptions(options);
+ }
+ },
+
+ /**
+ * @private
+ * @method _initGradient
+ */
+ _initGradient: function(options) {
+ if (options.fill && typeof options.fill === 'object' && !(options.fill instanceof fabric.Gradient)) {
+ this.set('fill', new fabric.Gradient(options.fill));
+ }
+ },
+
+ /**
+ * Sets object's properties from options
+ * @method setOptions
+ * @param {Object} [options]
+ */
+ setOptions: function(options) {
+ for (var prop in options) {
+ this.set(prop, options[prop]);
+ }
+ this._initGradient(options);
+ },
+
+ /**
+ * Transforms context when rendering an object
+ * @method transform
+ * @param {CanvasRenderingContext2D} ctx Context
+ */
+ transform: function(ctx) {
+ ctx.globalAlpha = this.opacity;
+ ctx.translate(this.left, this.top);
+ ctx.rotate(degreesToRadians(this.angle));
+ ctx.scale(
+ this.scaleX * (this.flipX ? -1 : 1),
+ this.scaleY * (this.flipY ? -1 : 1)
+ );
+ },
+
+ /**
+ * Returns an object representation of an instance
+ * @method toObject
+ * @param {Array} propertiesToInclude
+ * @return {Object} object representation of an instance
+ */
+ toObject: function(propertiesToInclude) {
+
+ var NUM_FRACTION_DIGITS = fabric.Object.NUM_FRACTION_DIGITS;
+
+ var object = {
+ type: this.type,
+ left: toFixed(this.left, NUM_FRACTION_DIGITS),
+ top: toFixed(this.top, NUM_FRACTION_DIGITS),
+ width: toFixed(this.width, NUM_FRACTION_DIGITS),
+ height: toFixed(this.height, NUM_FRACTION_DIGITS),
+ fill: (this.fill && this.fill.toObject) ? this.fill.toObject() : this.fill,
+ overlayFill: this.overlayFill,
+ stroke: this.stroke,
+ strokeWidth: this.strokeWidth,
+ strokeDashArray: this.strokeDashArray,
+ scaleX: toFixed(this.scaleX, NUM_FRACTION_DIGITS),
+ scaleY: toFixed(this.scaleY, NUM_FRACTION_DIGITS),
+ angle: toFixed(this.getAngle(), NUM_FRACTION_DIGITS),
+ flipX: this.flipX,
+ flipY: this.flipY,
+ opacity: toFixed(this.opacity, NUM_FRACTION_DIGITS),
+ selectable: this.selectable,
+ hasControls: this.hasControls,
+ hasBorders: this.hasBorders,
+ hasRotatingPoint: this.hasRotatingPoint,
+ transparentCorners: this.transparentCorners,
+ perPixelTargetFind: this.perPixelTargetFind
+ };
+
+ if (!this.includeDefaultValues) {
+ object = this._removeDefaultValues(object);
+ }
+ fabric.util.populateWithProperties(this, object, propertiesToInclude);
+
+ return object;
+ },
+
+ /**
+ * Returns (dataless) object representation of an instance
+ * @method toDatalessObject
+ * @param {Array} [propertiesToInclude]
+ * @return {Object} object representation of an instance
+ */
+ toDatalessObject: function(propertiesToInclude) {
+ // will be overwritten by subclasses
+ return this.toObject(propertiesToInclude);
+ },
+
+ /**
+ * Returns styles-string for svg-export
+ * @method getSvgStyles
+ * @return {String}
+ */
+ getSvgStyles: function() {
+ return [
+ "stroke: ", (this.stroke ? this.stroke : 'none'), "; ",
+ "stroke-width: ", (this.strokeWidth ? this.strokeWidth : '0'), "; ",
+ "stroke-dasharray: ", (this.strokeDashArray ? this.strokeDashArray.join(' ') : "; "),
+ "fill: ", (this.fill ? this.fill : 'none'), "; ",
+ "opacity: ", (this.opacity ? this.opacity : '1'), ";"
+ ].join("");
+ },
+
+ /**
+ * Returns transform-string for svg-export
+ * @method getSvgTransform
+ * @return {String}
+ */
+ getSvgTransform: function() {
+ var angle = this.getAngle();
+ var NUM_FRACTION_DIGITS = fabric.Object.NUM_FRACTION_DIGITS;
+
+ var translatePart = "translate(" +
+ toFixed(this.left, NUM_FRACTION_DIGITS) +
+ " " +
+ toFixed(this.top, NUM_FRACTION_DIGITS) +
+ ")";
+
+ var anglePart = angle !== 0
+ ? (" rotate(" + toFixed(angle, NUM_FRACTION_DIGITS) + ")")
+ : '';
+
+ var scalePart = (this.scaleX === 1 && this.scaleY === 1)
+ ? '' :
+ (" scale(" +
+ toFixed(this.scaleX, NUM_FRACTION_DIGITS) +
+ " " +
+ toFixed(this.scaleY, NUM_FRACTION_DIGITS) +
+ ")");
+
+ var flipXPart = this.flipX ? "matrix(-1 0 0 1 0 0) " : "";
+ var flipYPart = this.flipY ? "matrix(1 0 0 -1 0 0)" : "";
+
+ return [ translatePart, anglePart, scalePart, flipXPart, flipYPart ].join('');
+ },
+
+ /**
+ * @private
+ * @method _removeDefaultValues
+ */
+ _removeDefaultValues: function(object) {
+ var defaultOptions = fabric.Object.prototype.options;
+ if (defaultOptions) {
+ this.stateProperties.forEach(function(prop) {
+ if (object[prop] === defaultOptions[prop]) {
+ delete object[prop];
+ }
+ });
+ }
+ return object;
+ },
+
+ /**
+ * Returns true if an object is in its active state
+ * @return {Boolean} true if an object is in its active state
+ */
+ isActive: function() {
+ return !!this.active;
+ },
+
+ /**
+ * Sets state of an object - `true` makes it active, `false` - inactive
+ * @param {Boolean} active
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ setActive: function(active) {
+ this.active = !!active;
+ return this;
+ },
+
+ /**
+ * Returns a string representation of an instance
+ * @return {String}
+ */
+ toString: function() {
+ return "#";
+ },
+
+ /**
+ * Sets property to a given value
+ * @method set
+ * @param {String} name
+ * @param {Object|Function} value
+ * @return {fabric.Group} thisArg
+ * @chainable
+ */
+ set: function(key, value) {
+ if (typeof key === 'object') {
+ for (var prop in key) {
+ this._set(prop, key[prop]);
+ }
+ }
+ else {
+ if (typeof value === 'function') {
+ this._set(key, value(this.get(key)));
+ }
+ else {
+ this._set(key, value);
+ }
+ }
+ return this;
+ },
+
+ /**
+ * @private
+ * @method _set
+ * @param key
+ * @param value
+ */
+ _set: function(key, value) {
+ var shouldConstrainValue = (key === 'scaleX' || key === 'scaleY') &&
+ value < fabric.Object.MIN_SCALE_LIMIT;
+
+ if (shouldConstrainValue) {
+ value = fabric.Object.MIN_SCALE_LIMIT;
+ }
+ this[key] = value;
+ },
+
+ /**
+ * Toggles specified property from `true` to `false` or from `false` to `true`
+ * @method toggle
+ * @param {String} property property to toggle
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ toggle: function(property) {
+ var value = this.get(property);
+ if (typeof value === 'boolean') {
+ this.set(property, !value);
+ }
+ return this;
+ },
+
+ /**
+ * Sets sourcePath of an object
+ * @method setSourcePath
+ * @param {String} value
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ setSourcePath: function(value) {
+ this.sourcePath = value;
+ return this;
+ },
+
+ /**
+ * Basic getter
+ * @method get
+ * @param {String} property
+ * @return {Any} value of a property
+ */
+ get: function(property) {
+ return this[property];
+ },
+
+ /**
+ * Renders an object on a specified context
+ * @method render
+ * @param {CanvasRenderingContext2D} ctx context to render on
+ * @param {Boolean} noTransform
+ */
+ render: function(ctx, noTransform) {
+
+ // do not render if width or height are zeros
+ if (this.width === 0 || this.height === 0) return;
+
+ ctx.save();
+
+ var m = this.transformMatrix;
+ if (m && !this.group) {
+ ctx.setTransform(m[0], m[1], m[2], m[3], m[4], m[5]);
+ }
+
+ if (!noTransform) {
+ this.transform(ctx);
+ }
+
+ if (this.stroke || this.strokeDashArray) {
+ ctx.lineWidth = this.strokeWidth;
+ ctx.strokeStyle = this.stroke;
+ }
+
+ if (this.overlayFill) {
+ ctx.fillStyle = this.overlayFill;
+ }
+ else if (this.fill) {
+ ctx.fillStyle = this.fill.toLiveGradient
+ ? this.fill.toLiveGradient(ctx)
+ : this.fill;
+ }
+
+ if (m && this.group) {
+ ctx.translate(-this.group.width/2, -this.group.height/2);
+ ctx.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
+ }
+
+ this._render(ctx, noTransform);
+
+ if (this.active && !noTransform) {
+ this.drawBorders(ctx);
+ this.drawCorners(ctx);
+ }
+ ctx.restore();
+ },
+
+ /**
+ * Returns width of an object
+ * @method getWidth
+ * @return {Number} width value
+ */
+ getWidth: function() {
+ return this.width * this.scaleX;
+ },
+
+ /**
+ * Returns height of an object
+ * @method getHeight
+ * @return {Number} height value
+ */
+ getHeight: function() {
+ return this.height * this.scaleY;
+ },
+
+ /**
+ * Scales an object (equally by x and y)
+ * @method scale
+ * @param value {Number} scale factor
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ scale: function(value) {
+ this.scaleX = value;
+ this.scaleY = value;
+ this.setCoords();
+ return this;
+ },
+
+ /**
+ * Scales an object to a given width, with respect to bounding box (scaling by x/y equally)
+ * @method scaleToWidth
+ * @param value {Number} new width value
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ scaleToWidth: function(value) {
+ // adjust to bounding rect factor so that rotated shapes would fit as well
+ var boundingRectFactor = this.getBoundingRectWidth() / this.getWidth();
+ return this.scale(value / this.width / boundingRectFactor);
+ },
+
+ /**
+ * Scales an object to a given height, with respect to bounding box (scaling by x/y equally)
+ * @method scaleToHeight
+ * @param value {Number} new height value
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ scaleToHeight: function(value) {
+ // adjust to bounding rect factor so that rotated shapes would fit as well
+ var boundingRectFactor = this.getBoundingRectHeight() / this.getHeight();
+ return this.scale(value / this.height / boundingRectFactor);
+ },
+
+ /**
+ * Sets corner position coordinates based on current angle, width and height
+ * @method setCoords
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ setCoords: function() {
+
+ var strokeWidth = this.strokeWidth > 1 ? this.strokeWidth : 0,
+ padding = this.padding,
+ theta = degreesToRadians(this.angle);
+
+ this.currentWidth = (this.width + strokeWidth) * this.scaleX + padding * 2;
+ this.currentHeight = (this.height + strokeWidth) * this.scaleY + padding * 2;
+
+ //If width is negative, make postive. Fixes path selection issue
+ if(this.currentWidth < 0){
+ this.currentWidth = Math.abs(this.currentWidth);
+ }
+
+ var _hypotenuse = Math.sqrt(
+ Math.pow(this.currentWidth / 2, 2) +
+ Math.pow(this.currentHeight / 2, 2));
+
+ var _angle = Math.atan(this.currentHeight / this.currentWidth);
+
+ // offset added for rotate and scale actions
+ var offsetX = Math.cos(_angle + theta) * _hypotenuse,
+ offsetY = Math.sin(_angle + theta) * _hypotenuse,
+ sinTh = Math.sin(theta),
+ cosTh = Math.cos(theta);
+
+ var tl = {
+ x: this.left - offsetX,
+ y: this.top - offsetY
+ };
+ var tr = {
+ x: tl.x + (this.currentWidth * cosTh),
+ y: tl.y + (this.currentWidth * sinTh)
+ };
+ var br = {
+ x: tr.x - (this.currentHeight * sinTh),
+ y: tr.y + (this.currentHeight * cosTh)
+ };
+ var bl = {
+ x: tl.x - (this.currentHeight * sinTh),
+ y: tl.y + (this.currentHeight * cosTh)
+ };
+ var ml = {
+ x: tl.x - (this.currentHeight/2 * sinTh),
+ y: tl.y + (this.currentHeight/2 * cosTh)
+ };
+ var mt = {
+ x: tl.x + (this.currentWidth/2 * cosTh),
+ y: tl.y + (this.currentWidth/2 * sinTh)
+ };
+ var mr = {
+ x: tr.x - (this.currentHeight/2 * sinTh),
+ y: tr.y + (this.currentHeight/2 * cosTh)
+ };
+ var mb = {
+ x: bl.x + (this.currentWidth/2 * cosTh),
+ y: bl.y + (this.currentWidth/2 * sinTh)
+ };
+ var mtr = {
+ x: tl.x + (this.currentWidth/2 * cosTh),
+ y: tl.y + (this.currentWidth/2 * sinTh)
+ };
+
+ // debugging
+
+ // setTimeout(function() {
+ // canvas.contextTop.fillStyle = 'green';
+ // canvas.contextTop.fillRect(mb.x, mb.y, 3, 3);
+ // canvas.contextTop.fillRect(bl.x, bl.y, 3, 3);
+ // canvas.contextTop.fillRect(br.x, br.y, 3, 3);
+ // canvas.contextTop.fillRect(tl.x, tl.y, 3, 3);
+ // canvas.contextTop.fillRect(tr.x, tr.y, 3, 3);
+ // canvas.contextTop.fillRect(ml.x, ml.y, 3, 3);
+ // canvas.contextTop.fillRect(mr.x, mr.y, 3, 3);
+ // canvas.contextTop.fillRect(mt.x, mt.y, 3, 3);
+ // }, 50);
+
+ // clockwise
+ this.oCoords = { tl: tl, tr: tr, br: br, bl: bl, ml: ml, mt: mt, mr: mr, mb: mb, mtr: mtr };
+
+ // set coordinates of the draggable boxes in the corners used to scale/rotate the image
+ this._setCornerCoords();
+
+ return this;
+ },
+
+ /**
+ * Returns width of an object's bounding rectangle
+ * @method getBoundingRectWidth
+ * @return {Number} width value
+ */
+ getBoundingRectWidth: function() {
+ this.oCoords || this.setCoords();
+ var xCoords = [this.oCoords.tl.x, this.oCoords.tr.x, this.oCoords.br.x, this.oCoords.bl.x];
+ var minX = fabric.util.array.min(xCoords);
+ var maxX = fabric.util.array.max(xCoords);
+ return Math.abs(minX - maxX);
+ },
+
+ /**
+ * Returns height of an object's bounding rectangle
+ * @method getBoundingRectHeight
+ * @return {Number} height value
+ */
+ getBoundingRectHeight: function() {
+ this.oCoords || this.setCoords();
+ var yCoords = [this.oCoords.tl.y, this.oCoords.tr.y, this.oCoords.br.y, this.oCoords.bl.y];
+ var minY = fabric.util.array.min(yCoords);
+ var maxY = fabric.util.array.max(yCoords);
+ return Math.abs(minY - maxY);
+ },
+
+ /**
+ * Draws borders of an object's bounding box.
+ * Requires public properties: width, height
+ * Requires public options: padding, borderColor
+ * @method drawBorders
+ * @param {CanvasRenderingContext2D} ctx Context to draw on
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ drawBorders: function(ctx) {
+ if (!this.hasBorders) return;
+
+ var MIN_SCALE_LIMIT = fabric.Object.MIN_SCALE_LIMIT,
+ padding = this.padding,
+ padding2 = padding * 2,
+ strokeWidth = this.strokeWidth > 1 ? this.strokeWidth : 0;
+
+ ctx.save();
+
+ ctx.globalAlpha = this.isMoving ? this.borderOpacityWhenMoving : 1;
+ ctx.strokeStyle = this.borderColor;
+
+ var scaleX = 1 / (this.scaleX < MIN_SCALE_LIMIT ? MIN_SCALE_LIMIT : this.scaleX),
+ scaleY = 1 / (this.scaleY < MIN_SCALE_LIMIT ? MIN_SCALE_LIMIT : this.scaleY);
+
+ ctx.lineWidth = 1 / this.borderScaleFactor;
+
+ ctx.scale(scaleX, scaleY);
+
+ var w = this.getWidth(),
+ h = this.getHeight();
+
+ ctx.strokeRect(
+ ~~(-(w / 2) - padding - strokeWidth / 2 * this.scaleX) + 0.5, // offset needed to make lines look sharper
+ ~~(-(h / 2) - padding - strokeWidth / 2 * this.scaleY) + 0.5,
+ ~~(w + padding2 + strokeWidth * this.scaleX),
+ ~~(h + padding2 + strokeWidth * this.scaleY)
+ );
+
+ if (this.hasRotatingPoint && !this.get('lockRotation') && this.hasControls) {
+
+ var rotateHeight = (
+ this.flipY
+ ? h + (strokeWidth * this.scaleY) + (padding * 2)
+ : -h - (strokeWidth * this.scaleY) - (padding * 2)
+ ) / 2;
+
+ ctx.beginPath();
+ ctx.moveTo(0, rotateHeight);
+ ctx.lineTo(0, rotateHeight + (this.flipY ? this.rotatingPointOffset : -this.rotatingPointOffset));
+ ctx.closePath();
+ ctx.stroke();
+ }
+
+ ctx.restore();
+ return this;
+ },
+
+ /**
+ * @private
+ * @method _renderDashedStroke
+ */
+ _renderDashedStroke: function(ctx) {
+
+ if (1 & this.strokeDashArray.length /* if odd number of items */) {
+ /* duplicate items */
+ this.strokeDashArray.push.apply(this.strokeDashArray, this.strokeDashArray);
+ }
+
+ var i = 0,
+ x = -this.width/2, y = -this.height/2,
+ _this = this,
+ padding = this.padding,
+ dashedArrayLength = this.strokeDashArray.length;
+
+ ctx.save();
+ ctx.beginPath();
+
+ /** @ignore */
+ function renderSide(xMultiplier, yMultiplier) {
+
+ var lineLength = 0,
+ lengthDiff = 0,
+ sideLength = (yMultiplier ? _this.height : _this.width) + padding * 2;
+
+ while (lineLength < sideLength) {
+
+ var lengthOfSubPath = _this.strokeDashArray[i++];
+ lineLength += lengthOfSubPath;
+
+ if (lineLength > sideLength) {
+ lengthDiff = lineLength - sideLength;
+ }
+
+ // track coords
+ if (xMultiplier) {
+ x += (lengthOfSubPath * xMultiplier) - (lengthDiff * xMultiplier || 0);
+ }
+ else {
+ y += (lengthOfSubPath * yMultiplier) - (lengthDiff * yMultiplier || 0);
+ }
+
+ ctx[1 & i /* odd */ ? 'moveTo' : 'lineTo'](x, y);
+ if (i >= dashedArrayLength) {
+ i = 0;
+ }
+ }
+ }
+
+ renderSide(1, 0);
+ renderSide(0, 1);
+ renderSide(-1, 0);
+ renderSide(0, -1);
+
+ ctx.stroke();
+ ctx.closePath();
+ ctx.restore();
+ },
+
+ /**
+ * Draws corners of an object's bounding box.
+ * Requires public properties: width, height, scaleX, scaleY
+ * Requires public options: cornerSize, padding
+ * @method drawCorners
+ * @param {CanvasRenderingContext2D} ctx Context to draw on
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ drawCorners: function(ctx) {
+ if (!this.hasControls) return;
+
+ var size = this.cornerSize,
+ size2 = size / 2,
+ strokeWidth2 = this.strokeWidth / 2,
+ left = -(this.width / 2),
+ top = -(this.height / 2),
+ _left,
+ _top,
+ sizeX = size / this.scaleX,
+ sizeY = size / this.scaleY,
+ paddingX = this.padding / this.scaleX,
+ paddingY = this.padding / this.scaleY,
+ scaleOffsetY = size2 / this.scaleY,
+ scaleOffsetX = size2 / this.scaleX,
+ scaleOffsetSizeX = (size2 - size) / this.scaleX,
+ scaleOffsetSizeY = (size2 - size) / this.scaleY,
+ height = this.height,
+ width = this.width,
+ methodName = this.transparentCorners ? 'strokeRect' : 'fillRect';
+
+ ctx.save();
+
+ ctx.lineWidth = 1 / Math.max(this.scaleX, this.scaleY);
+
+ ctx.globalAlpha = this.isMoving ? this.borderOpacityWhenMoving : 1;
+ ctx.strokeStyle = ctx.fillStyle = this.cornerColor;
+
+ // top-left
+ _left = left - scaleOffsetX - strokeWidth2 - paddingX;
+ _top = top - scaleOffsetY - strokeWidth2 - paddingY;
+
+ ctx.clearRect(_left, _top, sizeX, sizeY);
+ ctx[methodName](_left, _top, sizeX, sizeY);
+
+ // top-right
+ _left = left + width - scaleOffsetX + strokeWidth2 + paddingX;
+ _top = top - scaleOffsetY - strokeWidth2 - paddingY;
+
+ ctx.clearRect(_left, _top, sizeX, sizeY);
+ ctx[methodName](_left, _top, sizeX, sizeY);
+
+ // bottom-left
+ _left = left - scaleOffsetX - strokeWidth2 - paddingX;
+ _top = top + height + scaleOffsetSizeY + strokeWidth2 + paddingY;
+
+ ctx.clearRect(_left, _top, sizeX, sizeY);
+ ctx[methodName](_left, _top, sizeX, sizeY);
+
+ // bottom-right
+ _left = left + width + scaleOffsetSizeX + strokeWidth2 + paddingX;
+ _top = top + height + scaleOffsetSizeY + strokeWidth2 + paddingY;
+
+ ctx.clearRect(_left, _top, sizeX, sizeY);
+ ctx[methodName](_left, _top, sizeX, sizeY);
+
+ if (!this.get('lockUniScaling')) {
+ // middle-top
+ _left = left + width/2 - scaleOffsetX;
+ _top = top - scaleOffsetY - strokeWidth2 - paddingY;
+
+ ctx.clearRect(_left, _top, sizeX, sizeY);
+ ctx[methodName](_left, _top, sizeX, sizeY);
+
+ // middle-bottom
+ _left = left + width/2 - scaleOffsetX;
+ _top = top + height + scaleOffsetSizeY + strokeWidth2 + paddingY;
+
+ ctx.clearRect(_left, _top, sizeX, sizeY);
+ ctx[methodName](_left, _top, sizeX, sizeY);
+
+ // middle-right
+ _left = left + width + scaleOffsetSizeX + strokeWidth2 + paddingX;
+ _top = top + height/2 - scaleOffsetY;
+
+ ctx.clearRect(_left, _top, sizeX, sizeY);
+ ctx[methodName](_left, _top, sizeX, sizeY);
+
+ // middle-left
+ _left = left - scaleOffsetX - strokeWidth2 - paddingX;
+ _top = top + height/2 - scaleOffsetY;
+
+ ctx.clearRect(_left, _top, sizeX, sizeY);
+ ctx[methodName](_left, _top, sizeX, sizeY);
+ }
+
+ // middle-top-rotate
+ if (this.hasRotatingPoint) {
+
+ _left = left + width/2 - scaleOffsetX;
+
+ _top = this.flipY ?
+ (top + height + (this.rotatingPointOffset / this.scaleY) - sizeY/2 + strokeWidth2 + paddingY)
+ : (top - (this.rotatingPointOffset / this.scaleY) - sizeY/2 - strokeWidth2 - paddingY);
+
+ ctx.clearRect(_left, _top, sizeX, sizeY);
+ ctx[methodName](_left, _top, sizeX, sizeY);
+ }
+
+ ctx.restore();
+
+ return this;
+ },
+
+ /**
+ * Clones an instance
+ * @method clone
+ * @param {Function} callback Callback is invoked with a clone as a first argument
+ * @param {Array} propertiesToInclude
+ * @return {fabric.Object} clone of an instance
+ */
+ clone: function(callback, propertiesToInclude) {
+ if (this.constructor.fromObject) {
+ return this.constructor.fromObject(this.toObject(propertiesToInclude), callback);
+ }
+ return new fabric.Object(this.toObject(propertiesToInclude));
+ },
+
+ /**
+ * Creates an instance of fabric.Image out of an object
+ * @method cloneAsImage
+ * @param callback {Function} callback, invoked with an instance as a first argument
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ cloneAsImage: function(callback) {
+ if (fabric.Image) {
+ var i = new Image();
+
+ /** @ignore */
+ i.onload = function() {
+ if (callback) {
+ callback(new fabric.Image(i), orig);
+ }
+ i = i.onload = null;
+ };
+
+ var orig = {
+ angle: this.get('angle'),
+ flipX: this.get('flipX'),
+ flipY: this.get('flipY')
+ };
+
+ // normalize angle
+ this.set('angle', 0).set('flipX', false).set('flipY', false);
+ this.toDataURL(function(dataURL) {
+ i.src = dataURL;
+ });
+ }
+ return this;
+ },
+
+ /**
+ * Converts an object into a data-url-like string
+ * @method toDataURL
+ * @return {String} string of data
+ */
+ toDataURL: function(callback) {
+ var el = fabric.document.createElement('canvas');
+ if (!el.getContext && typeof G_vmlCanvasManager !== 'undefined') {
+ G_vmlCanvasManager.initElement(el);
+ }
+
+ el.width = this.getBoundingRectWidth();
+ el.height = this.getBoundingRectHeight();
+
+ fabric.util.wrapElement(el, 'div');
+
+ var canvas = new fabric.Canvas(el);
+ canvas.backgroundColor = 'transparent';
+ canvas.renderAll();
+
+ if (this.constructor.async) {
+ this.clone(proceed);
+ }
+ else {
+ proceed(this.clone());
+ }
+
+ function proceed(clone) {
+ clone.left = el.width / 2;
+ clone.top = el.height / 2;
+
+ clone.setActive(false);
+
+ canvas.add(clone);
+ var data = canvas.toDataURL('png');
+
+ canvas.dispose();
+ canvas = clone = null;
+
+ callback && callback(data);
+ }
+ },
+
+ /**
+ * Returns true if object state (one of its state properties) was changed
+ * @method hasStateChanged
+ * @return {Boolean} true if instance' state has changed
+ */
+ hasStateChanged: function() {
+ return this.stateProperties.some(function(prop) {
+ return this[prop] !== this.originalState[prop];
+ }, this);
+ },
+
+ /**
+ * Saves state of an object
+ * @method saveState
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ saveState: function() {
+ this.stateProperties.forEach(function(prop) {
+ this.originalState[prop] = this.get(prop);
+ }, this);
+ return this;
+ },
+
+ /**
+ * Setups state of an object
+ * @method setupState
+ */
+ setupState: function() {
+ this.originalState = { };
+ this.saveState();
+ },
+
+ /**
+ * Returns true if object intersects with an area formed by 2 points
+ * @method intersectsWithRect
+ * @param {Object} selectionTL
+ * @param {Object} selectionBR
+ * @return {Boolean}
+ */
+ intersectsWithRect: function(selectionTL, selectionBR) {
+ var oCoords = this.oCoords,
+ tl = new fabric.Point(oCoords.tl.x, oCoords.tl.y),
+ tr = new fabric.Point(oCoords.tr.x, oCoords.tr.y),
+ bl = new fabric.Point(oCoords.bl.x, oCoords.bl.y),
+ br = new fabric.Point(oCoords.br.x, oCoords.br.y);
+
+ var intersection = fabric.Intersection.intersectPolygonRectangle(
+ [tl, tr, br, bl],
+ selectionTL,
+ selectionBR
+ );
+ return (intersection.status === 'Intersection');
+ },
+
+ /**
+ * Returns true if object intersects with another object
+ * @method intersectsWithObject
+ * @param {Object} other Object to test
+ * @return {Boolean}
+ */
+ intersectsWithObject: function(other) {
+ // extracts coords
+ function getCoords(oCoords) {
+ return {
+ tl: new fabric.Point(oCoords.tl.x, oCoords.tl.y),
+ tr: new fabric.Point(oCoords.tr.x, oCoords.tr.y),
+ bl: new fabric.Point(oCoords.bl.x, oCoords.bl.y),
+ br: new fabric.Point(oCoords.br.x, oCoords.br.y)
+ };
+ }
+ var thisCoords = getCoords(this.oCoords),
+ otherCoords = getCoords(other.oCoords);
+
+ var intersection = fabric.Intersection.intersectPolygonPolygon(
+ [thisCoords.tl, thisCoords.tr, thisCoords.br, thisCoords.bl],
+ [otherCoords.tl, otherCoords.tr, otherCoords.br, otherCoords.bl]
+ );
+
+ return (intersection.status === 'Intersection');
+ },
+
+ /**
+ * Returns true if object is fully contained within area of another object
+ * @method isContainedWithinObject
+ * @param {Object} other Object to test
+ * @return {Boolean}
+ */
+ isContainedWithinObject: function(other) {
+ return this.isContainedWithinRect(other.oCoords.tl, other.oCoords.br);
+ },
+
+ /**
+ * Returns true if object is fully contained within area formed by 2 points
+ * @method isContainedWithinRect
+ * @param {Object} selectionTL
+ * @param {Object} selectionBR
+ * @return {Boolean}
+ */
+ isContainedWithinRect: function(selectionTL, selectionBR) {
+ var oCoords = this.oCoords,
+ tl = new fabric.Point(oCoords.tl.x, oCoords.tl.y),
+ tr = new fabric.Point(oCoords.tr.x, oCoords.tr.y),
+ bl = new fabric.Point(oCoords.bl.x, oCoords.bl.y);
+
+ return tl.x > selectionTL.x
+ && tr.x < selectionBR.x
+ && tl.y > selectionTL.y
+ && bl.y < selectionBR.y;
+ },
+
+ /**
+ * Returns true if specified type is identical to the type of an instance
+ * @method isType
+ * @param type {String} type to check against
+ * @return {Boolean}
+ */
+ isType: function(type) {
+ return this.type === type;
+ },
+
+ /**
+ * Determines which one of the four corners has been clicked
+ * @method _findTargetCorner
+ * @private
+ * @param e {Event} event object
+ * @param offset {Object} canvas offset
+ * @return {String|Boolean} corner code (tl, tr, bl, br, etc.), or false if nothing is found
+ */
+ _findTargetCorner: function(e, offset) {
+ if (!this.hasControls || !this.active) return false;
+
+ var pointer = getPointer(e),
+ ex = pointer.x - offset.left,
+ ey = pointer.y - offset.top,
+ xpoints,
+ lines;
+
+ for (var i in this.oCoords) {
+
+ if (i === 'mtr' && !this.hasRotatingPoint) {
+ continue;
+ }
+
+ if (this.get('lockUniScaling') && (i === 'mt' || i === 'mr' || i === 'mb' || i === 'ml')) {
+ continue;
+ }
+
+ lines = this._getImageLines(this.oCoords[i].corner, i);
+
+ // debugging
+
+ // canvas.contextTop.fillRect(lines.bottomline.d.x, lines.bottomline.d.y, 2, 2);
+ // canvas.contextTop.fillRect(lines.bottomline.o.x, lines.bottomline.o.y, 2, 2);
+
+ // canvas.contextTop.fillRect(lines.leftline.d.x, lines.leftline.d.y, 2, 2);
+ // canvas.contextTop.fillRect(lines.leftline.o.x, lines.leftline.o.y, 2, 2);
+
+ // canvas.contextTop.fillRect(lines.topline.d.x, lines.topline.d.y, 2, 2);
+ // canvas.contextTop.fillRect(lines.topline.o.x, lines.topline.o.y, 2, 2);
+
+ // canvas.contextTop.fillRect(lines.rightline.d.x, lines.rightline.d.y, 2, 2);
+ // canvas.contextTop.fillRect(lines.rightline.o.x, lines.rightline.o.y, 2, 2);
+
+ xpoints = this._findCrossPoints(ex, ey, lines);
+ if (xpoints % 2 === 1 && xpoints !== 0) {
+ this.__corner = i;
+ return i;
+ }
+ }
+ return false;
+ },
+
+ /**
+ * Helper method to determine how many cross points are between the 4 image edges
+ * and the horizontal line determined by the position of our mouse when clicked on canvas
+ * @method _findCrossPoints
+ * @private
+ * @param ex {Number} x coordinate of the mouse
+ * @param ey {Number} y coordinate of the mouse
+ * @param oCoords {Object} Coordinates of the image being evaluated
+ */
+ _findCrossPoints: function(ex, ey, oCoords) {
+ var b1, b2, a1, a2, xi, yi,
+ xcount = 0,
+ iLine;
+
+ for (var lineKey in oCoords) {
+ iLine = oCoords[lineKey];
+ // optimisation 1: line below dot. no cross
+ if ((iLine.o.y < ey) && (iLine.d.y < ey)) {
+ continue;
+ }
+ // optimisation 2: line above dot. no cross
+ if ((iLine.o.y >= ey) && (iLine.d.y >= ey)) {
+ continue;
+ }
+ // optimisation 3: vertical line case
+ if ((iLine.o.x === iLine.d.x) && (iLine.o.x >= ex)) {
+ xi = iLine.o.x;
+ yi = ey;
+ }
+ // calculate the intersection point
+ else {
+ b1 = 0;
+ b2 = (iLine.d.y-iLine.o.y)/(iLine.d.x-iLine.o.x);
+ a1 = ey-b1*ex;
+ a2 = iLine.o.y-b2*iLine.o.x;
+
+ xi = - (a1-a2)/(b1-b2);
+ yi = a1+b1*xi;
+ }
+ // dont count xi < ex cases
+ if (xi >= ex) {
+ xcount += 1;
+ }
+ // optimisation 4: specific for square images
+ if (xcount === 2) {
+ break;
+ }
+ }
+ return xcount;
+ },
+
+ /**
+ * Method that returns an object with the image lines in it given the coordinates of the corners
+ * @method _getImageLines
+ * @private
+ * @param oCoords {Object} coordinates of the image corners
+ */
+ _getImageLines: function(oCoords) {
+ return {
+ topline: {
+ o: oCoords.tl,
+ d: oCoords.tr
+ },
+ rightline: {
+ o: oCoords.tr,
+ d: oCoords.br
+ },
+ bottomline: {
+ o: oCoords.br,
+ d: oCoords.bl
+ },
+ leftline: {
+ o: oCoords.bl,
+ d: oCoords.tl
+ }
+ };
+ },
+
+ /**
+ * Sets the coordinates of the draggable boxes in the corners of
+ * the image used to scale/rotate it.
+ * @method _setCornerCoords
+ * @private
+ */
+ _setCornerCoords: function() {
+ var coords = this.oCoords,
+ theta = degreesToRadians(this.angle),
+ newTheta = degreesToRadians(45 - this.angle),
+ cornerHypotenuse = Math.sqrt(2 * Math.pow(this.cornerSize, 2)) / 2,
+ cosHalfOffset = cornerHypotenuse * Math.cos(newTheta),
+ sinHalfOffset = cornerHypotenuse * Math.sin(newTheta),
+ sinTh = Math.sin(theta),
+ cosTh = Math.cos(theta);
+
+ coords.tl.corner = {
+ tl: {
+ x: coords.tl.x - sinHalfOffset,
+ y: coords.tl.y - cosHalfOffset
+ },
+ tr: {
+ x: coords.tl.x + cosHalfOffset,
+ y: coords.tl.y - sinHalfOffset
+ },
+ bl: {
+ x: coords.tl.x - cosHalfOffset,
+ y: coords.tl.y + sinHalfOffset
+ },
+ br: {
+ x: coords.tl.x + sinHalfOffset,
+ y: coords.tl.y + cosHalfOffset
+ }
+ };
+
+ coords.tr.corner = {
+ tl: {
+ x: coords.tr.x - sinHalfOffset,
+ y: coords.tr.y - cosHalfOffset
+ },
+ tr: {
+ x: coords.tr.x + cosHalfOffset,
+ y: coords.tr.y - sinHalfOffset
+ },
+ br: {
+ x: coords.tr.x + sinHalfOffset,
+ y: coords.tr.y + cosHalfOffset
+ },
+ bl: {
+ x: coords.tr.x - cosHalfOffset,
+ y: coords.tr.y + sinHalfOffset
+ }
+ };
+
+ coords.bl.corner = {
+ tl: {
+ x: coords.bl.x - sinHalfOffset,
+ y: coords.bl.y - cosHalfOffset
+ },
+ bl: {
+ x: coords.bl.x - cosHalfOffset,
+ y: coords.bl.y + sinHalfOffset
+ },
+ br: {
+ x: coords.bl.x + sinHalfOffset,
+ y: coords.bl.y + cosHalfOffset
+ },
+ tr: {
+ x: coords.bl.x + cosHalfOffset,
+ y: coords.bl.y - sinHalfOffset
+ }
+ };
+
+ coords.br.corner = {
+ tr: {
+ x: coords.br.x + cosHalfOffset,
+ y: coords.br.y - sinHalfOffset
+ },
+ bl: {
+ x: coords.br.x - cosHalfOffset,
+ y: coords.br.y + sinHalfOffset
+ },
+ br: {
+ x: coords.br.x + sinHalfOffset,
+ y: coords.br.y + cosHalfOffset
+ },
+ tl: {
+ x: coords.br.x - sinHalfOffset,
+ y: coords.br.y - cosHalfOffset
+ }
+ };
+
+ coords.ml.corner = {
+ tl: {
+ x: coords.ml.x - sinHalfOffset,
+ y: coords.ml.y - cosHalfOffset
+ },
+ tr: {
+ x: coords.ml.x + cosHalfOffset,
+ y: coords.ml.y - sinHalfOffset
+ },
+ bl: {
+ x: coords.ml.x - cosHalfOffset,
+ y: coords.ml.y + sinHalfOffset
+ },
+ br: {
+ x: coords.ml.x + sinHalfOffset,
+ y: coords.ml.y + cosHalfOffset
+ }
+ };
+
+ coords.mt.corner = {
+ tl: {
+ x: coords.mt.x - sinHalfOffset,
+ y: coords.mt.y - cosHalfOffset
+ },
+ tr: {
+ x: coords.mt.x + cosHalfOffset,
+ y: coords.mt.y - sinHalfOffset
+ },
+ bl: {
+ x: coords.mt.x - cosHalfOffset,
+ y: coords.mt.y + sinHalfOffset
+ },
+ br: {
+ x: coords.mt.x + sinHalfOffset,
+ y: coords.mt.y + cosHalfOffset
+ }
+ };
+
+ coords.mr.corner = {
+ tl: {
+ x: coords.mr.x - sinHalfOffset,
+ y: coords.mr.y - cosHalfOffset
+ },
+ tr: {
+ x: coords.mr.x + cosHalfOffset,
+ y: coords.mr.y - sinHalfOffset
+ },
+ bl: {
+ x: coords.mr.x - cosHalfOffset,
+ y: coords.mr.y + sinHalfOffset
+ },
+ br: {
+ x: coords.mr.x + sinHalfOffset,
+ y: coords.mr.y + cosHalfOffset
+ }
+ };
+
+ coords.mb.corner = {
+ tl: {
+ x: coords.mb.x - sinHalfOffset,
+ y: coords.mb.y - cosHalfOffset
+ },
+ tr: {
+ x: coords.mb.x + cosHalfOffset,
+ y: coords.mb.y - sinHalfOffset
+ },
+ bl: {
+ x: coords.mb.x - cosHalfOffset,
+ y: coords.mb.y + sinHalfOffset
+ },
+ br: {
+ x: coords.mb.x + sinHalfOffset,
+ y: coords.mb.y + cosHalfOffset
+ }
+ };
+
+ coords.mtr.corner = {
+ tl: {
+ x: coords.mtr.x - sinHalfOffset + (sinTh * this.rotatingPointOffset),
+ y: coords.mtr.y - cosHalfOffset - (cosTh * this.rotatingPointOffset)
+ },
+ tr: {
+ x: coords.mtr.x + cosHalfOffset + (sinTh * this.rotatingPointOffset),
+ y: coords.mtr.y - sinHalfOffset - (cosTh * this.rotatingPointOffset)
+ },
+ bl: {
+ x: coords.mtr.x - cosHalfOffset + (sinTh * this.rotatingPointOffset),
+ y: coords.mtr.y + sinHalfOffset - (cosTh * this.rotatingPointOffset)
+ },
+ br: {
+ x: coords.mtr.x + sinHalfOffset + (sinTh * this.rotatingPointOffset),
+ y: coords.mtr.y + cosHalfOffset - (cosTh * this.rotatingPointOffset)
+ }
+ };
+ },
+
+ /**
+ * Makes object's color grayscale
+ * @method toGrayscale
+ * @return {fabric.Object} thisArg
+ */
+ toGrayscale: function() {
+ var fillValue = this.get('fill');
+ if (fillValue) {
+ this.set('overlayFill', new fabric.Color(fillValue).toGrayscale().toRgb());
+ }
+ return this;
+ },
+
+ /**
+ * Returns complexity of an instance
+ * @method complexity
+ * @return {Number} complexity
+ */
+ complexity: function() {
+ return 0;
+ },
+
+ /**
+ * Returns a JSON representation of an instance
+ * @method toJSON
+ * @param {Array} propertiesToInclude
+ * @return {String} json
+ */
+ toJSON: function(propertiesToInclude) {
+ // delegate, not alias
+ return this.toObject(propertiesToInclude);
+ },
+
+ /**
+ * Sets gradient fill of an object
+ * @method setGradientFill
+ */
+ setGradientFill: function(options) {
+ this.set('fill', fabric.Gradient.forObject(this, options));
+ },
+
+ /**
+ * Animates object's properties
+ * @method animate
+ *
+ * As object — multiple properties
+ *
+ * object.animate({ left: ..., top: ... });
+ * object.animate({ left: ..., top: ... }, { duration: ... });
+ *
+ * As string — one property
+ *
+ * object.animate('left', ...);
+ * object.animate('left', { duration: ... });
+ *
+ */
+ animate: function() {
+ if (arguments[0] && typeof arguments[0] === 'object') {
+ for (var prop in arguments[0]) {
+ this._animate(prop, arguments[0][prop], arguments[1]);
+ }
+ }
+ else {
+ this._animate.apply(this, arguments);
+ }
+ return this;
+ },
+
+ /**
+ * @private
+ * @method _animate
+ */
+ _animate: function(property, to, options) {
+ var obj = this;
+
+ to = to.toString();
+ options || (options = { });
+
+ if (!('from' in options)) {
+ options.from = this.get(property);
+ }
+
+ if (~to.indexOf('=')) {
+ to = this.get(property) + parseFloat(to.replace('=', ''));
+ }
+ else {
+ to = parseFloat(to);
+ }
+
+ fabric.util.animate({
+ startValue: options.from,
+ endValue: to,
+ byValue: options.by,
+ easing: options.easing,
+ duration: options.duration,
+ onChange: function(value) {
+ obj.set(property, value);
+ options.onChange && options.onChange();
+ },
+ onComplete: function() {
+ obj.setCoords();
+ options.onComplete && options.onComplete();
+ }
+ });
+ },
+
+ /**
+ * Centers object horizontally on canvas to which it was added last
+ * @method centerH
+ * @return {fabric.Object} thisArg
+ */
+ centerH: function () {
+ this.canvas.centerObjectH(this);
+ return this;
+ },
+
+ /**
+ * Centers object vertically on canvas to which it was added last
+ * @method centerV
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ centerV: function () {
+ this.canvas.centerObjectV(this);
+ return this;
+ },
+
+ /**
+ * Centers object vertically and horizontally on canvas to which is was added last
+ * @method center
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ center: function () {
+ return this.centerH().centerV();
+ },
+
+ /**
+ * Removes object from canvas to which it was added last
+ * @method remove
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ remove: function() {
+ return this.canvas.remove(this);
+ },
+
+ /**
+ * Moves an object to the bottom of the stack of drawn objects
+ * @method sendToBack
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ sendToBack: function() {
+ this.canvas.sendToBack(this);
+ return this;
+ },
+
+ /**
+ * Moves an object to the top of the stack of drawn objects
+ * @method bringToFront
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ bringToFront: function() {
+ this.canvas.bringToFront(this);
+ return this;
+ },
+
+ /**
+ * Moves an object one level down in stack of drawn objects
+ * @method sendBackwards
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ sendBackwards: function() {
+ this.canvas.sendBackwards(this);
+ return this;
+ },
+
+ /**
+ * Moves an object one level up in stack of drawn objects
+ * @method bringForward
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ bringForward: function() {
+ this.canvas.bringForward(this);
+ return this;
+ }
+ });
+
+ var proto = fabric.Object.prototype;
+ for (var i = proto.stateProperties.length; i--; ) {
+
+ var propName = proto.stateProperties[i],
+ capitalizedPropName = propName.charAt(0).toUpperCase() + propName.slice(1),
+ setterName = 'set' + capitalizedPropName,
+ getterName = 'get' + capitalizedPropName;
+
+ // using `new Function` for better introspection
+ if (!proto[getterName]) {
+ proto[getterName] = (function(property) {
+ return new Function('return this.get("' + property + '")');
+ })(propName);
+ }
+ if (!proto[setterName]) {
+ proto[setterName] = (function(property) {
+ return new Function('value', 'return this.set("' + property + '", value)');
+ })(propName);
+ }
+ }
+
+ /**
+ * Alias for {@link fabric.Object.prototype.setAngle}
+ * @alias rotate -> setAngle
+ */
+ fabric.Object.prototype.rotate = fabric.Object.prototype.setAngle;
+
+ extend(fabric.Object.prototype, fabric.Observable);
+
+ extend(fabric.Object, {
+
+ /**
+ * @static
+ * @constant
+ * @type Number
+ */
+ NUM_FRACTION_DIGITS: 2,
+
+ /**
+ * Minimum allowed scale value of an object
+ * @static
+ * @constant
+ * @type Number
+ */
+ MIN_SCALE_LIMIT: 0.1
+
+ });
+
+})(typeof exports !== 'undefined' ? exports : this);
+
+(function(global) {
+
+ "use strict";
+
+ var fabric = global.fabric || (global.fabric = { }),
+ extend = fabric.util.object.extend,
+ coordProps = { 'x1': 1, 'x2': 1, 'y1': 1, 'y2': 1 };
+
+ if (fabric.Line) {
+ fabric.warn('fabric.Line is already defined');
+ return;
+ }
+
+ /**
+ * Line class
+ * @class Line
+ * @extends fabric.Object
+ */
+ fabric.Line = fabric.util.createClass(fabric.Object, /** @scope fabric.Line.prototype */ {
+
+ /**
+ * Type of an object
+ * @property
+ * @type String
+ */
+ type: 'line',
+
+ /**
+ * Constructor
+ * @method initialize
+ * @param {Array} [points] Array of points
+ * @param {Object} [options] Options object
+ * @return {fabric.Line} thisArg
+ */
+ initialize: function(points, options) {
+ options = options || { };
+
+ if (!points) {
+ points = [0, 0, 0, 0];
+ }
+
+ this.callSuper('initialize', options);
+
+ this.set('x1', points[0]);
+ this.set('y1', points[1]);
+ this.set('x2', points[2]);
+ this.set('y2', points[3]);
+
+ this._setWidthHeight(options);
+ },
+
+ /**
+ * @private
+ * @method _setWidthHeight
+ * @param {Object} [options] Options
+ */
+ _setWidthHeight: function(options) {
+ options || (options = { });
+
+ this.set('width', (this.x2 - this.x1) || 1);
+ this.set('height', (this.y2 - this.y1) || 1);
+
+ this.set('left', 'left' in options ? options.left : (this.x1 + this.width / 2));
+ this.set('top', 'top' in options ? options.top : (this.y1 + this.height / 2));
+ },
+
+ /**
+ * @private
+ * @method _set
+ * @param {String} key
+ * @param {Any} value
+ */
+ _set: function(key, value) {
+ this[key] = value;
+ if (key in coordProps) {
+ this._setWidthHeight();
+ }
+ return this;
+ },
+
+ /**
+ * @private
+ * @method _render
+ * @param {CanvasRenderingContext2D} ctx Context to render on
+ */
+ _render: function(ctx) {
+ ctx.beginPath();
+
+ if (this.group) {
+ ctx.translate(-this.group.width/2 + this.left, -this.group.height / 2 + this.top);
+ }
+
+ // move from center (of virtual box) to its left/top corner
+ ctx.moveTo(this.width === 1 ? 0 : (-this.width / 2), this.height === 1 ? 0 : (-this.height / 2));
+ ctx.lineTo(this.width === 1 ? 0 : (this.width / 2), this.height === 1 ? 0 : (this.height / 2));
+
+ ctx.lineWidth = this.strokeWidth;
+
+ // TODO: test this
+ // make sure setting "fill" changes color of a line
+ // (by copying fillStyle to strokeStyle, since line is stroked, not filled)
+ var origStrokeStyle = ctx.strokeStyle;
+ ctx.strokeStyle = ctx.fillStyle;
+ ctx.stroke();
+ ctx.strokeStyle = origStrokeStyle;
+ },
+
+ /**
+ * Returns complexity of an instance
+ * @method complexity
+ * @return {Number} complexity
+ */
+ complexity: function() {
+ return 1;
+ },
+
+ /**
+ * Returns object representation of an instance
+ * @methd toObject
+ * @param {Array} propertiesToInclude
+ * @return {Object} object representation of an instance
+ */
+ toObject: function(propertiesToInclude) {
+ return extend(this.callSuper('toObject', propertiesToInclude), {
+ x1: this.get('x1'),
+ y1: this.get('y1'),
+ x2: this.get('x2'),
+ y2: this.get('y2')
+ });
+ },
+
+ /**
+ * Returns SVG representation of an instance
+ * @method toSVG
+ * @return {String} svg representation of an instance
+ */
+ toSVG: function() {
+ return [
+ ''
+ ].join('');
+ }
+ });
+
+ /**
+ * List of attribute names to account for when parsing SVG element (used by {@link fabric.Line.fromElement})
+ * @static
+ * @see http://www.w3.org/TR/SVG/shapes.html#LineElement
+ */
+ fabric.Line.ATTRIBUTE_NAMES = 'x1 y1 x2 y2 stroke stroke-width transform'.split(' ');
+
+ /**
+ * Returns fabric.Line instance from an SVG element
+ * @static
+ * @method fabric.Line.fromElement
+ * @param {SVGElement} element Element to parse
+ * @param {Object} [options] Options object
+ * @return {fabric.Line} instance of fabric.Line
+ */
+ fabric.Line.fromElement = function(element, options) {
+ var parsedAttributes = fabric.parseAttributes(element, fabric.Line.ATTRIBUTE_NAMES);
+ var points = [
+ parsedAttributes.x1 || 0,
+ parsedAttributes.y1 || 0,
+ parsedAttributes.x2 || 0,
+ parsedAttributes.y2 || 0
+ ];
+ return new fabric.Line(points, extend(parsedAttributes, options));
+ };
+
+ /**
+ * Returns fabric.Line instance from an object representation
+ * @static
+ * @method fabric.Line.fromObject
+ * @param {Object} object Object to create an instance from
+ * @return {fabric.Line} instance of fabric.Line
+ */
+ fabric.Line.fromObject = function(object) {
+ var points = [object.x1, object.y1, object.x2, object.y2];
+ return new fabric.Line(points, object);
+ };
+
+})(typeof exports !== 'undefined' ? exports : this);
+(function(global) {
+
+ "use strict";
+
+ var fabric = global.fabric || (global.fabric = { }),
+ piBy2 = Math.PI * 2,
+ extend = fabric.util.object.extend;
+
+ if (fabric.Circle) {
+ fabric.warn('fabric.Circle is already defined.');
+ return;
+ }
+
+ /**
+ * Circle class
+ * @class Circle
+ * @extends fabric.Object
+ */
+ fabric.Circle = fabric.util.createClass(fabric.Object, /** @scope fabric.Circle.prototype */ {
+
+ /**
+ * Type of an object
+ * @property
+ * @type String
+ */
+ type: 'circle',
+
+ /**
+ * Constructor
+ * @method initialize
+ * @param {Object} [options] Options object
+ * @return {fabric.Circle} thisArg
+ */
+ initialize: function(options) {
+ options = options || { };
+
+ this.set('radius', options.radius || 0);
+ this.callSuper('initialize', options);
+
+ var diameter = this.get('radius') * 2;
+ this.set('width', diameter).set('height', diameter);
+ },
+
+ /**
+ * Returns object representation of an instance
+ * @method toObject
+ * @param {Array} propertiesToInclude
+ * @return {Object} object representation of an instance
+ */
+ toObject: function(propertiesToInclude) {
+ return extend(this.callSuper('toObject', propertiesToInclude), {
+ radius: this.get('radius')
+ });
+ },
+
+ /**
+ * Returns svg representation of an instance
+ * @method toSVG
+ * @return {String} svg representation of an instance
+ */
+ toSVG: function() {
+ return ('');
+ },
+
+ /**
+ * @private
+ * @method _render
+ * @param ctx {CanvasRenderingContext2D} context to render on
+ */
+ _render: function(ctx, noTransform) {
+ ctx.beginPath();
+ // multiply by currently set alpha (the one that was set by path group where this object is contained, for example)
+ ctx.globalAlpha = this.group ? (ctx.globalAlpha * this.opacity) : this.opacity;
+ ctx.arc(noTransform ? this.left : 0, noTransform ? this.top : 0, this.radius, 0, piBy2, false);
+ ctx.closePath();
+ if (this.fill) {
+ ctx.fill();
+ }
+ if (this.stroke) {
+ ctx.stroke();
+ }
+ },
+
+ /**
+ * Returns horizontal radius of an object (according to how an object is scaled)
+ * @method getRadiusX
+ * @return {Number}
+ */
+ getRadiusX: function() {
+ return this.get('radius') * this.get('scaleX');
+ },
+
+ /**
+ * Returns vertical radius of an object (according to how an object is scaled)
+ * @method getRadiusY
+ * @return {Number}
+ */
+ getRadiusY: function() {
+ return this.get('radius') * this.get('scaleY');
+ },
+
+ /**
+ * Sets radius of an object (and updates width accordingly)
+ * @method setRadius
+ * @return {Number}
+ */
+ setRadius: function(value) {
+ this.radius = value;
+ this.set('width', value * 2).set('height', value * 2);
+ },
+
+ /**
+ * Returns complexity of an instance
+ * @method complexity
+ * @return {Number} complexity of this instance
+ */
+ complexity: function() {
+ return 1;
+ }
+ });
+
+ /**
+ * List of attribute names to account for when parsing SVG element (used by {@link fabric.Circle.fromElement})
+ * @static
+ * @see: http://www.w3.org/TR/SVG/shapes.html#CircleElement
+ */
+ fabric.Circle.ATTRIBUTE_NAMES = 'cx cy r fill fill-opacity opacity stroke stroke-width transform'.split(' ');
+
+ /**
+ * Returns {@link fabric.Circle} instance from an SVG element
+ * @static
+ * @method fabric.Circle.fromElement
+ * @param {SVGElement} element Element to parse
+ * @param {Object} [options] Options object
+ * @throws {Error} If value of `r` attribute is missing or invalid
+ * @return {Object} Instance of fabric.Circle
+ */
+ fabric.Circle.fromElement = function(element, options) {
+ options || (options = { });
+ var parsedAttributes = fabric.parseAttributes(element, fabric.Circle.ATTRIBUTE_NAMES);
+ if (!isValidRadius(parsedAttributes)) {
+ throw new Error('value of `r` attribute is required and can not be negative');
+ }
+ if ('left' in parsedAttributes) {
+ parsedAttributes.left -= (options.width / 2) || 0;
+ }
+ if ('top' in parsedAttributes) {
+ parsedAttributes.top -= (options.height / 2) || 0;
+ }
+ var obj = new fabric.Circle(extend(parsedAttributes, options));
+
+ obj.cx = parseFloat(element.getAttribute('cx')) || 0;
+ obj.cy = parseFloat(element.getAttribute('cy')) || 0;
+
+ return obj;
+ };
+
+ /**
+ * @private
+ */
+ function isValidRadius(attributes) {
+ return (('radius' in attributes) && (attributes.radius > 0));
+ }
+
+ /**
+ * Returns {@link fabric.Circle} instance from an object representation
+ * @static
+ * @method fabric.Circle.fromObject
+ * @param {Object} object Object to create an instance from
+ * @return {Object} Instance of fabric.Circle
+ */
+ fabric.Circle.fromObject = function(object) {
+ return new fabric.Circle(object);
+ };
+
+})(typeof exports !== 'undefined' ? exports : this);
+(function(global) {
+
+ "use strict";
+
+ var fabric = global.fabric || (global.fabric = { });
+
+ if (fabric.Triangle) {
+ fabric.warn('fabric.Triangle is already defined');
+ return;
+ }
+
+ /**
+ * Triangle class
+ * @class Triangle
+ * @extends fabric.Object
+ */
+ fabric.Triangle = fabric.util.createClass(fabric.Object, /** @scope fabric.Triangle.prototype */ {
+
+ /**
+ * Type of an object
+ * @property
+ * @type String
+ */
+ type: 'triangle',
+
+ /**
+ * Constructor
+ * @method initialize
+ * @param {Object} [options] Options object
+ * @return {Object} thisArg
+ */
+ initialize: function(options) {
+ options = options || { };
+
+ this.callSuper('initialize', options);
+
+ this.set('width', options.width || 100)
+ .set('height', options.height || 100);
+ },
+
+ /**
+ * @private
+ * @method _render
+ * @param ctx {CanvasRenderingContext2D} Context to render on
+ */
+ _render: function(ctx) {
+ var widthBy2 = this.width / 2,
+ heightBy2 = this.height / 2;
+
+ ctx.beginPath();
+ ctx.moveTo(-widthBy2, heightBy2);
+ ctx.lineTo(0, -heightBy2);
+ ctx.lineTo(widthBy2, heightBy2);
+ ctx.closePath();
+
+ if (this.fill) {
+ ctx.fill();
+ }
+ if (this.stroke) {
+ ctx.stroke();
+ }
+ },
+
+ /**
+ * Returns complexity of an instance
+ * @method complexity
+ * @return {Number} complexity of this instance
+ */
+ complexity: function() {
+ return 1;
+ },
+
+ /**
+ * Returns SVG representation of an instance
+ * @method toSVG
+ * @return {String} svg representation of an instance
+ */
+ toSVG: function() {
+
+ var widthBy2 = this.width / 2,
+ heightBy2 = this.height / 2;
+
+ var points = [
+ -widthBy2 + " " + heightBy2,
+ "0 " + -heightBy2,
+ widthBy2 + " " + heightBy2
+ ].join(",");
+
+ return '';
+ }
+ });
+
+ /**
+ * Returns fabric.Triangle instance from an object representation
+ * @static
+ * @method Canvas.Trangle.fromObject
+ * @param object {Object} object to create an instance from
+ * @return {Object} instance of Canvas.Triangle
+ */
+ fabric.Triangle.fromObject = function(object) {
+ return new fabric.Triangle(object);
+ };
+
+})(typeof exports !== 'undefined' ? exports : this);
+(function(global){
+
+ "use strict";
+
+ var fabric = global.fabric || (global.fabric = { }),
+ piBy2 = Math.PI * 2,
+ extend = fabric.util.object.extend;
+
+ if (fabric.Ellipse) {
+ fabric.warn('fabric.Ellipse is already defined.');
+ return;
+ }
+
+ /**
+ * Ellipse class
+ * @class Ellipse
+ * @extends fabric.Object
+ */
+ fabric.Ellipse = fabric.util.createClass(fabric.Object, /** @scope fabric.Ellipse.prototype */ {
+
+ /**
+ * Type of an object
+ * @property
+ * @type String
+ */
+ type: 'ellipse',
+
+ /**
+ * Constructor
+ * @method initialize
+ * @param {Object} [options] Options object
+ * @return {fabric.Ellipse} thisArg
+ */
+ initialize: function(options) {
+ options = options || { };
+
+ this.callSuper('initialize', options);
+
+ this.set('rx', options.rx || 0);
+ this.set('ry', options.ry || 0);
+
+ this.set('width', this.get('rx') * 2);
+ this.set('height', this.get('ry') * 2);
+ },
+
+ /**
+ * Returns object representation of an instance
+ * @method toObject
+ * @param {Array} propertiesToInclude
+ * @return {Object} object representation of an instance
+ */
+ toObject: function(propertiesToInclude) {
+ return extend(this.callSuper('toObject', propertiesToInclude), {
+ rx: this.get('rx'),
+ ry: this.get('ry')
+ });
+ },
+
+ /**
+ * Returns svg representation of an instance
+ * @method toSVG
+ * @return {String} svg representation of an instance
+ */
+ toSVG: function() {
+ return [
+ ''
+ ].join('');
+ },
+
+ /**
+ * Renders this instance on a given context
+ * @method render
+ * @param ctx {CanvasRenderingContext2D} context to render on
+ * @param noTransform {Boolean} context is not transformed when set to true
+ */
+ render: function(ctx, noTransform) {
+ // do not use `get` for perf. reasons
+ if (this.rx === 0 || this.ry === 0) return;
+ return this.callSuper('render', ctx, noTransform);
+ },
+
+ /**
+ * @private
+ * @method _render
+ * @param ctx {CanvasRenderingContext2D} context to render on
+ */
+ _render: function(ctx, noTransform) {
+ ctx.beginPath();
+ ctx.save();
+ ctx.globalAlpha = this.group ? (ctx.globalAlpha * this.opacity) : this.opacity;
+ if (this.transformMatrix && this.group) {
+ ctx.translate(this.cx, this.cy);
+ }
+ ctx.transform(1, 0, 0, this.ry/this.rx, 0, 0);
+ ctx.arc(noTransform ? this.left : 0, noTransform ? this.top : 0, this.rx, 0, piBy2, false);
+ if (this.stroke) {
+ ctx.stroke();
+ }
+ if (this.fill) {
+ ctx.fill();
+ }
+ ctx.restore();
+ },
+
+ /**
+ * Returns complexity of an instance
+ * @method complexity
+ * @return {Number} complexity
+ */
+ complexity: function() {
+ return 1;
+ }
+ });
+
+ /**
+ * List of attribute names to account for when parsing SVG element (used by {@link fabric.Ellipse.fromElement})
+ * @static
+ * @see http://www.w3.org/TR/SVG/shapes.html#EllipseElement
+ */
+ fabric.Ellipse.ATTRIBUTE_NAMES = 'cx cy rx ry fill fill-opacity opacity stroke stroke-width transform'.split(' ');
+
+ /**
+ * Returns {@link fabric.Ellipse} instance from an SVG element
+ * @static
+ * @method fabric.Ellipse.fromElement
+ * @param {SVGElement} element Element to parse
+ * @param {Object} [options] Options object
+ * @return {fabric.Ellipse}
+ */
+ fabric.Ellipse.fromElement = function(element, options) {
+ options || (options = { });
+
+ var parsedAttributes = fabric.parseAttributes(element, fabric.Ellipse.ATTRIBUTE_NAMES);
+ var cx = parsedAttributes.left;
+ var cy = parsedAttributes.top;
+
+ if ('left' in parsedAttributes) {
+ parsedAttributes.left -= (options.width / 2) || 0;
+ }
+ if ('top' in parsedAttributes) {
+ parsedAttributes.top -= (options.height / 2) || 0;
+ }
+
+ var ellipse = new fabric.Ellipse(extend(parsedAttributes, options));
+
+ ellipse.cx = cx || 0;
+ ellipse.cy = cy || 0;
+
+ return ellipse;
+ };
+
+ /**
+ * Returns {@link fabric.Ellipse} instance from an object representation
+ * @static
+ * @method fabric.Ellipse.fromObject
+ * @param {Object} object Object to create an instance from
+ * @return {fabric.Ellipse}
+ */
+ fabric.Ellipse.fromObject = function(object) {
+ return new fabric.Ellipse(object);
+ };
+
+})(typeof exports !== 'undefined' ? exports : this);
+(function(global) {
+
+ "use strict";
+
+ var fabric = global.fabric || (global.fabric = { }),
+ extend = fabric.util.object.extend;
+
+ if (fabric.Rect) {
+ console.warn('fabric.Rect is already defined');
+ return;
+ }
+
+ /**
+ * Rectangle class
+ * @class Rect
+ * @extends fabric.Object
+ */
+ fabric.Rect = fabric.util.createClass(fabric.Object, /** @scope fabric.Rect.prototype */ {
+
+ /**
+ * Type of an object
+ * @property
+ * @type String
+ */
+ type: 'rect',
+
+ /**
+ * Horizontal border radius
+ * @property
+ * @type Number
+ */
+ rx: 0,
+
+ /**
+ * Vertical border radius
+ * @property
+ * @type Number
+ */
+ ry: 0,
+
+ /**
+ * Constructor
+ * @method initialize
+ * @param {Object} [options] Options object
+ * @return {Object} thisArg
+ */
+ initialize: function(options) {
+ options = options || { };
+
+ this._initStateProperties();
+ this.callSuper('initialize', options);
+ this._initRxRy();
+
+ this.x = 0;
+ this.y = 0;
+ },
+
+ /**
+ * Creates `stateProperties` list on an instance, and adds `fabric.Rect` -specific ones to it
+ * (such as "rx", "ry", etc.)
+ * @private
+ * @method _initStateProperties
+ */
+ _initStateProperties: function() {
+ this.stateProperties = this.stateProperties.concat(['rx', 'ry']);
+ },
+
+ /**
+ * Initializes rx/ry attributes
+ * @private
+ * @method _initRxRy
+ */
+ _initRxRy: function() {
+ if (this.rx && !this.ry) {
+ this.ry = this.rx;
+ }
+ else if (this.ry && !this.rx) {
+ this.rx = this.ry;
+ }
+ },
+
+ /**
+ * @private
+ * @method _render
+ * @param ctx {CanvasRenderingContext2D} context to render on
+ */
+ _render: function(ctx) {
+ var rx = this.rx || 0,
+ ry = this.ry || 0,
+ x = -this.width / 2,
+ y = -this.height / 2,
+ w = this.width,
+ h = this.height;
+
+ ctx.beginPath();
+ ctx.globalAlpha = this.group ? (ctx.globalAlpha * this.opacity) : this.opacity;
+
+ if (this.transformMatrix && this.group) {
+ ctx.translate(
+ this.width / 2 + this.x,
+ this.height / 2 + this.y);
+ }
+ if (!this.transformMatrix && this.group) {
+ ctx.translate(
+ -this.group.width / 2 + this.width / 2 + this.x,
+ -this.group.height / 2 + this.height / 2 + this.y);
+ }
+
+ ctx.moveTo(x+rx, y);
+ ctx.lineTo(x+w-rx, y);
+ ctx.quadraticCurveTo(x+w, y, x+w, y+ry, x+w, y+ry);
+ ctx.lineTo(x+w, y+h-ry);
+ ctx.quadraticCurveTo(x+w,y+h,x+w-rx,y+h,x+w-rx,y+h);
+ ctx.lineTo(x+rx,y+h);
+ ctx.quadraticCurveTo(x,y+h,x,y+h-ry,x,y+h-ry);
+ ctx.lineTo(x,y+ry);
+ ctx.quadraticCurveTo(x,y,x+rx,y,x+rx,y);
+ ctx.closePath();
+
+ if (this.fill) {
+ ctx.fill();
+ }
+
+ if (this.strokeDashArray) {
+ this._renderDashedStroke(ctx);
+ }
+ else if (this.stroke) {
+ ctx.stroke();
+ }
+ },
+
+ /**
+ * @method _normalizeLeftTopProperties
+ * @private
+ * Since coordinate system differs from that of SVG
+ */
+ _normalizeLeftTopProperties: function(parsedAttributes) {
+ if (parsedAttributes.left) {
+ this.set('left', parsedAttributes.left + this.getWidth() / 2);
+ }
+ this.set('x', parsedAttributes.left || 0);
+ if (parsedAttributes.top) {
+ this.set('top', parsedAttributes.top + this.getHeight() / 2);
+ }
+ this.set('y', parsedAttributes.top || 0);
+ return this;
+ },
+
+ /**
+ * Returns complexity of an instance
+ * @method complexity
+ * @return {Number} complexity
+ */
+ complexity: function() {
+ return 1;
+ },
+
+ /**
+ * Returns object representation of an instance
+ * @method toObject
+ * @param {Array} propertiesToInclude
+ * @return {Object} object representation of an instance
+ */
+ toObject: function(propertiesToInclude) {
+ return extend(this.callSuper('toObject', propertiesToInclude), {
+ rx: this.get('rx') || 0,
+ ry: this.get('ry') || 0
+ });
+ },
+
+ /**
+ * Returns svg representation of an instance
+ * @method toSVG
+ * @return {String} svg representation of an instance
+ */
+ toSVG: function() {
+ return '';
+ }
+ });
+
+ /**
+ * List of attribute names to account for when parsing SVG element (used by `fabric.Rect.fromElement`)
+ * @static
+ */
+ fabric.Rect.ATTRIBUTE_NAMES = 'x y width height rx ry fill fill-opacity opacity stroke stroke-width transform'.split(' ');
+
+ /**
+ * @private
+ */
+ function _setDefaultLeftTopValues(attributes) {
+ attributes.left = attributes.left || 0;
+ attributes.top = attributes.top || 0;
+ return attributes;
+ }
+
+ /**
+ * Returns {@link fabric.Rect} instance from an SVG element
+ * @static
+ * @method fabric.Rect.fromElement
+ * @param {SVGElement} element Element to parse
+ * @param {Object} [options] Options object
+ * @return {fabric.Rect} Instance of fabric.Rect
+ */
+ fabric.Rect.fromElement = function(element, options) {
+ if (!element) {
+ return null;
+ }
+
+ var parsedAttributes = fabric.parseAttributes(element, fabric.Rect.ATTRIBUTE_NAMES);
+ parsedAttributes = _setDefaultLeftTopValues(parsedAttributes);
+
+ var rect = new fabric.Rect(extend((options ? fabric.util.object.clone(options) : { }), parsedAttributes));
+ rect._normalizeLeftTopProperties(parsedAttributes);
+
+ return rect;
+ };
+
+ /**
+ * Returns {@link fabric.Rect} instance from an object representation
+ * @static
+ * @method fabric.Rect.fromObject
+ * @param object {Object} object to create an instance from
+ * @return {Object} instance of fabric.Rect
+ */
+ fabric.Rect.fromObject = function(object) {
+ return new fabric.Rect(object);
+ };
+
+})(typeof exports !== 'undefined' ? exports : this);
+(function(global) {
+
+ "use strict";
+
+ var fabric = global.fabric || (global.fabric = { }),
+ toFixed = fabric.util.toFixed;
+
+ if (fabric.Polyline) {
+ fabric.warn('fabric.Polyline is already defined');
+ return;
+ }
+
+ /**
+ * Polyline class
+ * @class Polyline
+ * @extends fabric.Object
+ */
+ fabric.Polyline = fabric.util.createClass(fabric.Object, /** @scope fabric.Polyline.prototype */ {
+
+ /**
+ * Type of an object
+ * @property
+ * @type String
+ */
+ type: 'polyline',
+
+ /**
+ * Constructor
+ * @method initialize
+ * @param {Array} points array of points
+ * @param {Object} [options] Options object
+ * @return {Object} thisArg
+ */
+ initialize: function(points, options) {
+ options = options || { };
+ this.set('points', points);
+ this.callSuper('initialize', options);
+ this._calcDimensions();
+ },
+
+ /**
+ * @private
+ * @method _calcDimensions
+ */
+ _calcDimensions: function() {
+ return fabric.Polygon.prototype._calcDimensions.call(this);
+ },
+
+ /**
+ * Returns object representation of an instance
+ * @method toObject
+ * @param {Array} propertiesToInclude
+ * @return {Object} object representation of an instance
+ */
+ toObject: function(propertiesToInclude) {
+ return fabric.Polygon.prototype.toObject.call(this, propertiesToInclude);
+ },
+
+ /**
+ * Returns SVG representation of an instance
+ * @method toSVG
+ * @return {String} svg representation of an instance
+ */
+ toSVG: function() {
+ var points = [];
+ for (var i = 0, len = this.points.length; i < len; i++) {
+ points.push(toFixed(this.points[i].x, 2), ',', toFixed(this.points[i].y, 2), ' ');
+ }
+
+ return [
+ ''
+ ].join('');
+ },
+
+ /**
+ * @private
+ * @method _render
+ * @param {CanvasRenderingContext2D} ctx Context to render on
+ */
+ _render: function(ctx) {
+ var point;
+ ctx.beginPath();
+ ctx.moveTo(this.points[0].x, this.points[0].y);
+ for (var i = 0, len = this.points.length; i < len; i++) {
+ point = this.points[i];
+ ctx.lineTo(point.x, point.y);
+ }
+ if (this.fill) {
+ ctx.fill();
+ }
+ if (this.stroke) {
+ ctx.stroke();
+ }
+ },
+
+ /**
+ * Returns complexity of an instance
+ * @method complexity
+ * @return {Number} complexity
+ */
+ complexity: function() {
+ return this.get('points').length;
+ }
+ });
+
+ /**
+ * List of attribute names to account for when parsing SVG element (used by {@link fabric.Polyline.fromElement})
+ * @static
+ * @see: http://www.w3.org/TR/SVG/shapes.html#PolylineElement
+ */
+ fabric.Polyline.ATTRIBUTE_NAMES = 'fill fill-opacity opacity stroke stroke-width transform'.split(' ');
+
+ /**
+ * Returns fabric.Polyline instance from an SVG element
+ * @static
+ * @method fabric.Polyline.fromElement
+ * @param {SVGElement} element Element to parse
+ * @param {Object} [options] Options object
+ * @return {Object} instance of fabric.Polyline
+ */
+ fabric.Polyline.fromElement = function(element, options) {
+ if (!element) {
+ return null;
+ }
+ options || (options = { });
+
+ var points = fabric.parsePointsAttribute(element.getAttribute('points')),
+ parsedAttributes = fabric.parseAttributes(element, fabric.Polyline.ATTRIBUTE_NAMES);
+
+ for (var i = 0, len = points.length; i < len; i++) {
+ // normalize coordinates, according to containing box (dimensions of which are passed via `options`)
+ points[i].x -= (options.width / 2) || 0;
+ points[i].y -= (options.height / 2) || 0;
+ }
+
+ return new fabric.Polyline(points, fabric.util.object.extend(parsedAttributes, options));
+ };
+
+ /**
+ * Returns fabric.Polyline instance from an object representation
+ * @static
+ * @method fabric.Polyline.fromObject
+ * @param {Object} [object] Object to create an instance from
+ * @return {fabric.Polyline}
+ */
+ fabric.Polyline.fromObject = function(object) {
+ var points = object.points;
+ return new fabric.Polyline(points, object);
+ };
+
+})(typeof exports !== 'undefined' ? exports : this);
+(function(global) {
+
+ "use strict";
+
+ var fabric = global.fabric || (global.fabric = { }),
+ extend = fabric.util.object.extend,
+ min = fabric.util.array.min,
+ max = fabric.util.array.max,
+ toFixed = fabric.util.toFixed;
+
+ if (fabric.Polygon) {
+ fabric.warn('fabric.Polygon is already defined');
+ return;
+ }
+
+ /**
+ * Polygon class
+ * @class Polygon
+ * @extends fabric.Object
+ */
+ fabric.Polygon = fabric.util.createClass(fabric.Object, /** @scope fabric.Polygon.prototype */ {
+
+ /**
+ * Type of an object
+ * @property
+ * @type String
+ */
+ type: 'polygon',
+
+ /**
+ * Constructor
+ * @method initialize
+ * @param {Array} points Array of points
+ * @param {Object} [options] Options object
+ * @return {fabric.Polygon} thisArg
+ */
+ initialize: function(points, options) {
+ options = options || { };
+ this.points = points;
+ this.callSuper('initialize', options);
+ this._calcDimensions();
+ },
+
+ /**
+ * @private
+ * @method _calcDimensions
+ */
+ _calcDimensions: function() {
+
+ var points = this.points,
+ minX = min(points, 'x'),
+ minY = min(points, 'y'),
+ maxX = max(points, 'x'),
+ maxY = max(points, 'y');
+
+ this.width = (maxX - minX) || 1;
+ this.height = (maxY - minY) || 1;
+
+ this.minX = minX;
+ this.minY = minY;
+ },
+
+ /**
+ * Returns object representation of an instance
+ * @method toObject
+ * @param {Array} propertiesToInclude
+ * @return {Object} object representation of an instance
+ */
+ toObject: function(propertiesToInclude) {
+ return extend(this.callSuper('toObject', propertiesToInclude), {
+ points: this.points.concat()
+ });
+ },
+
+ /**
+ * Returns svg representation of an instance
+ * @method toSVG
+ * @return {String} svg representation of an instance
+ */
+ toSVG: function() {
+ var points = [];
+ for (var i = 0, len = this.points.length; i < len; i++) {
+ points.push(toFixed(this.points[i].x, 2), ',', toFixed(this.points[i].y, 2), ' ');
+ }
+
+ return [
+ ''
+ ].join('');
+ },
+
+ /**
+ * @private
+ * @method _render
+ * @param ctx {CanvasRenderingContext2D} context to render on
+ */
+ _render: function(ctx) {
+ var point;
+ ctx.beginPath();
+ ctx.moveTo(this.points[0].x, this.points[0].y);
+ for (var i = 0, len = this.points.length; i < len; i++) {
+ point = this.points[i];
+ ctx.lineTo(point.x, point.y);
+ }
+ if (this.fill) {
+ ctx.fill();
+ }
+ if (this.stroke) {
+ ctx.closePath();
+ ctx.stroke();
+ }
+ },
+
+ /**
+ * Returns complexity of an instance
+ * @method complexity
+ * @return {Number} complexity of this instance
+ */
+ complexity: function() {
+ return this.points.length;
+ }
+ });
+
+ /**
+ * List of attribute names to account for when parsing SVG element (used by `fabric.Polygon.fromElement`)
+ * @static
+ * @see: http://www.w3.org/TR/SVG/shapes.html#PolygonElement
+ */
+ fabric.Polygon.ATTRIBUTE_NAMES = 'fill fill-opacity opacity stroke stroke-width transform'.split(' ');
+
+ /**
+ * Returns {@link fabric.Polygon} instance from an SVG element
+ * @static
+ * @method fabric.Polygon.fromElement
+ * @param {SVGElement} element Element to parse
+ * @param {Object} [options] Options object
+ * @return {fabric.Polygon}
+ */
+ fabric.Polygon.fromElement = function(element, options) {
+ if (!element) {
+ return null;
+ }
+ options || (options = { });
+
+ var points = fabric.parsePointsAttribute(element.getAttribute('points')),
+ parsedAttributes = fabric.parseAttributes(element, fabric.Polygon.ATTRIBUTE_NAMES);
+
+ for (var i = 0, len = points.length; i < len; i++) {
+ // normalize coordinates, according to containing box (dimensions of which are passed via `options`)
+ points[i].x -= (options.width / 2) || 0;
+ points[i].y -= (options.height / 2) || 0;
+ }
+
+ return new fabric.Polygon(points, extend(parsedAttributes, options));
+ };
+
+ /**
+ * Returns fabric.Polygon instance from an object representation
+ * @static
+ * @method fabric.Polygon.fromObject
+ * @param {Object} object Object to create an instance from
+ * @return {fabric.Polygon}
+ */
+ fabric.Polygon.fromObject = function(object) {
+ return new fabric.Polygon(object.points, object);
+ };
+
+})(typeof exports !== 'undefined' ? exports : this);
+(function(global) {
+
+ var commandLengths = {
+ m: 2,
+ l: 2,
+ h: 1,
+ v: 1,
+ c: 6,
+ s: 4,
+ q: 4,
+ t: 2,
+ a: 7
+ };
+
+ function drawArc(ctx, x, y, coords) {
+ var rx = coords[0];
+ var ry = coords[1];
+ var rot = coords[2];
+ var large = coords[3];
+ var sweep = coords[4];
+ var ex = coords[5];
+ var ey = coords[6];
+ var segs = arcToSegments(ex, ey, rx, ry, large, sweep, rot, x, y);
+ for (var i=0; i 1) {
+ pl = Math.sqrt(pl);
+ rx *= pl;
+ ry *= pl;
+ }
+
+ var a00 = cos_th / rx;
+ var a01 = sin_th / rx;
+ var a10 = (-sin_th) / ry;
+ var a11 = (cos_th) / ry;
+ var x0 = a00 * ox + a01 * oy;
+ var y0 = a10 * ox + a11 * oy;
+ var x1 = a00 * x + a01 * y;
+ var y1 = a10 * x + a11 * y;
+
+ var d = (x1-x0) * (x1-x0) + (y1-y0) * (y1-y0);
+ var sfactor_sq = 1 / d - 0.25;
+ if (sfactor_sq < 0) sfactor_sq = 0;
+ var sfactor = Math.sqrt(sfactor_sq);
+ if (sweep === large) sfactor = -sfactor;
+ var xc = 0.5 * (x0 + x1) - sfactor * (y1-y0);
+ var yc = 0.5 * (y0 + y1) + sfactor * (x1-x0);
+
+ var th0 = Math.atan2(y0-yc, x0-xc);
+ var th1 = Math.atan2(y1-yc, x1-xc);
+
+ var th_arc = th1-th0;
+ if (th_arc < 0 && sweep === 1){
+ th_arc += 2*Math.PI;
+ } else if (th_arc > 0 && sweep === 0) {
+ th_arc -= 2 * Math.PI;
+ }
+
+ var segments = Math.ceil(Math.abs(th_arc / (Math.PI * 0.5 + 0.001)));
+ var result = [];
+ for (var i=0; i';
+ },
+
+ /**
+ * Returns object representation of an instance
+ * @method toObject
+ * @param {Array} propertiesToInclude
+ * @return {Object} object representation of an instance
+ */
+ toObject: function(propertiesToInclude) {
+ var o = extend(this.callSuper('toObject', propertiesToInclude), {
+ path: this.path
+ });
+ if (this.sourcePath) {
+ o.sourcePath = this.sourcePath;
+ }
+ if (this.transformMatrix) {
+ o.transformMatrix = this.transformMatrix;
+ }
+ return o;
+ },
+
+ /**
+ * Returns dataless object representation of an instance
+ * @method toDatalessObject
+ * @param {Array} propertiesToInclude
+ * @return {Object} object representation of an instance
+ */
+ toDatalessObject: function(propertiesToInclude) {
+ var o = this.toObject(propertiesToInclude);
+ if (this.sourcePath) {
+ o.path = this.sourcePath;
+ }
+ delete o.sourcePath;
+ return o;
+ },
+
+ /**
+ * Returns svg representation of an instance
+ * @method toSVG
+ * @return {String} svg representation of an instance
+ */
+ toSVG: function() {
+ var chunks = [];
+ for (var i = 0, len = this.path.length; i < len; i++) {
+ chunks.push(this.path[i].join(' '));
+ }
+ var path = chunks.join(' ');
+
+ return [
+ '',
+ '',
+ ''
+ ].join('');
+ },
+
+ /**
+ * Returns number representation of an instance complexity
+ * @method complexity
+ * @return {Number} complexity
+ */
+ complexity: function() {
+ return this.path.length;
+ },
+
+ /**
+ * @private
+ * @method _parsePath
+ */
+ _parsePath: function() {
+ var result = [ ],
+ currentPath,
+ chunks,
+ parsed;
+
+ for (var i = 0, chunksParsed, len = this.path.length; i < len; i++) {
+ currentPath = this.path[i];
+ chunks = currentPath.slice(1).trim().replace(/(\d)-/g, '$1###-').split(/\s|,|###/);
+ chunksParsed = [ currentPath.charAt(0) ];
+
+ for (var j = 0, jlen = chunks.length; j < jlen; j++) {
+ parsed = parseFloat(chunks[j]);
+ if (!isNaN(parsed)) {
+ chunksParsed.push(parsed);
+ }
+ }
+
+ var command = chunksParsed[0].toLowerCase(),
+ commandLength = commandLengths[command];
+
+ if (chunksParsed.length - 1 > commandLength) {
+ for (var k = 1, klen = chunksParsed.length; k < klen; k += commandLength) {
+ result.push([ chunksParsed[0] ].concat(chunksParsed.slice(k, k + commandLength)));
+ }
+ }
+ else {
+ result.push(chunksParsed);
+ }
+ }
+
+ return result;
+ },
+
+ /**
+ * @method _parseDimensions
+ */
+ _parseDimensions: function() {
+ var aX = [],
+ aY = [],
+ previousX,
+ previousY,
+ isLowerCase = false,
+ x,
+ y;
+
+ this.path.forEach(function(item, i) {
+ if (item[0] !== 'H') {
+ previousX = (i === 0) ? getX(item) : getX(this.path[i-1]);
+ }
+ if (item[0] !== 'V') {
+ previousY = (i === 0) ? getY(item) : getY(this.path[i-1]);
+ }
+
+ // lowercased letter denotes relative position;
+ // transform to absolute
+ if (item[0] === item[0].toLowerCase()) {
+ isLowerCase = true;
+ }
+
+ // last 2 items in an array of coordinates are the actualy x/y (except H/V);
+ // collect them
+
+ // TODO (kangax): support relative h/v commands
+
+ x = isLowerCase
+ ? previousX + getX(item)
+ : item[0] === 'V'
+ ? previousX
+ : getX(item);
+
+ y = isLowerCase
+ ? previousY + getY(item)
+ : item[0] === 'H'
+ ? previousY
+ : getY(item);
+
+ var val = parseInt(x, 10);
+ if (!isNaN(val)) aX.push(val);
+
+ val = parseInt(y, 10);
+ if (!isNaN(val)) aY.push(val);
+
+ }, this);
+
+ var minX = min(aX),
+ minY = min(aY),
+ maxX = max(aX),
+ maxY = max(aY),
+ deltaX = maxX - minX,
+ deltaY = maxY - minY;
+
+ var o = {
+ top: minY + deltaY / 2,
+ left: minX + deltaX / 2,
+ bottom: max(aY) - deltaY,
+ right: max(aX) - deltaX
+ };
+
+ o.width = deltaX;
+ o.height = deltaY;
+
+ return o;
+ }
+ });
+
+ /**
+ * Creates an instance of fabric.Path from an object
+ * @static
+ * @method fabric.Path.fromObject
+ * @return {fabric.Path} Instance of fabric.Path
+ */
+ fabric.Path.fromObject = function(object) {
+ return new fabric.Path(object.path, object);
+ };
+
+ /**
+ * List of attribute names to account for when parsing SVG element (used by `fabric.Path.fromElement`)
+ * @static
+ * @see http://www.w3.org/TR/SVG/paths.html#PathElement
+ */
+ fabric.Path.ATTRIBUTE_NAMES = 'd fill fill-opacity opacity fill-rule stroke stroke-width transform'.split(' ');
+
+ /**
+ * Creates an instance of fabric.Path from an SVG element
+ * @static
+ * @method fabric.Path.fromElement
+ * @param {SVGElement} element to parse
+ * @param {Object} [options] Options object
+ * @return {fabric.Path} Instance of fabric.Path
+ */
+ fabric.Path.fromElement = function(element, options) {
+ var parsedAttributes = fabric.parseAttributes(element, fabric.Path.ATTRIBUTE_NAMES);
+ return new fabric.Path(parsedAttributes.d, extend(parsedAttributes, options));
+ };
+
+})(typeof exports !== 'undefined' ? exports : this);
+
+(function(global) {
+
+ "use strict";
+
+ var fabric = global.fabric || (global.fabric = { }),
+ extend = fabric.util.object.extend,
+ invoke = fabric.util.array.invoke,
+ parentToObject = fabric.Object.prototype.toObject,
+ camelize = fabric.util.string.camelize,
+ capitalize = fabric.util.string.capitalize;
+
+ if (fabric.PathGroup) {
+ fabric.warn('fabric.PathGroup is already defined');
+ return;
+ }
+
+ /**
+ * Path group class
+ * @class PathGroup
+ * @extends fabric.Path
+ */
+ fabric.PathGroup = fabric.util.createClass(fabric.Path, /** @scope fabric.PathGroup.prototype */ {
+
+ /**
+ * Type of an object
+ * @property
+ * @type String
+ */
+ type: 'path-group',
+
+ /**
+ * Fill value
+ * @property
+ * @type String
+ */
+ fill: '',
+
+ /**
+ * Constructor
+ * @method initialize
+ * @param {Array} paths
+ * @param {Object} [options] Options object
+ * @return {fabric.PathGroup} thisArg
+ */
+ initialize: function(paths, options) {
+
+ options = options || { };
+ this.paths = paths || [ ];
+
+ for (var i = this.paths.length; i--; ) {
+ this.paths[i].group = this;
+ }
+
+ this.setOptions(options);
+ this.setCoords();
+
+ if (options.sourcePath) {
+ this.setSourcePath(options.sourcePath);
+ }
+ },
+
+ /**
+ * Renders this group on a specified context
+ * @method render
+ * @param {CanvasRenderingContext2D} ctx Context to render this instance on
+ */
+ render: function(ctx) {
+ ctx.save();
+
+ var m = this.transformMatrix;
+ if (m) {
+ ctx.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
+ }
+
+ this.transform(ctx);
+ for (var i = 0, l = this.paths.length; i < l; ++i) {
+ this.paths[i].render(ctx, true);
+ }
+ if (this.active) {
+ this.drawBorders(ctx);
+ this.hideCorners || this.drawCorners(ctx);
+ }
+ ctx.restore();
+ },
+
+ /**
+ * Sets certain property to a certain value
+ * @method _set
+ * @param {String} prop
+ * @param {Any} value
+ * @return {fabric.PathGroup} thisArg
+ */
+ _set: function(prop, value) {
+
+ if ((prop === 'fill' || prop === 'overlayFill') && value && this.isSameColor()) {
+ var i = this.paths.length;
+ while (i--) {
+ this.paths[i]._set(prop, value);
+ }
+ }
+
+ return this.callSuper('_set', prop, value);
+ },
+
+ /**
+ * Returns object representation of this path group
+ * @method toObject
+ * @param {Array} [propertiesToInclude]
+ * @return {Object} object representation of an instance
+ */
+ toObject: function(propertiesToInclude) {
+ return extend(parentToObject.call(this, propertiesToInclude), {
+ paths: invoke(this.getObjects(), 'toObject', propertiesToInclude),
+ sourcePath: this.sourcePath
+ });
+ },
+
+ /**
+ * Returns dataless object representation of this path group
+ * @method toDatalessObject
+ * @param {Array} [propertiesToInclude]
+ * @return {Object} dataless object representation of an instance
+ */
+ toDatalessObject: function(propertiesToInclude) {
+ var o = this.toObject(propertiesToInclude);
+ if (this.sourcePath) {
+ o.paths = this.sourcePath;
+ }
+ return o;
+ },
+
+ /**
+ * Returns svg representation of an instance
+ * @method toSVG
+ * @return {String} svg representation of an instance
+ */
+ toSVG: function() {
+ var objects = this.getObjects();
+ var markup = [
+ ''
+ ];
+
+ for (var i = 0, len = objects.length; i < len; i++) {
+ markup.push(objects[i].toSVG());
+ }
+ markup.push('');
+
+ return markup.join('');
+ },
+
+ /**
+ * Returns a string representation of this path group
+ * @method toString
+ * @return {String} string representation of an object
+ */
+ toString: function() {
+ return '#';
+ },
+
+ /**
+ * Returns true if all paths in this group are of same color
+ * @method isSameColor
+ * @return {Boolean} true if all paths are of the same color (`fill`)
+ */
+ isSameColor: function() {
+ var firstPathFill = this.getObjects()[0].get('fill');
+ return this.getObjects().every(function(path) {
+ return path.get('fill') === firstPathFill;
+ });
+ },
+
+ /**
+ * Returns number representation of object's complexity
+ * @method complexity
+ * @return {Number} complexity
+ */
+ complexity: function() {
+ return this.paths.reduce(function(total, path) {
+ return total + ((path && path.complexity) ? path.complexity() : 0);
+ }, 0);
+ },
+
+ /**
+ * Makes path group grayscale
+ * @method toGrayscale
+ * @return {fabric.PathGroup} thisArg
+ */
+ toGrayscale: function() {
+ var i = this.paths.length;
+ while (i--) {
+ this.paths[i].toGrayscale();
+ }
+ return this;
+ },
+
+ /**
+ * Returns all paths in this path group
+ * @method getObjects
+ * @return {Array} array of path objects included in this path group
+ */
+ getObjects: function() {
+ return this.paths;
+ }
+ });
+
+ /**
+ * @private
+ * @method instantiatePaths
+ */
+ function instantiatePaths(paths) {
+ for (var i = 0, len = paths.length; i < len; i++) {
+ if (!(paths[i] instanceof fabric.Object)) {
+ var klassName = camelize(capitalize(paths[i].type));
+ paths[i] = fabric[klassName].fromObject(paths[i]);
+ }
+ }
+ return paths;
+ }
+
+ /**
+ * Creates fabric.PathGroup instance from an object representation
+ * @static
+ * @method fabric.PathGroup.fromObject
+ * @param {Object} object
+ * @return {fabric.PathGroup}
+ */
+ fabric.PathGroup.fromObject = function(object) {
+ var paths = instantiatePaths(object.paths);
+ return new fabric.PathGroup(paths, object);
+ };
+
+})(typeof exports !== 'undefined' ? exports : this);
+(function(global){
+
+ "use strict";
+
+ var fabric = global.fabric || (global.fabric = { }),
+ extend = fabric.util.object.extend,
+ min = fabric.util.array.min,
+ max = fabric.util.array.max,
+ invoke = fabric.util.array.invoke,
+ removeFromArray = fabric.util.removeFromArray;
+
+ if (fabric.Group) {
+ return;
+ }
+
+ // lock-related properties, for use in fabric.Group#get
+ // to enable locking behavior on group
+ // when one of its objects has lock-related properties set
+ var _lockProperties = {
+ lockMovementX: true,
+ lockMovementY: true,
+ lockRotation: true,
+ lockScalingX: true,
+ lockScalingY: true,
+ lockUniScaling: true
+ };
+
+ /**
+ * Group class
+ * @class Group
+ * @extends fabric.Object
+ */
+ fabric.Group = fabric.util.createClass(fabric.Object, /** @scope fabric.Group.prototype */ {
+
+ /**
+ * Type of an object
+ * @property
+ * @type String
+ */
+ type: 'group',
+
+ /**
+ * Constructor
+ * @method initialized
+ * @param {Object} objects Group objects
+ * @param {Object} [options] Options object
+ * @return {Object} thisArg
+ */
+ initialize: function(objects, options) {
+ options = options || { };
+
+ this.objects = objects || [];
+ this.originalState = { };
+
+ this.callSuper('initialize');
+
+ this._calcBounds();
+ this._updateObjectsCoords();
+
+ if (options) {
+ extend(this, options);
+ }
+ this._setOpacityIfSame();
+
+ // group is active by default
+ this.setCoords(true);
+ this.saveCoords();
+
+ //this.activateAllObjects();
+ },
+
+ /**
+ * @private
+ * @method _updateObjectsCoords
+ */
+ _updateObjectsCoords: function() {
+ var groupDeltaX = this.left,
+ groupDeltaY = this.top;
+
+ this.forEachObject(function(object) {
+
+ var objectLeft = object.get('left'),
+ objectTop = object.get('top');
+
+ object.set('originalLeft', objectLeft);
+ object.set('originalTop', objectTop);
+
+ object.set('left', objectLeft - groupDeltaX);
+ object.set('top', objectTop - groupDeltaY);
+
+ object.setCoords();
+
+ // do not display corners of objects enclosed in a group
+ object.hideCorners = true;
+ }, this);
+ },
+
+ /**
+ * Returns string represenation of a group
+ * @method toString
+ * @return {String}
+ */
+ toString: function() {
+ return '#';
+ },
+
+ /**
+ * Returns an array of all objects in this group
+ * @method getObjects
+ * @return {Array} group objects
+ */
+ getObjects: function() {
+ return this.objects;
+ },
+
+ /**
+ * Adds an object to a group; Then recalculates group's dimension, position.
+ * @method addWithUpdate
+ * @param {Object} object
+ * @return {fabric.Group} thisArg
+ * @chainable
+ */
+ addWithUpdate: function(object) {
+ this._restoreObjectsState();
+ this.objects.push(object);
+ this._calcBounds();
+ this._updateObjectsCoords();
+ return this;
+ },
+
+ /**
+ * Removes an object from a group; Then recalculates group's dimension, position.
+ * @method removeWithUpdate
+ * @param {Object} object
+ * @return {fabric.Group} thisArg
+ * @chainable
+ */
+ removeWithUpdate: function(object) {
+ this._restoreObjectsState();
+ removeFromArray(this.objects, object);
+ object.setActive(false);
+ this._calcBounds();
+ this._updateObjectsCoords();
+ return this;
+ },
+
+ /**
+ * Adds an object to a group
+ * @method add
+ * @param {Object} object
+ * @return {fabric.Group} thisArg
+ * @chainable
+ */
+ add: function(object) {
+ this.objects.push(object);
+ return this;
+ },
+
+ /**
+ * Removes an object from a group
+ * @method remove
+ * @param {Object} object
+ * @return {fabric.Group} thisArg
+ * @chainable
+ */
+ remove: function(object) {
+ removeFromArray(this.objects, object);
+ return this;
+ },
+
+ /**
+ * Returns a size of a group (i.e: length of an array containing its objects)
+ * @return {Number} Group size
+ */
+ size: function() {
+ return this.getObjects().length;
+ },
+
+ /**
+ * Properties that are delegated to group objects when reading/writing
+ */
+ delegatedProperties: {
+ fill: true,
+ opacity: true,
+ fontFamily: true,
+ fontWeight: true,
+ lineHeight: true,
+ textDecoration: true,
+ textShadow: true,
+ backgroundColor: true
+ },
+
+ /**
+ * @private
+ */
+ _set: function(key, value) {
+ if (key in this.delegatedProperties) {
+ var i = this.objects.length;
+ this[key] = value;
+ while (i--) {
+ this.objects[i].set(key, value);
+ }
+ }
+ else {
+ this[key] = value;
+ }
+ },
+
+ /**
+ * Returns true if a group contains an object
+ * @method contains
+ * @param {Object} object Object to check against
+ * @return {Boolean} `true` if group contains an object
+ */
+ contains: function(object) {
+ return this.objects.indexOf(object) > -1;
+ },
+
+ /**
+ * Returns object representation of an instance
+ * @method toObject
+ * @param {Array} propertiesToInclude
+ * @return {Object} object representation of an instance
+ */
+ toObject: function(propertiesToInclude) {
+ return extend(this.callSuper('toObject', propertiesToInclude), {
+ objects: invoke(this.objects, 'toObject', propertiesToInclude)
+ });
+ },
+
+ /**
+ * Renders instance on a given context
+ * @method render
+ * @param {CanvasRenderingContext2D} ctx context to render instance on
+ */
+ render: function(ctx, noTransform) {
+ ctx.save();
+ this.transform(ctx);
+
+ var groupScaleFactor = Math.max(this.scaleX, this.scaleY);
+
+ //The array is now sorted in order of highest first, so start from end.
+ for (var i = this.objects.length; i > 0; i--) {
+
+ var object = this.objects[i-1],
+ originalScaleFactor = object.borderScaleFactor,
+ originalHasRotatingPoint = object.hasRotatingPoint;
+
+ object.borderScaleFactor = groupScaleFactor;
+ object.hasRotatingPoint = false;
+
+ object.render(ctx);
+
+ object.borderScaleFactor = originalScaleFactor;
+ object.hasRotatingPoint = originalHasRotatingPoint;
+ }
+
+ if (!noTransform && this.active) {
+ this.drawBorders(ctx);
+ this.hideCorners || this.drawCorners(ctx);
+ }
+ ctx.restore();
+ this.setCoords();
+ },
+
+ /**
+ * Returns object from the group at the specified index
+ * @method item
+ * @param index {Number} index of item to get
+ * @return {fabric.Object}
+ */
+ item: function(index) {
+ return this.getObjects()[index];
+ },
+
+ /**
+ * Returns complexity of an instance
+ * @method complexity
+ * @return {Number} complexity
+ */
+ complexity: function() {
+ return this.getObjects().reduce(function(total, object) {
+ total += (typeof object.complexity === 'function') ? object.complexity() : 0;
+ return total;
+ }, 0);
+ },
+
+ /**
+ * Retores original state of each of group objects (original state is that which was before group was created).
+ * @private
+ * @method _restoreObjectsState
+ * @return {fabric.Group} thisArg
+ * @chainable
+ */
+ _restoreObjectsState: function() {
+ this.objects.forEach(this._restoreObjectState, this);
+ return this;
+ },
+
+ /**
+ * Restores original state of a specified object in group
+ * @private
+ * @method _restoreObjectState
+ * @param {fabric.Object} object
+ * @return {fabric.Group} thisArg
+ */
+ _restoreObjectState: function(object) {
+
+ var groupLeft = this.get('left'),
+ groupTop = this.get('top'),
+ groupAngle = this.getAngle() * (Math.PI / 180),
+ rotatedTop = Math.cos(groupAngle) * object.get('top') + Math.sin(groupAngle) * object.get('left'),
+ rotatedLeft = -Math.sin(groupAngle) * object.get('top') + Math.cos(groupAngle) * object.get('left');
+
+ object.setAngle(object.getAngle() + this.getAngle());
+
+ object.set('left', groupLeft + rotatedLeft * this.get('scaleX'));
+ object.set('top', groupTop + rotatedTop * this.get('scaleY'));
+
+ object.set('scaleX', object.get('scaleX') * this.get('scaleX'));
+ object.set('scaleY', object.get('scaleY') * this.get('scaleY'));
+
+ object.setCoords();
+ object.hideCorners = false;
+ object.setActive(false);
+ object.setCoords();
+
+ return this;
+ },
+
+ /**
+ * Destroys a group (restoring state of its objects)
+ * @method destroy
+ * @return {fabric.Group} thisArg
+ * @chainable
+ */
+ destroy: function() {
+ return this._restoreObjectsState();
+ },
+
+ /**
+ * Saves coordinates of this instance (to be used together with `hasMoved`)
+ * @saveCoords
+ * @return {fabric.Group} thisArg
+ * @chainable
+ */
+ saveCoords: function() {
+ this._originalLeft = this.get('left');
+ this._originalTop = this.get('top');
+ return this;
+ },
+
+ /**
+ * Checks whether this group was moved (since `saveCoords` was called last)
+ * @method hasMoved
+ * @return {Boolean} true if an object was moved (since fabric.Group#saveCoords was called)
+ */
+ hasMoved: function() {
+ return this._originalLeft !== this.get('left') ||
+ this._originalTop !== this.get('top');
+ },
+
+ /**
+ * Sets coordinates of all group objects
+ * @method setObjectsCoords
+ * @return {fabric.Group} thisArg
+ * @chainable
+ */
+ setObjectsCoords: function() {
+ this.forEachObject(function(object) {
+ object.setCoords();
+ });
+ return this;
+ },
+
+ /**
+ * Activates (makes active) all group objects
+ * @method activateAllObjects
+ * @return {fabric.Group} thisArg
+ * @chainable
+ */
+ activateAllObjects: function() {
+ this.forEachObject(function(object) {
+ object.setActive();
+ });
+ return this;
+ },
+
+ /**
+ * Executes given function for each object in this group
+ * @method forEachObject
+ * @param {Function} callback
+ * Callback invoked with current object as first argument,
+ * index - as second and an array of all objects - as third.
+ * Iteration happens in reverse order (for performance reasons).
+ * Callback is invoked in a context of Global Object (e.g. `window`)
+ * when no `context` argument is given
+ *
+ * @param {Object} context Context (aka thisObject)
+ *
+ * @return {fabric.Group} thisArg
+ * @chainable
+ */
+ forEachObject: fabric.StaticCanvas.prototype.forEachObject,
+
+ /**
+ * @private
+ * @method _setOpacityIfSame
+ */
+ _setOpacityIfSame: function() {
+ var objects = this.getObjects(),
+ firstValue = objects[0] ? objects[0].get('opacity') : 1;
+
+ var isSameOpacity = objects.every(function(o) {
+ return o.get('opacity') === firstValue;
+ });
+
+ if (isSameOpacity) {
+ this.opacity = firstValue;
+ }
+ },
+
+ /**
+ * @private
+ * @method _calcBounds
+ */
+ _calcBounds: function() {
+ var aX = [],
+ aY = [],
+ minX, minY, maxX, maxY, o, width, height,
+ i = 0,
+ len = this.objects.length;
+
+ for (; i < len; ++i) {
+ o = this.objects[i];
+ o.setCoords();
+ for (var prop in o.oCoords) {
+ aX.push(o.oCoords[prop].x);
+ aY.push(o.oCoords[prop].y);
+ }
+ }
+
+ minX = min(aX);
+ maxX = max(aX);
+ minY = min(aY);
+ maxY = max(aY);
+
+ width = (maxX - minX) || 0;
+ height = (maxY - minY) || 0;
+
+ this.width = width;
+ this.height = height;
+
+ this.left = (minX + width / 2) || 0;
+ this.top = (minY + height / 2) || 0;
+ },
+
+ /**
+ * Checks if point is contained within the group
+ * @method containsPoint
+ * @param {fabric.Point} point point with `x` and `y` properties
+ * @return {Boolean} true if point is contained within group
+ */
+ containsPoint: function(point) {
+
+ var halfWidth = this.get('width') / 2,
+ halfHeight = this.get('height') / 2,
+ centerX = this.get('left'),
+ centerY = this.get('top');
+
+ return centerX - halfWidth < point.x &&
+ centerX + halfWidth > point.x &&
+ centerY - halfHeight < point.y &&
+ centerY + halfHeight > point.y;
+ },
+
+ /**
+ * Makes all of this group's objects grayscale (i.e. calling `toGrayscale` on them)
+ * @method toGrayscale
+ * @return {fabric.Group} thisArg
+ * @chainable
+ */
+ toGrayscale: function() {
+ var i = this.objects.length;
+ while (i--) {
+ this.objects[i].toGrayscale();
+ }
+ return this;
+ },
+
+ /**
+ * Returns svg representation of an instance
+ * @method toSVG
+ * @return {String} svg representation of an instance
+ */
+ toSVG: function() {
+ var objectsMarkup = [ ];
+ for (var i = 0, len = this.objects.length; i < len; i++) {
+ objectsMarkup.push(this.objects[i].toSVG());
+ }
+
+ return (
+ '' +
+ objectsMarkup.join('') +
+ '');
+ },
+
+ /**
+ * Returns requested property
+ * @method get
+ * @param {String} prop Property to get
+ * @return {Any}
+ */
+ get: function(prop) {
+ if (prop in _lockProperties) {
+ if (this[prop]) {
+ return this[prop];
+ }
+ else {
+ for (var i = 0, len = this.objects.length; i < len; i++) {
+ if (this.objects[i][prop]) {
+ return true;
+ }
+ }
+ return false;
+ }
+ }
+ else {
+ return this[prop];
+ }
+ }
+ });
+
+ /**
+ * Returns {@link fabric.Group} instance from an object representation
+ * @static
+ * @method fabric.Group.fromObject
+ * @param {Object} object Object to create a group from
+ * @param {Object} [options] Options object
+ * @return {fabric.Group} An instance of fabric.Group
+ */
+ fabric.Group.fromObject = function(object, callback) {
+ fabric.util.enlivenObjects(object.objects, function(enlivenedObjects) {
+ delete object.objects;
+ callback && callback(new fabric.Group(enlivenedObjects, object));
+ });
+ };
+
+ /**
+ * Indicates that instances of this type are async
+ * @static
+ * @type Boolean
+ */
+ fabric.Group.async = true;
+
+})(typeof exports !== 'undefined' ? exports : this);
+(function(global) {
+
+ "use strict";
+
+ var extend = fabric.util.object.extend;
+
+ if (!global.fabric) {
+ global.fabric = { };
+ }
+
+ if (global.fabric.Image) {
+ fabric.warn('fabric.Image is already defined.');
+ return;
+ }
+
+ /**
+ * Image class
+ * @class Image
+ * @extends fabric.Object
+ */
+ fabric.Image = fabric.util.createClass(fabric.Object, /** @scope fabric.Image.prototype */ {
+
+ /**
+ * Type of an object
+ * @property
+ * @type String
+ */
+ type: 'image',
+
+ /**
+ * Constructor
+ * @param {HTMLImageElement | String} element Image element
+ * @param {Object} [options] Options object
+ * @return {fabric.Image}
+ */
+ initialize: function(element, options) {
+ options || (options = { });
+
+ this.callSuper('initialize', options);
+ this._initElement(element);
+ this._originalImage = this.getElement();
+ this._initConfig(options);
+
+ this.filters = [ ];
+
+ if (options.filters) {
+ this.filters = options.filters;
+ this.applyFilters();
+ }
+ },
+
+ /**
+ * Returns image element which this instance if based on
+ * @method getElement
+ * @return {HTMLImageElement} image element
+ */
+ getElement: function() {
+ return this._element;
+ },
+
+ /**
+ * Sets image element for this instance to a specified one
+ * @method setElement
+ * @param {HTMLImageElement} element
+ * @return {fabric.Image} thisArg
+ * @chainable
+ */
+ setElement: function(element) {
+ this._element = element;
+ this._initConfig();
+ return this;
+ },
+
+ /**
+ * Returns original size of an image
+ * @method getOriginalSize
+ * @return {Object} object with "width" and "height" properties
+ */
+ getOriginalSize: function() {
+ var element = this.getElement();
+ return {
+ width: element.width,
+ height: element.height
+ };
+ },
+
+ /**
+ * Renders image on a specified context
+ * @method render
+ * @param {CanvasRenderingContext2D} ctx Context to render on
+ */
+ render: function(ctx, noTransform) {
+ ctx.save();
+ var m = this.transformMatrix;
+ this._resetWidthHeight();
+ if (this.group) {
+ ctx.translate(-this.group.width/2 + this.width/2, -this.group.height/2 + this.height/2);
+ }
+ if (m) {
+ ctx.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
+ }
+ if (!noTransform) {
+ this.transform(ctx);
+ }
+ this._render(ctx);
+ if (this.active && !noTransform) {
+ this.drawBorders(ctx);
+ this.hideCorners || this.drawCorners(ctx);
+ }
+ ctx.restore();
+ },
+
+ /**
+ * Returns object representation of an instance
+ * @method toObject
+ * @param {Array} propertiesToInclude
+ * @return {Object} object representation of an instance
+ */
+ toObject: function(propertiesToInclude) {
+ return extend(this.callSuper('toObject', propertiesToInclude), {
+ src: this._originalImage.src || this._originalImage._src,
+ filters: this.filters.concat()
+ });
+ },
+
+ /**
+ * Returns SVG representation of an instance
+ * @method toSVG
+ * @return {String} svg representation of an instance
+ */
+ toSVG: function() {
+ return ''+
+ ' element with actual transformation, then offsetting object to the top/left
+ // so that object's center aligns with container's left/top
+ 'transform="translate('+ (-this.width/2) + ' ' + (-this.height/2) + ')" ' +
+ 'width="' + this.width + '" ' +
+ 'height="' + this.height + '"' + '>' +
+ '';
+ },
+
+ /**
+ * Returns source of an image
+ * @method getSrc
+ * @return {String} Source of an image
+ */
+ getSrc: function() {
+ return this.getElement().src || this.getElement()._src;
+ },
+
+ /**
+ * Returns string representation of an instance
+ * @method toString
+ * @return {String} String representation of an instance
+ */
+ toString: function() {
+ return '#';
+ },
+
+ /**
+ * Returns a clone of an instance
+ * @method clone
+ * @param {Array} propertiesToInclude
+ * @param {Function} callback Callback is invoked with a clone as a first argument
+ */
+ clone: function(callback, propertiesToInclude) {
+ this.constructor.fromObject(this.toObject(propertiesToInclude), callback);
+ },
+
+ /**
+ * Applies filters assigned to this image (from "filters" array)
+ * @mthod applyFilters
+ * @param {Function} callback Callback is invoked when all filters have been applied and new image is generated
+ * @return {fabric.Image} thisArg
+ * @chainable
+ */
+ applyFilters: function(callback) {
+
+ if (this.filters.length === 0) {
+ this.setElement(this._originalImage);
+ callback && callback();
+ return;
+ }
+
+ var isLikelyNode = typeof Buffer !== 'undefined' && typeof window === 'undefined',
+ imgEl = this._originalImage,
+ canvasEl = fabric.document.createElement('canvas'),
+ replacement = isLikelyNode ? new (require('canvas').Image)() : fabric.document.createElement('img'),
+ _this = this;
+
+ if (!canvasEl.getContext && typeof G_vmlCanvasManager !== 'undefined') {
+ G_vmlCanvasManager.initElement(canvasEl);
+ }
+
+ canvasEl.width = imgEl.width;
+ canvasEl.height = imgEl.height;
+
+ canvasEl.getContext('2d').drawImage(imgEl, 0, 0, imgEl.width, imgEl.height);
+
+ this.filters.forEach(function(filter) {
+ filter && filter.applyTo(canvasEl);
+ });
+
+ /** @ignore */
+ replacement.onload = function() {
+ _this._element = replacement;
+ callback && callback();
+ replacement.onload = canvasEl = imgEl = null;
+ };
+ replacement.width = imgEl.width;
+ replacement.height = imgEl.height;
+
+ if (isLikelyNode) {
+ var base64str = canvasEl.toDataURL('image/png').replace(/data:image\/png;base64,/, '');
+ replacement.src = new Buffer(base64str, 'base64');
+ _this._element = replacement;
+
+ // onload doesn't fire in node, so we invoke callback manually
+ callback && callback();
+ }
+ else {
+ replacement.src = canvasEl.toDataURL('image/png');
+ }
+
+ return this;
+ },
+
+ /**
+ * @private
+ * @method _render
+ * @param ctx
+ */
+ _render: function(ctx) {
+ ctx.drawImage(
+ this.getElement(),
+ - this.width / 2,
+ -this.height / 2,
+ this.width,
+ this.height
+ );
+ },
+
+ /**
+ * @private
+ * @method _resetWidthHeight
+ */
+ _resetWidthHeight: function() {
+ var element = this.getElement();
+
+ this.set('width', element.width);
+ this.set('height', element.height);
+ },
+
+ /**
+ * The Image class's initialization method. This method is automatically
+ * called by the constructor.
+ * @private
+ * @method _initElement
+ * @param {HTMLImageElement|String} el The element representing the image
+ */
+ _initElement: function(element) {
+ this.setElement(fabric.util.getById(element));
+ fabric.util.addClass(this.getElement(), fabric.Image.CSS_CANVAS);
+ },
+
+ /**
+ * @private
+ * @method _initConfig
+ * @param {Object} [options] Options object
+ */
+ _initConfig: function(options) {
+ options || (options = { });
+ this.setOptions(options);
+ this._setWidthHeight(options);
+ },
+
+ /**
+ * @private
+ * @method _initFilters
+ * @param {Object} object Object with filters property
+ */
+ _initFilters: function(object) {
+ if (object.filters && object.filters.length) {
+ this.filters = object.filters.map(function(filterObj) {
+ return filterObj && fabric.Image.filters[filterObj.type].fromObject(filterObj);
+ });
+ }
+ },
+
+ /**
+ * @private
+ * @method _setWidthHeight
+ * @param {Object} [options] Object with width/height properties
+ */
+ _setWidthHeight: function(options) {
+ this.width = 'width' in options
+ ? options.width
+ : (this.getElement().width || 0);
+
+ this.height = 'height' in options
+ ? options.height
+ : (this.getElement().height || 0);
+ },
+
+ /**
+ * Returns complexity of an instance
+ * @method complexity
+ * @return {Number} complexity
+ */
+ complexity: function() {
+ return 1;
+ }
+ });
+
+ /**
+ * Default CSS class name for canvas
+ * @static
+ * @type String
+ */
+ fabric.Image.CSS_CANVAS = "canvas-img";
+
+ /**
+ * Alias for getSrc
+ * @static
+ * @method getSvgSrc
+ */
+ fabric.Image.prototype.getSvgSrc = fabric.Image.prototype.getSrc;
+
+ /**
+ * Creates an instance of fabric.Image from its object representation
+ * @static
+ * @method fromObject
+ * @param {Object} object
+ * @param {Function} [callback] Callback to invoke when an image instance is created
+ */
+ fabric.Image.fromObject = function(object, callback) {
+ var img = fabric.document.createElement('img'),
+ src = object.src;
+
+ if (object.width) {
+ img.width = object.width;
+ }
+ if (object.height) {
+ img.height = object.height;
+ }
+
+ /** @ignore */
+ img.onload = function() {
+ fabric.Image.prototype._initFilters.call(object, object);
+
+ var instance = new fabric.Image(img, object);
+ callback && callback(instance);
+ img = img.onload = null;
+ };
+ img.src = src;
+ };
+
+ /**
+ * Creates an instance of fabric.Image from an URL string
+ * @static
+ * @method fromURL
+ * @param {String} url URL to create an image from
+ * @param {Function} [callback] Callback to invoke when image is created (newly created image is passed as a first argument)
+ * @param {Object} [imgOptions] Options object
+ */
+ fabric.Image.fromURL = function(url, callback, imgOptions) {
+ var img = fabric.document.createElement('img');
+
+ /** @ignore */
+ img.onload = function() {
+ if (callback) {
+ callback(new fabric.Image(img, imgOptions));
+ }
+ img = img.onload = null;
+ };
+ img.src = url;
+ };
+
+ /**
+ * List of attribute names to account for when parsing SVG element (used by {@link fabric.Image.fromElement})
+ * @static
+ * @see http://www.w3.org/TR/SVG/struct.html#ImageElement
+ */
+ fabric.Image.ATTRIBUTE_NAMES = 'x y width height fill fill-opacity opacity stroke stroke-width transform xlink:href'.split(' ');
+
+ /**
+ * Returns {@link fabric.Image} instance from an SVG element
+ * @static
+ * @method fabric.Image.fromElement
+ * @param {SVGElement} element Element to parse
+ * @param {Function} callback Callback to execute when fabric.Image object is created
+ * @param {Object} [options] Options object
+ * @return {fabric.Image}
+ */
+ fabric.Image.fromElement = function(element, callback, options) {
+ options || (options = { });
+
+ var parsedAttributes = fabric.parseAttributes(element, fabric.Image.ATTRIBUTE_NAMES);
+
+ fabric.Image.fromURL(parsedAttributes['xlink:href'], callback, extend(parsedAttributes, options));
+ };
+
+ /**
+ * Indicates that instances of this type are async
+ * @static
+ * @type Boolean
+ */
+ fabric.Image.async = true;
+
+})(typeof exports !== 'undefined' ? exports : this);
+
+fabric.util.object.extend(fabric.Object.prototype, {
+
+ /**
+ * @private
+ * @method _getAngleValueForStraighten
+ * @return {Number} angle value
+ */
+ _getAngleValueForStraighten: function() {
+ var angle = this.getAngle() % 360;
+ if (angle > 0) {
+ return Math.round((angle-1)/90) * 90;
+ }
+ return Math.round(angle/90) * 90;
+ },
+
+ /**
+ * Straightens an object (rotating it from current angle to one of 0, 90, 180, 270, etc. depending on which is closer)
+ * @method straighten
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ straighten: function() {
+ this.setAngle(this._getAngleValueForStraighten());
+ return this;
+ },
+
+ /**
+ * Same as {@link fabric.Object.prototype.straghten} but with animation
+ * @method fxStraighten
+ * @param {Object} callbacks
+ * - onComplete: invoked on completion
+ * - onChange: invoked on every step of animation
+ *
+ * @return {fabric.Object} thisArg
+ * @chainable
+ */
+ fxStraighten: function(callbacks) {
+ callbacks = callbacks || { };
+
+ var empty = function() { },
+ onComplete = callbacks.onComplete || empty,
+ onChange = callbacks.onChange || empty,
+ _this = this;
+
+ fabric.util.animate({
+ startValue: this.get('angle'),
+ endValue: this._getAngleValueForStraighten(),
+ duration: this.FX_DURATION,
+ onChange: function(value) {
+ _this.setAngle(value);
+ onChange();
+ },
+ onComplete: function() {
+ _this.setCoords();
+ onComplete();
+ },
+ onStart: function() {
+ _this.setActive(false);
+ }
+ });
+
+ return this;
+ }
+});
+
+fabric.util.object.extend(fabric.StaticCanvas.prototype, {
+
+ /**
+ * Straightens object, then rerenders canvas
+ * @method straightenObject
+ * @param {fabric.Object} object Object to straighten
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ straightenObject: function (object) {
+ object.straighten();
+ this.renderAll();
+ return this;
+ },
+
+ /**
+ * Same as {@link fabric.Canvas.prototype.straightenObject}, but animated
+ * @method fxStraightenObject
+ * @param {fabric.Object} object Object to straighten
+ * @return {fabric.Canvas} thisArg
+ * @chainable
+ */
+ fxStraightenObject: function (object) {
+ object.fxStraighten({
+ onChange: this.renderAll.bind(this)
+ });
+ return this;
+ }
+});
+/**
+ * @namespace
+ */
+fabric.Image.filters = { };
+
+/**
+ * Grayscale image filter class
+ * @class fabric.Image.filters.Grayscale
+ * @memberOf fabric.Image.filters
+ */
+fabric.Image.filters.Grayscale = fabric.util.createClass( /** @scope fabric.Image.filters.Grayscale.prototype */ {
+
+ /**
+ * Filter type
+ * @param {String} type
+ */
+ type: "Grayscale",
+
+ /**
+ * Applies filter to canvas element
+ * @method applyTo
+ * @memberOf fabric.Image.filters.Grayscale.prototype
+ * @param {Object} canvasEl Canvas element to apply filter to
+ */
+ applyTo: function(canvasEl) {
+ var context = canvasEl.getContext('2d'),
+ imageData = context.getImageData(0, 0, canvasEl.width, canvasEl.height),
+ data = imageData.data,
+ iLen = imageData.width,
+ jLen = imageData.height,
+ index, average, i, j;
+
+ for (i = 0; i < iLen; i++) {
+ for (j = 0; j < jLen; j++) {
+
+ index = (i * 4) * jLen + (j * 4);
+ average = (data[index] + data[index + 1] + data[index + 2]) / 3;
+
+ data[index] = average;
+ data[index + 1] = average;
+ data[index + 2] = average;
+ }
+ }
+
+ context.putImageData(imageData, 0, 0);
+ },
+
+ /**
+ * Returns json representation of filter
+ * @method toJSON
+ * @return {String} json representation of filter
+ */
+ toJSON: function() {
+ return { type: this.type };
+ }
+});
+
+/**
+ * Returns filter instance from an object representation
+ * @static
+ * @method fabric.Image.filters.Grayscale.fromObject
+ * @return {fabric.Image.filters.Grayscale}
+ */
+fabric.Image.filters.Grayscale.fromObject = function() {
+ return new fabric.Image.filters.Grayscale();
+};
+
+/**
+ * Remove white filter class
+ * @class fabric.Image.filters.RemoveWhite
+ * @memberOf fabric.Image.filters
+ */
+fabric.Image.filters.RemoveWhite = fabric.util.createClass( /** @scope fabric.Image.filters.RemoveWhite.prototype */ {
+
+ /**
+ * Filter type
+ * @param {String} type
+ */
+ type: "RemoveWhite",
+
+ /**
+ * Constructor
+ * @memberOf fabric.Image.filters.RemoveWhite.prototype
+ * @param {Object} [options] Options object
+ */
+ initialize: function(options) {
+ options || (options = { });
+ this.threshold = options.threshold || 30;
+ this.distance = options.distance || 20;
+ },
+
+ /**
+ * Applies filter to canvas element
+ * @method applyTo
+ * @param {Object} canvasEl Canvas element to apply filter to
+ */
+ applyTo: function(canvasEl) {
+ var context = canvasEl.getContext('2d'),
+ imageData = context.getImageData(0, 0, canvasEl.width, canvasEl.height),
+ data = imageData.data,
+ threshold = this.threshold,
+ distance = this.distance,
+ limit = 255 - threshold,
+ abs = Math.abs,
+ r, g, b;
+
+ for (var i = 0, len = data.length; i < len; i += 4) {
+
+ r = data[i];
+ g = data[i+1];
+ b = data[i+2];
+
+ if (r > limit &&
+ g > limit &&
+ b > limit &&
+ abs(r-g) < distance &&
+ abs(r-b) < distance &&
+ abs(g-b) < distance) {
+
+ data[i+3] = 1;
+ }
+ }
+
+ context.putImageData(imageData, 0, 0);
+ },
+
+ /**
+ * Returns json representation of filter
+ * @method toJSON
+ * @return {String} json representation of filter
+ */
+ toJSON: function() {
+ return {
+ type: this.type,
+ threshold: this.threshold,
+ distance: this.distance
+ };
+ }
+});
+
+/**
+ * Returns filter instance from an object representation
+ * @static
+ * @method fabric.Image.filters.RemoveWhite.fromObject
+ * @return {fabric.Image.filters.RemoveWhite}
+ */
+fabric.Image.filters.RemoveWhite.fromObject = function(object) {
+ return new fabric.Image.filters.RemoveWhite(object);
+};
+
+/**
+ * Invert filter class
+ * @class fabric.Image.filters.Invert
+ * @memberOf fabric.Image.filters
+ */
+fabric.Image.filters.Invert = fabric.util.createClass( /** @scope fabric.Image.filters.Invert.prototype */ {
+
+ /**
+ * Filter type
+ * @param {String} type
+ */
+ type: "Invert",
+
+ /**
+ * Applies filter to canvas element
+ * @method applyTo
+ * @memberOf fabric.Image.filters.Invert.prototype
+ * @param {Object} canvasEl Canvas element to apply filter to
+ */
+ applyTo: function(canvasEl) {
+ var context = canvasEl.getContext('2d'),
+ imageData = context.getImageData(0, 0, canvasEl.width, canvasEl.height),
+ data = imageData.data,
+ iLen = data.length, i;
+
+ for (i = 0; i < iLen; i+=4) {
+ data[i] = 255 - data[i];
+ data[i + 1] = 255 - data[i + 1];
+ data[i + 2] = 255 - data[i + 2];
+ }
+
+ context.putImageData(imageData, 0, 0);
+ },
+
+ /**
+ * Returns json representation of filter
+ * @method toJSON
+ * @return {String} json representation of filter
+ */
+ toJSON: function() {
+ return { type: this.type };
+ }
+});
+
+/**
+ * Returns filter instance from an object representation
+ * @static
+ * @method fabric.Image.filters.Invert.fromObject
+ * @return {fabric.Image.filters.Invert}
+ */
+fabric.Image.filters.Invert.fromObject = function() {
+ return new fabric.Image.filters.Invert();
+};
+
+/**
+ * Sepia filter class
+ * @class fabric.Image.filters.Sepia
+ * @memberOf fabric.Image.filters
+ */
+fabric.Image.filters.Sepia = fabric.util.createClass( /** @scope fabric.Image.filters.Sepia.prototype */ {
+
+ /**
+ * Filter type
+ * @param {String} type
+ */
+ type: "Sepia",
+
+ /**
+ * Applies filter to canvas element
+ * @method applyTo
+ * @memberOf fabric.Image.filters.Sepia.prototype
+ * @param {Object} canvasEl Canvas element to apply filter to
+ */
+ applyTo: function(canvasEl) {
+ var context = canvasEl.getContext('2d'),
+ imageData = context.getImageData(0, 0, canvasEl.width, canvasEl.height),
+ data = imageData.data,
+ iLen = data.length, i, avg;
+
+ for (i = 0; i < iLen; i+=4) {
+ avg = 0.3 * data[i] + 0.59 * data[i + 1] + 0.11 * data[i + 2];
+ data[i] = avg + 100;
+ data[i + 1] = avg + 50;
+ data[i + 2] = avg + 255;
+ }
+
+ context.putImageData(imageData, 0, 0);
+ },
+
+ /**
+ * Returns json representation of filter
+ * @method toJSON
+ * @return {String} json representation of filter
+ */
+ toJSON: function() {
+ return { type: this.type };
+ }
+});
+
+/**
+ * Returns filter instance from an object representation
+ * @static
+ * @method fabric.Image.filters.Sepia.fromObject
+ * @return {fabric.Image.filters.Sepia}
+ */
+fabric.Image.filters.Sepia.fromObject = function() {
+ return new fabric.Image.filters.Sepia();
+};
+
+/**
+ * Sepia2 filter class
+ * @class fabric.Image.filters.Sepia2
+ * @memberOf fabric.Image.filters
+ */
+fabric.Image.filters.Sepia2 = fabric.util.createClass( /** @scope fabric.Image.filters.Sepia2.prototype */ {
+
+ /**
+ * Filter type
+ * @param {String} type
+ */
+ type: "Sepia2",
+
+ /**
+ * Applies filter to canvas element
+ * @method applyTo
+ * @memberOf fabric.Image.filters.Sepia.prototype
+ * @param {Object} canvasEl Canvas element to apply filter to
+ */
+ applyTo: function(canvasEl) {
+ var context = canvasEl.getContext('2d'),
+ imageData = context.getImageData(0, 0, canvasEl.width, canvasEl.height),
+ data = imageData.data,
+ iLen = data.length, i, r, g, b;
+
+ for (i = 0; i < iLen; i+=4) {
+
+ r = data[i];
+ g = data[i + 1];
+ b = data[i + 2];
+
+ data[i] = (r * 0.393 + g * 0.769 + b * 0.189 ) / 1.351;
+ data[i + 1] = (r * 0.349 + g * 0.686 + b * 0.168 ) / 1.203;
+ data[i + 2] = (r * 0.272 + g * 0.534 + b * 0.131 ) / 2.140;
+ }
+
+ context.putImageData(imageData, 0, 0);
+ },
+
+ /**
+ * Returns json representation of filter
+ * @method toJSON
+ * @return {String} json representation of filter
+ */
+ toJSON: function() {
+ return { type: this.type };
+ }
+});
+
+/**
+ * Returns filter instance from an object representation
+ * @static
+ * @method fabric.Image.filters.Sepia2.fromObject
+ * @return {fabric.Image.filters.Sepia2}
+ */
+fabric.Image.filters.Sepia2.fromObject = function() {
+ return new fabric.Image.filters.Sepia2();
+};
+
+/**
+ * Brightness filter class
+ * @class fabric.Image.filters.Brightness
+ * @memberOf fabric.Image.filters
+ */
+fabric.Image.filters.Brightness = fabric.util.createClass( /** @scope fabric.Image.filters.Brightness.prototype */ {
+
+ /**
+ * Filter type
+ * @param {String} type
+ */
+ type: "Brightness",
+
+ /**
+ * Constructor
+ * @memberOf fabric.Image.filters.Brightness.prototype
+ * @param {Object} [options] Options object
+ */
+ initialize: function(options) {
+ options || (options = { });
+ this.brightness = options.brightness || 100;
+ },
+
+ /**
+ * Applies filter to canvas element
+ * @method applyTo
+ * @param {Object} canvasEl Canvas element to apply filter to
+ */
+ applyTo: function(canvasEl) {
+ var context = canvasEl.getContext('2d'),
+ imageData = context.getImageData(0, 0, canvasEl.width, canvasEl.height),
+ data = imageData.data,
+ brightness = this.brightness;
+
+ for (var i = 0, len = data.length; i < len; i += 4) {
+ data[i] += brightness;
+ data[i + 1] += brightness;
+ data[i + 2] += brightness;
+ }
+
+ context.putImageData(imageData, 0, 0);
+ },
+
+ /**
+ * Returns json representation of filter
+ * @method toJSON
+ * @return {String} json representation of filter
+ */
+ toJSON: function() {
+ return {
+ type: this.type,
+ brightness: this.brightness
+ };
+ }
+});
+
+/**
+ * Returns filter instance from an object representation
+ * @static
+ * @method fabric.Image.filters.Brightness.fromObject
+ * @return {fabric.Image.filters.Brightness}
+ */
+fabric.Image.filters.Brightness.fromObject = function(object) {
+ return new fabric.Image.filters.Brightness(object);
+};
+
+/**
+ * Noise filter class
+ * @class fabric.Image.filters.Noise
+ * @memberOf fabric.Image.filters
+ */
+fabric.Image.filters.Noise = fabric.util.createClass( /** @scope fabric.Image.filters.Noise.prototype */ {
+
+ /**
+ * Filter type
+ * @param {String} type
+ */
+ type: "Noise",
+
+ /**
+ * Constructor
+ * @memberOf fabric.Image.filters.Noise.prototype
+ * @param {Object} [options] Options object
+ */
+ initialize: function(options) {
+ options || (options = { });
+ this.noise = options.noise || 100;
+ },
+
+ /**
+ * Applies filter to canvas element
+ * @method applyTo
+ * @param {Object} canvasEl Canvas element to apply filter to
+ */
+ applyTo: function(canvasEl) {
+ var context = canvasEl.getContext('2d'),
+ imageData = context.getImageData(0, 0, canvasEl.width, canvasEl.height),
+ data = imageData.data,
+ noise = this.noise, rand;
+
+ for (var i = 0, len = data.length; i < len; i += 4) {
+
+ rand = (0.5 - Math.random()) * noise;
+
+ data[i] += rand;
+ data[i + 1] += rand;
+ data[i + 2] += rand;
+ }
+
+ context.putImageData(imageData, 0, 0);
+ },
+
+ /**
+ * Returns json representation of filter
+ * @method toJSON
+ * @return {String} json representation of filter
+ */
+ toJSON: function() {
+ return {
+ type: this.type,
+ noise: this.noise
+ };
+ }
+});
+
+/**
+ * Returns filter instance from an object representation
+ * @static
+ * @method fabric.Image.filters.Noise.fromObject
+ * @return {fabric.Image.filters.Noise}
+ */
+fabric.Image.filters.Noise.fromObject = function(object) {
+ return new fabric.Image.filters.Noise(object);
+};
+
+/**
+ * GradientTransparency filter class
+ * @class fabric.Image.filters.GradientTransparency
+ * @memberOf fabric.Image.filters
+ */
+fabric.Image.filters.GradientTransparency = fabric.util.createClass( /** @scope fabric.Image.filters.GradientTransparency.prototype */ {
+
+ /**
+ * Filter type
+ * @param {String} type
+ */
+ type: "GradientTransparency",
+
+ /**
+ * Constructor
+ * @memberOf fabric.Image.filters.GradientTransparency
+ * @param {Object} [options] Options object
+ */
+ initialize: function(options) {
+ options || (options = { });
+ this.threshold = options.threshold || 100;
+ },
+
+ /**
+ * Applies filter to canvas element
+ * @method applyTo
+ * @param {Object} canvasEl Canvas element to apply filter to
+ */
+ applyTo: function(canvasEl) {
+ var context = canvasEl.getContext('2d'),
+ imageData = context.getImageData(0, 0, canvasEl.width, canvasEl.height),
+ data = imageData.data,
+ threshold = this.threshold,
+ total = data.length;
+
+ for (var i = 0, len = data.length; i < len; i += 4) {
+ data[i + 3] = threshold + 255 * (total - i) / total;
+ }
+
+ context.putImageData(imageData, 0, 0);
+ },
+
+ /**
+ * Returns json representation of filter
+ * @method toJSON
+ * @return {String} json representation of filter
+ */
+ toJSON: function() {
+ return {
+ type: this.type,
+ threshold: this.threshold
+ };
+ }
+});
+
+/**
+ * Returns filter instance from an object representation
+ * @static
+ * @method fabric.Image.filters.GradientTransparency.fromObject
+ * @return {fabric.Image.filters.GradientTransparency}
+ */
+fabric.Image.filters.GradientTransparency.fromObject = function(object) {
+ return new fabric.Image.filters.GradientTransparency(object);
+};
+
+/**
+ * Tint filter class
+ * @class fabric.Image.filters.Tint
+ * @memberOf fabric.Image.filters
+ */
+fabric.Image.filters.Tint = fabric.util.createClass( /** @scope fabric.Image.filters.Tint.prototype */ {
+
+ /**
+ * Filter type
+ * @param {String} type
+ */
+ type: "Tint",
+
+ /**
+ * Constructor
+ * @memberOf fabric.Image.filters.Tint.prototype
+ * @param {Object} [options] Options object
+ */
+ initialize: function(options) {
+ options || (options = { });
+ this.color = options.color || 0;
+ },
+
+ /**
+ * Applies filter to canvas element
+ * @method applyTo
+ * @param {Object} canvasEl Canvas element to apply filter to
+ */
+ applyTo: function(canvasEl) {
+
+ var context = canvasEl.getContext('2d'),
+ imageData = context.getImageData(0, 0, canvasEl.width, canvasEl.height),
+ data = imageData.data,
+ iLen = data.length, i, a;
+
+ var rgb = parseInt(this.color, 10).toString(16);
+
+ var cr = parseInt('0x' + rgb.substr(0, 2), 16);
+ var cg = parseInt('0x' + rgb.substr(2, 2), 16);
+ var cb = parseInt('0x' + rgb.substr(4, 2), 16);
+
+ for (i = 0; i < iLen; i+=4) {
+
+ a = data[i+3];
+
+ if (a > 0){
+ data[i] = cr;
+ data[i+1] = cg;
+ data[i+2] = cb;
+ }
+ }
+
+ context.putImageData(imageData, 0, 0);
+ },
+
+ /**
+ * Returns json representation of filter
+ * @method toJSON
+ * @return {String} json representation of filter
+ */
+ toJSON: function() {
+ return {
+ type: this.type,
+ color: this.color
+ };
+ }
+});
+
+/**
+ * Returns filter instance from an object representation
+ * @static
+ * @method fabric.Image.filters.Tint.fromObject
+ * @return {fabric.Image.filters.Tint}
+ */
+fabric.Image.filters.Tint.fromObject = function(object) {
+ return new fabric.Image.filters.Tint(object);
+};
+
+/**
+ * Adapted from html5rocks article
+ * @class fabric.Image.filters.Convolute
+ * @memberOf fabric.Image.filters
+ */
+fabric.Image.filters.Convolute = fabric.util.createClass(/** @scope fabric.Image.filters.Convolute.prototype */ {
+
+ /**
+ * Filter type
+ * @param {String} type
+ */
+ type: 'Convolute',
+
+ /**
+ * Constructor
+ * @memberOf fabric.Image.filters.Convolute.prototype
+ * @param {Object} [options] Options object
+ */
+ initialize: function(options) {
+ options || (options = { });
+
+ this.opaque = options.opaque;
+ this.matrix = options.matrix || [ 0, 0, 0,
+ 0, 1, 0,
+ 0, 0, 0 ];
+
+ this.tmpCtx = fabric.document.createElement('canvas').getContext('2d');
+ },
+
+ /**
+ * @private
+ * @method _createImageData
+ */
+ _createImageData: function(w, h) {
+ return this.tmpCtx.createImageData(w, h);
+ },
+
+ /**
+ * Applies filter to canvas element
+ * @method applyTo
+ * @param {Object} canvasEl Canvas element to apply filter to
+ */
+ applyTo: function(canvasEl) {
+
+ var weights = this.matrix;
+ var context = canvasEl.getContext('2d');
+ var pixels = context.getImageData(0, 0, canvasEl.width, canvasEl.height);
+
+ var side = Math.round(Math.sqrt(weights.length));
+ var halfSide = Math.floor(side/2);
+ var src = pixels.data;
+ var sw = pixels.width;
+ var sh = pixels.height;
+
+ // pad output by the convolution matrix
+ var w = sw;
+ var h = sh;
+ var output = this._createImageData(w, h);
+
+ var dst = output.data;
+
+ // go through the destination image pixels
+ var alphaFac = this.opaque ? 1 : 0;
+ for (var y=0; y= 0 && scy < sh && scx >= 0 && scx < sw) {
+ var srcOff = (scy*sw+scx)*4;
+ var wt = weights[cy*side+cx];
+ r += src[srcOff] * wt;
+ g += src[srcOff+1] * wt;
+ b += src[srcOff+2] * wt;
+ a += src[srcOff+3] * wt;
+ }
+ }
+ }
+ dst[dstOff] = r;
+ dst[dstOff+1] = g;
+ dst[dstOff+2] = b;
+ dst[dstOff+3] = a + alphaFac*(255-a);
+ }
+ }
+
+ context.putImageData(output, 0, 0);
+ },
+
+ /**
+ * Returns json representation of filter
+ * @method toJSON
+ * @return {String} json representation of filter
+ */
+ toJSON: function() {
+ return {
+ type: this.type,
+ matrix: this.matrix
+ };
+ }
+});
+
+/**
+ * Returns filter instance from an object representation
+ * @static
+ * @method fabric.Image.filters.Convolute.fromObject
+ * @return {fabric.Image.filters.Convolute}
+ */
+fabric.Image.filters.Convolute.fromObject = function(object) {
+ return new fabric.Image.filters.Convolute(object);
+};
+
+/**
+ * Pixelate filter class
+ * @class fabric.Image.filters.Pixelate
+ * @memberOf fabric.Image.filters
+ */
+fabric.Image.filters.Pixelate = fabric.util.createClass(/** @scope fabric.Image.filters.Pixelate.prototype */ {
+
+ /**
+ * Filter type
+ * @param {String} type
+ */
+ type: 'Pixelate',
+
+ /**
+ * Constructor
+ * @memberOf fabric.Image.filters.Pixelate.prototype
+ * @param {Object} [options] Options object
+ */
+ initialize: function(options) {
+ options || (options = { });
+ this.blocksize = options.blocksize || 4;
+ },
+
+ /**
+ * Applies filter to canvas element
+ * @method applyTo
+ * @param {Object} canvasEl Canvas element to apply filter to
+ */
+ applyTo: function(canvasEl) {
+
+ var context = canvasEl.getContext('2d'),
+ imageData = context.getImageData(0, 0, canvasEl.width, canvasEl.height),
+ data = imageData.data,
+ iLen = imageData.width,
+ jLen = imageData.height,
+ index, i, j, r, g, b, a;
+
+ for (i = 0; i < iLen; i += this.blocksize) {
+ for (j = 0; j < jLen; j += this.blocksize) {
+
+ index = (i * 4) * jLen + (j * 4);
+
+ r = data[index];
+ g = data[index+1];
+ b = data[index+2];
+ a = data[index+3];
+
+ /*
+ blocksize: 4
+
+ [1,x,x,x,1]
+ [x,x,x,x,1]
+ [x,x,x,x,1]
+ [x,x,x,x,1]
+ [1,1,1,1,1]
+ */
+
+ for (var _i = i, _ilen = i + this.blocksize; _i < _ilen; _i++) {
+ for (var _j = j, _jlen = j + this.blocksize; _j < _jlen; _j++) {
+ index = (_i * 4) * jLen + (_j * 4);
+ data[index] = r;
+ data[index + 1] = g;
+ data[index + 2] = b;
+ data[index + 3] = a;
+ }
+ }
+ }
+ }
+
+ context.putImageData(imageData, 0, 0);
+ },
+
+ /**
+ * Returns json representation of filter
+ * @method toJSON
+ * @return {String} json representation of filter
+ */
+ toJSON: function() {
+ return {
+ type: this.type,
+ blocksize: this.blocksize
+ };
+ }
+});
+
+/**
+ * Returns filter instance from an object representation
+ * @static
+ * @method fabric.Image.filters.Pixelate.fromObject
+ * @return {fabric.Image.filters.Pixelate}
+ */
+fabric.Image.filters.Pixelate.fromObject = function(object) {
+ return new fabric.Image.filters.Pixelate(object);
+};
+(function(global) {
+
+ "use strict";
+
+ var fabric = global.fabric || (global.fabric = { }),
+ extend = fabric.util.object.extend,
+ clone = fabric.util.object.clone,
+ toFixed = fabric.util.toFixed;
+
+ if (fabric.Text) {
+ fabric.warn('fabric.Text is already defined');
+ return;
+ }
+
+ /**
+ * Text class
+ * @class Text
+ * @extends fabric.Object
+ */
+ fabric.Text = fabric.util.createClass(fabric.Object, /** @scope fabric.Text.prototype */ {
+
+ /**
+ * Font size
+ * @property
+ * @type Number
+ */
+ fontSize: 40,
+
+ /**
+ * Font weight (e.g. bold, normal, 400, 600, 800)
+ * @property
+ * @type Number
+ */
+ fontWeight: 400,
+
+ /**
+ * Font family
+ * @property
+ * @type String
+ */
+ fontFamily: 'Times New Roman',
+
+ /**
+ * Text decoration (e.g. underline, overline)
+ * @property
+ * @type String
+ */
+ textDecoration: '',
+
+ /**
+ * Text shadow
+ * @property
+ * @type String | null
+ */
+ textShadow: '',
+
+ /**
+ * Text alignment. Possible values: "left", "center", or "right".
+ * @property
+ * @type String
+ */
+ textAlign: 'left',
+
+ /**
+ * Font style (e.g. italic)
+ * @property
+ * @type String
+ */
+ fontStyle: '',
+
+ /**
+ * Line height
+ * @property
+ * @type Number
+ */
+ lineHeight: 1.3,
+
+ /**
+ * Stroke style. When specified, text is rendered with stroke
+ * @property
+ * @type String
+ */
+ strokeStyle: '',
+
+ /**
+ * Stroke width
+ * @property
+ * @type Number
+ */
+ strokeWidth: 1,
+
+ /**
+ * Background color of an entire text box
+ * @property
+ * @type String
+ */
+ backgroundColor: '',
+
+ /**
+ * Background color of text lines
+ * @property
+ * @type String
+ */
+ textBackgroundColor: '',
+
+ /**
+ * URL of a font file, when using Cufon
+ * @property
+ * @type String | null
+ */
+ path: null,
+
+ /**
+ * Type of an object
+ * @property
+ * @type String
+ */
+ type: 'text',
+
+ /**
+ * Indicates whether canvas native text methods should be used to render text (otherwise, Cufon is used)
+ * @property
+ * @type Boolean
+ */
+ useNative: true,
+
+ /**
+ * Constructor
+ * @method initialize
+ * @param {String} text
+ * @param {Object} [options]
+ * @return {fabric.Text} thisArg
+ */
+ initialize: function(text, options) {
+ options = options || { };
+
+ this._initStateProperties();
+ this.text = text;
+ this.setOptions(options);
+ this._initDimensions();
+ this.setCoords();
+ },
+
+ /**
+ * Renders text object on offscreen canvas, so that it would get dimensions
+ * @private
+ * @method _initDimensions
+ */
+ _initDimensions: function() {
+ var canvasEl = fabric.document.createElement('canvas');
+
+ if (!canvasEl.getContext && typeof G_vmlCanvasManager !== 'undefined') {
+ G_vmlCanvasManager.initElement(canvasEl);
+ }
+
+ this._render(canvasEl.getContext('2d'));
+ },
+
+ /**
+ * Creates `stateProperties` list on an instance, and adds `fabric.Text` -specific ones to it
+ * (such as "fontFamily", "fontWeight", etc.)
+ * @private
+ * @method _initStateProperties
+ */
+ _initStateProperties: function() {
+ this.stateProperties = this.stateProperties.concat();
+ this.stateProperties.push(
+ 'fontFamily',
+ 'fontWeight',
+ 'fontSize',
+ 'path',
+ 'text',
+ 'textDecoration',
+ 'textShadow',
+ 'textAlign',
+ 'fontStyle',
+ 'lineHeight',
+ 'strokeStyle',
+ 'strokeWidth',
+ 'backgroundColor',
+ 'textBackgroundColor',
+ 'useNative'
+ );
+ fabric.util.removeFromArray(this.stateProperties, 'width');
+ },
+
+ /**
+ * Returns string representation of an instance
+ * @method toString
+ * @return {String} String representation of text object
+ */
+ toString: function() {
+ return '#';
+ },
+
+ /**
+ * @private
+ * @method _render
+ * @param {CanvasRenderingContext2D} ctx Context to render on
+ */
+ _render: function(ctx) {
+ if (typeof Cufon === 'undefined' || this.useNative === true) {
+ this._renderViaNative(ctx);
+ }
+ else {
+ this._renderViaCufon(ctx);
+ }
+ },
+
+ /**
+ * @private
+ * @method _renderViaCufon
+ */
+ _renderViaCufon: function(ctx) {
+ var o = Cufon.textOptions || (Cufon.textOptions = { });
+
+ // export options to be used by cufon.js
+ o.left = this.left;
+ o.top = this.top;
+ o.context = ctx;
+ o.color = this.fill;
+
+ var el = this._initDummyElementForCufon();
+
+ // set "cursor" to top/left corner
+ this.transform(ctx);
+
+ // draw text
+ Cufon.replaceElement(el, {
+ engine: 'canvas',
+ separate: 'none',
+ fontFamily: this.fontFamily,
+ fontWeight: this.fontWeight,
+ textDecoration: this.textDecoration,
+ textShadow: this.textShadow,
+ textAlign: this.textAlign,
+ fontStyle: this.fontStyle,
+ lineHeight: this.lineHeight,
+ strokeStyle: this.strokeStyle,
+ strokeWidth: this.strokeWidth,
+ backgroundColor: this.backgroundColor,
+ textBackgroundColor: this.textBackgroundColor
+ });
+
+ // update width, height
+ this.width = o.width;
+ this.height = o.height;
+
+ this._totalLineHeight = o.totalLineHeight;
+ this._fontAscent = o.fontAscent;
+ this._boundaries = o.boundaries;
+ this._shadowOffsets = o.shadowOffsets;
+ this._shadows = o.shadows || [ ];
+
+ el = null;
+
+ // need to set coords _after_ the width/height was retreived from Cufon
+ this.setCoords();
+ },
+
+ /**
+ * @private
+ * @method _render_native
+ * @param {CanvasRenderingContext2D} ctx Context to render on
+ */
+ _renderViaNative: function(ctx) {
+
+ this.transform(ctx);
+ this._setTextStyles(ctx);
+
+ var textLines = this.text.split(/\r?\n/);
+
+ this.width = this._getTextWidth(ctx, textLines);
+ this.height = this._getTextHeight(ctx, textLines);
+
+ this._renderTextBackground(ctx, textLines);
+
+ if (this.textAlign !== 'left' && this.textAlign !== 'justify') {
+ ctx.save();
+ ctx.translate(this.textAlign === 'center' ? (this.width / 2) : this.width, 0);
+ }
+
+ this._setTextShadow(ctx);
+ this._renderTextFill(ctx, textLines);
+ this.textShadow && ctx.restore();
+
+ this._renderTextStroke(ctx, textLines);
+ if (this.textAlign !== 'left' && this.textAlign !== 'justify') {
+ ctx.restore();
+ }
+
+ this._renderTextDecoration(ctx, textLines);
+ this._setBoundaries(ctx, textLines);
+ this._totalLineHeight = 0;
+
+ this.setCoords();
+ },
+
+ /**
+ * @private
+ * @method _setBoundaries
+ */
+ _setBoundaries: function(ctx, textLines) {
+ this._boundaries = [ ];
+
+ for (var i = 0, len = textLines.length; i < len; i++) {
+
+ var lineWidth = this._getLineWidth(ctx, textLines[i]);
+ var lineLeftOffset = this._getLineLeftOffset(lineWidth);
+
+ this._boundaries.push({
+ height: this.fontSize * this.lineHeight,
+ width: lineWidth,
+ left: lineLeftOffset
+ });
+ }
+ },
+
+ /**
+ * @private
+ * @method _setTextStyles
+ */
+ _setTextStyles: function(ctx) {
+ ctx.fillStyle = this.fill.toLiveGradient
+ ? this.fill.toLiveGradient(ctx)
+ : this.fill;
+ ctx.strokeStyle = this.strokeStyle;
+ ctx.lineWidth = this.strokeWidth;
+ ctx.textBaseline = 'alphabetic';
+ ctx.textAlign = this.textAlign;
+ ctx.font = this._getFontDeclaration();
+ },
+
+ /**
+ * @private
+ * @method _getTextHeight
+ */
+ _getTextHeight: function(ctx, textLines) {
+ return this.fontSize * textLines.length * this.lineHeight;
+ },
+
+ /**
+ * @private
+ * @method _getTextWidth
+ */
+ _getTextWidth: function(ctx, textLines) {
+ var maxWidth = ctx.measureText(textLines[0]).width;
+
+ for (var i = 1, len = textLines.length; i < len; i++) {
+ var currentLineWidth = ctx.measureText(textLines[i]).width;
+ if (currentLineWidth > maxWidth) {
+ maxWidth = currentLineWidth;
+ }
+ }
+ return maxWidth;
+ },
+
+ /**
+ * @private
+ * @method _setTextShadow
+ */
+ _setTextShadow: function(ctx) {
+ if (this.textShadow) {
+
+ // "rgba(0,0,0,0.2) 2px 2px 10px"
+ // "rgb(0, 100, 0) 0 0 5px"
+ // "red 2px 2px 1px"
+ // "#f55 123 345 567"
+ var reOffsetsAndBlur = /\s+(-?\d+)(?:px)?\s+(-?\d+)(?:px)?\s+(\d+)(?:px)?\s*/;
+
+ var shadowDeclaration = this.textShadow;
+ var offsetsAndBlur = reOffsetsAndBlur.exec(this.textShadow);
+ var shadowColor = shadowDeclaration.replace(reOffsetsAndBlur, '');
+
+ ctx.save();
+ ctx.shadowColor = shadowColor;
+ ctx.shadowOffsetX = parseInt(offsetsAndBlur[1], 10);
+ ctx.shadowOffsetY = parseInt(offsetsAndBlur[2], 10);
+ ctx.shadowBlur = parseInt(offsetsAndBlur[3], 10);
+
+ this._shadows = [{
+ blur: ctx.shadowBlur,
+ color: ctx.shadowColor,
+ offX: ctx.shadowOffsetX,
+ offY: ctx.shadowOffsetY
+ }];
+
+ this._shadowOffsets = [[
+ parseInt(ctx.shadowOffsetX, 10), parseInt(ctx.shadowOffsetY, 10)
+ ]];
+ }
+ },
+
+ /**
+ * @private
+ * @method _drawTextLine
+ * @param method
+ * @param ctx
+ * @param line
+ * @param left
+ * param top
+ */
+ _drawTextLine: function(method, ctx, line, left, top) {
+
+ // short-circuit
+ if (this.textAlign !== 'justify') {
+ ctx[method](line, left, top);
+ return;
+ }
+
+ var lineWidth = ctx.measureText(line).width;
+ var totalWidth = this.width;
+
+ if (totalWidth > lineWidth) {
+ // stretch the line
+
+ var words = line.split(/\s+/);
+ var wordsWidth = ctx.measureText(line.replace(/\s+/g, '')).width;
+ var widthDiff = totalWidth - wordsWidth;
+ var numSpaces = words.length - 1;
+ var spaceWidth = widthDiff / numSpaces;
+
+ var leftOffset = 0;
+ for (var i = 0, len = words.length; i < len; i++) {
+ ctx[method](words[i], left + leftOffset, top);
+ leftOffset += ctx.measureText(words[i]).width + spaceWidth;
+ }
+ }
+ else {
+ ctx[method](line, left, top);
+ }
+ },
+
+ /**
+ * @private
+ * @method _renderTextFill
+ */
+ _renderTextFill: function(ctx, textLines) {
+ this._boundaries = [ ];
+ for (var i = 0, len = textLines.length; i < len; i++) {
+ this._drawTextLine(
+ 'fillText',
+ ctx,
+ textLines[i],
+ -this.width / 2,
+ (-this.height / 2) + (i * this.fontSize * this.lineHeight) + this.fontSize
+ );
+ }
+ },
+
+ /**
+ * @private
+ * @method _renderTextStroke
+ */
+ _renderTextStroke: function(ctx, textLines) {
+ if (this.strokeStyle) {
+ ctx.beginPath();
+ for (var i = 0, len = textLines.length; i < len; i++) {
+ this._drawTextLine(
+ 'strokeText',
+ ctx,
+ textLines[i],
+ -this.width / 2,
+ (-this.height / 2) + (i * this.fontSize * this.lineHeight) + this.fontSize
+ );
+ }
+ ctx.closePath();
+ }
+ },
+
+ /**
+ * @private
+ * @method _renderTextBackground
+ */
+ _renderTextBackground: function(ctx, textLines) {
+ this._renderTextBoxBackground(ctx);
+ this._renderTextLinesBackground(ctx, textLines);
+ },
+
+ /**
+ * @private
+ * @method _renderTextBoxBackground
+ */
+ _renderTextBoxBackground: function(ctx) {
+ if (this.backgroundColor) {
+ ctx.save();
+ ctx.fillStyle = this.backgroundColor;
+
+ ctx.fillRect(
+ (-this.width / 2),
+ (-this.height / 2),
+ this.width,
+ this.height
+ );
+
+ ctx.restore();
+ }
+ },
+
+ /**
+ * @private
+ * @method _renderTextLinesBackground
+ */
+ _renderTextLinesBackground: function(ctx, textLines) {
+ if (this.textBackgroundColor) {
+ ctx.save();
+ ctx.fillStyle = this.textBackgroundColor;
+
+ for (var i = 0, len = textLines.length; i < len; i++) {
+
+ if (textLines[i] !== '') {
+
+ var lineWidth = this._getLineWidth(ctx, textLines[i]);
+ var lineLeftOffset = this._getLineLeftOffset(lineWidth);
+
+ ctx.fillRect(
+ (-this.width / 2) + lineLeftOffset,
+ (-this.height / 2) + (i * this.fontSize * this.lineHeight),
+ lineWidth,
+ this.fontSize * this.lineHeight
+ );
+ }
+ }
+ ctx.restore();
+ }
+ },
+
+ /**
+ * @private
+ * @method _getLineLeftOffset
+ */
+ _getLineLeftOffset: function(lineWidth) {
+ if (this.textAlign === 'center') {
+ return (this.width - lineWidth) / 2;
+ }
+ if (this.textAlign === 'right') {
+ return this.width - lineWidth;
+ }
+ return 0;
+ },
+
+ /**
+ * @private
+ * @method _getLineWidth
+ * @param ctx
+ * @param line
+ */
+ _getLineWidth: function(ctx, line) {
+ return this.textAlign === 'justify'
+ ? this.width
+ : ctx.measureText(line).width;
+ },
+
+ /**
+ * @private
+ * @method _renderTextDecoration
+ */
+ _renderTextDecoration: function(ctx, textLines) {
+
+ var halfOfVerticalBox = this._getTextHeight(ctx, textLines) / 2;
+ var _this = this;
+
+ /** @ignore */
+ function renderLinesAtOffset(offset) {
+ for (var i = 0, len = textLines.length; i < len; i++) {
+
+ var lineWidth = _this._getLineWidth(ctx, textLines[i]);
+ var lineLeftOffset = _this._getLineLeftOffset(lineWidth);
+
+ ctx.fillRect(
+ (-_this.width / 2) + lineLeftOffset,
+ (offset + (i * _this.fontSize * _this.lineHeight)) - halfOfVerticalBox,
+ lineWidth,
+ 1);
+ }
+ }
+
+ if (this.textDecoration.indexOf('underline') > -1) {
+ renderLinesAtOffset(this.fontSize);
+ }
+ if (this.textDecoration.indexOf('line-through') > -1) {
+ renderLinesAtOffset(this.fontSize / 2);
+ }
+ if (this.textDecoration.indexOf('overline') > -1) {
+ renderLinesAtOffset(0);
+ }
+ },
+
+ /**
+ * @private
+ * @method _getFontDeclaration
+ */
+ _getFontDeclaration: function() {
+ return [
+ this.fontStyle,
+ this.fontWeight,
+ this.fontSize + 'px',
+ (fabric.isLikelyNode ? ('"' + this.fontFamily + '"') : this.fontFamily)
+ ].join(' ');
+ },
+
+ /**
+ * @private
+ * @method _initDummyElement
+ */
+ _initDummyElementForCufon: function() {
+ var el = fabric.document.createElement('pre'),
+ container = fabric.document.createElement('div');
+
+ // Cufon doesn't play nice with textDecoration=underline if element doesn't have a parent
+ container.appendChild(el);
+
+ if (typeof G_vmlCanvasManager === 'undefined') {
+ el.innerHTML = this.text;
+ }
+ else {
+ // IE 7 & 8 drop newlines and white space on text nodes
+ // see: http://web.student.tuwien.ac.at/~e0226430/innerHtmlQuirk.html
+ // see: http://www.w3schools.com/dom/dom_mozilla_vs_ie.asp
+ el.innerText = this.text.replace(/\r?\n/gi, '\r');
+ }
+
+ el.style.fontSize = this.fontSize + 'px';
+ el.style.letterSpacing = 'normal';
+
+ return el;
+ },
+
+ /**
+ * Renders text instance on a specified context
+ * @method render
+ * @param ctx {CanvasRenderingContext2D} context to render on
+ */
+ render: function(ctx, noTransform) {
+ ctx.save();
+ this._render(ctx);
+ if (!noTransform && this.active) {
+ this.drawBorders(ctx);
+ this.hideCorners || this.drawCorners(ctx);
+ }
+ ctx.restore();
+ },
+
+ /**
+ * Returns object representation of an instance
+ * @method toObject
+ * @param {Array} propertiesToInclude
+ * @return {Object} object representation of an instance
+ */
+ toObject: function(propertiesToInclude) {
+ return extend(this.callSuper('toObject', propertiesToInclude), {
+ text: this.text,
+ fontSize: this.fontSize,
+ fontWeight: this.fontWeight,
+ fontFamily: this.fontFamily,
+ fontStyle: this.fontStyle,
+ lineHeight: this.lineHeight,
+ textDecoration: this.textDecoration,
+ textShadow: this.textShadow,
+ textAlign: this.textAlign,
+ path: this.path,
+ strokeStyle: this.strokeStyle,
+ strokeWidth: this.strokeWidth,
+ backgroundColor: this.backgroundColor,
+ textBackgroundColor: this.textBackgroundColor,
+ useNative: this.useNative
+ });
+ },
+
+ /**
+ * Returns SVG representation of an instance
+ * @method toSVG
+ * @return {String} svg representation of an instance
+ */
+ toSVG: function() {
+
+ var textLines = this.text.split(/\r?\n/),
+ lineTopOffset = this.useNative
+ ? this.fontSize * this.lineHeight
+ : (-this._fontAscent - ((this._fontAscent / 5) * this.lineHeight)),
+
+ textLeftOffset = -(this.width/2),
+ textTopOffset = this.useNative
+ ? this.fontSize - 1
+ : (this.height/2) - (textLines.length * this.fontSize) - this._totalLineHeight,
+
+ textAndBg = this._getSVGTextAndBg(lineTopOffset, textLeftOffset, textLines),
+ shadowSpans = this._getSVGShadows(lineTopOffset, textLines);
+
+ // move top offset by an ascent
+ textTopOffset += (this._fontAscent ? ((this._fontAscent / 5) * this.lineHeight) : 0);
+
+ return [
+ '',
+ textAndBg.textBgRects.join(''),
+ '',
+ shadowSpans.join(''),
+ textAndBg.textSpans.join(''),
+ '',
+ ''
+ ].join('');
+ },
+
+ /**
+ * @private
+ * @method _getSVGShadows
+ */
+ _getSVGShadows: function(lineTopOffset, textLines) {
+ var shadowSpans = [], j, i, jlen, ilen, lineTopOffsetMultiplier = 1;
+
+ if (!this._shadows || !this._boundaries) {
+ return shadowSpans;
+ }
+
+ for (j = 0, jlen = this._shadows.length; j < jlen; j++) {
+ for (i = 0, ilen = textLines.length; i < ilen; i++) {
+ if (textLines[i] !== '') {
+ var lineLeftOffset = (this._boundaries && this._boundaries[i]) ? this._boundaries[i].left : 0;
+ shadowSpans.push(
+ '',
+ fabric.util.string.escapeXml(textLines[i]),
+ '');
+ lineTopOffsetMultiplier = 1;
+ } else {
+ // in some environments (e.g. IE 7 & 8) empty tspans are completely ignored, using a lineTopOffsetMultiplier
+ // prevents empty tspans
+ lineTopOffsetMultiplier++;
+ }
+ }
+ }
+ return shadowSpans;
+ },
+
+ /**
+ * @private
+ * @method _getSVGTextAndBg
+ */
+ _getSVGTextAndBg: function(lineTopOffset, textLeftOffset, textLines) {
+ var textSpans = [ ], textBgRects = [ ], i, lineLeftOffset, len, lineTopOffsetMultiplier = 1;
+
+ // bounding-box background
+ if (this.backgroundColor && this._boundaries) {
+ textBgRects.push(
+ '');
+ }
+
+ // text and text-background
+ for (i = 0, len = textLines.length; i < len; i++) {
+ if (textLines[i] !== '') {
+ lineLeftOffset = (this._boundaries && this._boundaries[i]) ? toFixed(this._boundaries[i].left, 2) : 0;
+ textSpans.push(
+ ' elements since setting opacity on containing one doesn't work in Illustrator
+ this._getFillAttributes(this.fill), '>',
+ fabric.util.string.escapeXml(textLines[i]),
+ ''
+ );
+ lineTopOffsetMultiplier = 1;
+ }
+ else {
+ // in some environments (e.g. IE 7 & 8) empty tspans are completely ignored, using a lineTopOffsetMultiplier
+ // prevents empty tspans
+ lineTopOffsetMultiplier++;
+ }
+
+ if (!this.textBackgroundColor || !this._boundaries) continue;
+
+ textBgRects.push(
+ '');
+ }
+ return {
+ textSpans: textSpans,
+ textBgRects: textBgRects
+ };
+ },
+
+ /**
+ * Adobe Illustrator (at least CS5) is unable to render rgba()-based fill values
+ * we work around it by "moving" alpha channel into opacity attribute and setting fill's alpha to 1
+ *
+ * @private
+ * @method _getFillAttributes
+ */
+ _getFillAttributes: function(value) {
+ var fillColor = value ? new fabric.Color(value) : '';
+ if (!fillColor || !fillColor.getSource() || fillColor.getAlpha() === 1) {
+ return 'fill="' + value + '"';
+ }
+ return 'opacity="' + fillColor.getAlpha() + '" fill="' + fillColor.setAlpha(1).toRgb() + '"';
+ },
+
+ /**
+ * Sets "color" of an instance (alias of `set('fill', …)`)
+ * @method setColor
+ * @param {String} value
+ * @return {fabric.Text} thisArg
+ * @chainable
+ */
+ setColor: function(value) {
+ this.set('fill', value);
+ return this;
+ },
+
+ /**
+ * Sets fontSize of an instance and updates its coordinates
+ * @method setFontsize
+ * @param {Number} value
+ * @return {fabric.Text} thisArg
+ * @chainable
+ */
+ setFontsize: function(value) {
+ this.set('fontSize', value);
+ this._initDimensions();
+ this.setCoords();
+ return this;
+ },
+
+ /**
+ * Returns actual text value of an instance
+ * @method getText
+ * @return {String}
+ */
+ getText: function() {
+ return this.text;
+ },
+
+ /**
+ * Sets text of an instance, and updates its coordinates
+ * @method setText
+ * @param {String} value
+ * @return {fabric.Text} thisArg
+ * @chainable
+ */
+ setText: function(value) {
+ this.set('text', value);
+ this._initDimensions();
+ this.setCoords();
+ return this;
+ },
+
+ /**
+ * Sets specified property to a specified value
+ * @method set
+ * @param {String} name
+ * @param {Any} value
+ * @return {fabric.Text} thisArg
+ * @chainable
+ */
+ _set: function(name, value) {
+ if (name === 'fontFamily' && this.path) {
+ this.path = this.path.replace(/(.*?)([^\/]*)(\.font\.js)/, '$1' + value + '$3');
+ }
+ this.callSuper('_set', name, value);
+ }
+ });
+
+ /**
+ * List of attribute names to account for when parsing SVG element (used by {@link fabric.Text.fromElement})
+ * @static
+ */
+ fabric.Text.ATTRIBUTE_NAMES =
+ ('x y fill fill-opacity opacity stroke stroke-width transform ' +
+ 'font-family font-style font-weight font-size text-decoration').split(' ');
+
+ /**
+ * Returns fabric.Text instance from an object representation
+ * @static
+ * @method fromObject
+ * @param {Object} object to create an instance from
+ * @return {fabric.Text} an instance
+ */
+ fabric.Text.fromObject = function(object) {
+ return new fabric.Text(object.text, clone(object));
+ };
+
+ /**
+ * Returns fabric.Text instance from an SVG element (not yet implemented)
+ * @static
+ * @method fabric.Text.fromElement
+ * @param element
+ * @param options
+ * @return {fabric.Text} an instance
+ */
+ fabric.Text.fromElement = function(element, options) {
+
+ if (!element) {
+ return null;
+ }
+
+ var parsedAttributes = fabric.parseAttributes(element, fabric.Text.ATTRIBUTE_NAMES);
+ options = fabric.util.object.extend((options ? fabric.util.object.clone(options) : { }), parsedAttributes);
+
+ var text = new fabric.Text(element.textContent, options);
+
+ /*
+ Adjust positioning:
+ x/y attributes in SVG correspond to the bottom-left corner of text bounding box
+ top/left properties in Fabric correspond to center point of text bounding box
+ */
+
+ text.set({
+ left: text.getLeft() + text.getWidth() / 2,
+ top: text.getTop() - text.getHeight() / 2
+ });
+
+ return text;
+ };
+
+})(typeof exports !== 'undefined' ? exports : this);
+(function() {
+
+ if (typeof document !== 'undefined' && typeof window !== 'undefined') {
+ return;
+ }
+
+ var DOMParser = new require('xmldom').DOMParser,
+ URL = require('url'),
+ HTTP = require('http'),
+
+ Canvas = require('canvas'),
+ Image = require('canvas').Image;
+
+ /** @private */
+ function request(url, encoding, callback) {
+ var oURL = URL.parse(url),
+ client = HTTP.createClient(oURL.port, oURL.hostname),
+ req = client.request('GET', oURL.pathname, { 'host': oURL.hostname });
+
+ client.addListener('error', function(err) {
+ if (err.errno === process.ECONNREFUSED) {
+ fabric.log('ECONNREFUSED: connection refused to ' + client.host + ':' + client.port);
+ }
+ else {
+ fabric.log(err.message);
+ }
+ });
+
+ req.end();
+ req.on('response', function (response) {
+ var body = "";
+ if (encoding) {
+ response.setEncoding(encoding);
+ }
+ response.on('end', function () {
+ callback(body);
+ });
+ response.on('data', function (chunk) {
+ if (response.statusCode === 200) {
+ body += chunk;
+ }
+ });
+ });
+ }
+
+ fabric.util.loadImage = function(url, callback) {
+ var img = new Image();
+ if (url && url.indexOf('data') === 0) {
+ img.src = img._src = url;
+ callback(img);
+ }
+ else if (url) {
+ request(url, 'binary', function(body) {
+ img.src = new Buffer(body, 'binary');
+ // preserving original url, which seems to be lost in node-canvas
+ img._src = url;
+ callback(img);
+ });
+ }
+ };
+
+ fabric.loadSVGFromURL = function(url, callback) {
+ url = url.replace(/^\n\s*/, '').replace(/\?.*$/, '').trim();
+ request(url, '', function(body) {
+ fabric.loadSVGFromString(body, callback);
+ });
+ };
+
+ fabric.loadSVGFromString = function(string, callback) {
+ var doc = new DOMParser().parseFromString(string);
+ fabric.parseSVGDocument(doc.documentElement, function(results, options) {
+ callback(results, options);
+ });
+ };
+
+ fabric.util.getScript = function(url, callback) {
+ request(url, '', function(body) {
+ eval(body);
+ callback && callback();
+ });
+ };
+
+ fabric.Image.fromObject = function(object, callback) {
+ fabric.util.loadImage(object.src, function(img) {
+ var oImg = new fabric.Image(img);
+
+ oImg._initConfig(object);
+ oImg._initFilters(object);
+ callback(oImg);
+ });
+ };
+
+ /**
+ * Only available when running fabric on node.js
+ * @method createCanvasForNode
+ * @param width Canvas width
+ * @param height Canvas height
+ * @return {Object} wrapped canvas instance
+ */
+ fabric.createCanvasForNode = function(width, height) {
+
+ var canvasEl = fabric.document.createElement('canvas'),
+ nodeCanvas = new Canvas(width || 600, height || 600);
+
+ // jsdom doesn't create style on canvas element, so here be temp. workaround
+ canvasEl.style = { };
+
+ canvasEl.width = nodeCanvas.width;
+ canvasEl.height = nodeCanvas.height;
+
+ var FabricCanvas = fabric.Canvas || fabric.StaticCanvas;
+ var fabricCanvas = new FabricCanvas(canvasEl);
+ fabricCanvas.contextContainer = nodeCanvas.getContext('2d');
+ fabricCanvas.nodeCanvas = nodeCanvas;
+
+ return fabricCanvas;
+ };
+
+ /** @ignore */
+ fabric.StaticCanvas.prototype.createPNGStream = function() {
+ return this.nodeCanvas.createPNGStream();
+ };
+
+ var origSetWidth = fabric.StaticCanvas.prototype.setWidth;
+ fabric.StaticCanvas.prototype.setWidth = function(width) {
+ origSetWidth.call(this);
+ this.nodeCanvas.width = width;
+ return this;
+ };
+ if (fabric.Canvas) {
+ fabric.Canvas.prototype.setWidth = fabric.StaticCanvas.prototype.setWidth;
+ }
+
+ var origSetHeight = fabric.StaticCanvas.prototype.setHeight;
+ fabric.StaticCanvas.prototype.setHeight = function(height) {
+ origSetHeight.call(this);
+ this.nodeCanvas.height = height;
+ return this;
+ };
+ if (fabric.Canvas) {
+ fabric.Canvas.prototype.setHeight = fabric.StaticCanvas.prototype.setHeight;
+ }
+
+})();
diff --git a/Script/Library/jquery.js b/Script/Library/jquery.js
new file mode 100644
index 0000000..1f3aa68
--- /dev/null
+++ b/Script/Library/jquery.js
@@ -0,0 +1,9472 @@
+/*!
+ * jQuery JavaScript Library v1.8.3
+ * http://jquery.com/
+ *
+ * Includes Sizzle.js
+ * http://sizzlejs.com/
+ *
+ * Copyright 2012 jQuery Foundation and other contributors
+ * Released under the MIT license
+ * http://jquery.org/license
+ *
+ * Date: Tue Nov 13 2012 08:20:33 GMT-0500 (Eastern Standard Time)
+ */
+(function( window, undefined ) {
+var
+ // A central reference to the root jQuery(document)
+ rootjQuery,
+
+ // The deferred used on DOM ready
+ readyList,
+
+ // Use the correct document accordingly with window argument (sandbox)
+ document = window.document,
+ location = window.location,
+ navigator = window.navigator,
+
+ // Map over jQuery in case of overwrite
+ _jQuery = window.jQuery,
+
+ // Map over the $ in case of overwrite
+ _$ = window.$,
+
+ // Save a reference to some core methods
+ core_push = Array.prototype.push,
+ core_slice = Array.prototype.slice,
+ core_indexOf = Array.prototype.indexOf,
+ core_toString = Object.prototype.toString,
+ core_hasOwn = Object.prototype.hasOwnProperty,
+ core_trim = String.prototype.trim,
+
+ // Define a local copy of jQuery
+ jQuery = function( selector, context ) {
+ // The jQuery object is actually just the init constructor 'enhanced'
+ return new jQuery.fn.init( selector, context, rootjQuery );
+ },
+
+ // Used for matching numbers
+ core_pnum = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source,
+
+ // Used for detecting and trimming whitespace
+ core_rnotwhite = /\S/,
+ core_rspace = /\s+/,
+
+ // Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
+ rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
+
+ // A simple way to check for HTML strings
+ // Prioritize #id over to avoid XSS via location.hash (#9521)
+ rquickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
+
+ // Match a standalone tag
+ rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
+
+ // JSON RegExp
+ rvalidchars = /^[\],:{}\s]*$/,
+ rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
+ rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
+ rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d\d*\.|)\d+(?:[eE][\-+]?\d+|)/g,
+
+ // Matches dashed string for camelizing
+ rmsPrefix = /^-ms-/,
+ rdashAlpha = /-([\da-z])/gi,
+
+ // Used by jQuery.camelCase as callback to replace()
+ fcamelCase = function( all, letter ) {
+ return ( letter + "" ).toUpperCase();
+ },
+
+ // The ready event handler and self cleanup method
+ DOMContentLoaded = function() {
+ if ( document.addEventListener ) {
+ document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
+ jQuery.ready();
+ } else if ( document.readyState === "complete" ) {
+ // we're here because readyState === "complete" in oldIE
+ // which is good enough for us to call the dom ready!
+ document.detachEvent( "onreadystatechange", DOMContentLoaded );
+ jQuery.ready();
+ }
+ },
+
+ // [[Class]] -> type pairs
+ class2type = {};
+
+jQuery.fn = jQuery.prototype = {
+ constructor: jQuery,
+ init: function( selector, context, rootjQuery ) {
+ var match, elem, ret, doc;
+
+ // Handle $(""), $(null), $(undefined), $(false)
+ if ( !selector ) {
+ return this;
+ }
+
+ // Handle $(DOMElement)
+ if ( selector.nodeType ) {
+ this.context = this[0] = selector;
+ this.length = 1;
+ return this;
+ }
+
+ // Handle HTML strings
+ if ( typeof selector === "string" ) {
+ if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
+ // Assume that strings that start and end with <> are HTML and skip the regex check
+ match = [ null, selector, null ];
+
+ } else {
+ match = rquickExpr.exec( selector );
+ }
+
+ // Match html or make sure no context is specified for #id
+ if ( match && (match[1] || !context) ) {
+
+ // HANDLE: $(html) -> $(array)
+ if ( match[1] ) {
+ context = context instanceof jQuery ? context[0] : context;
+ doc = ( context && context.nodeType ? context.ownerDocument || context : document );
+
+ // scripts is true for back-compat
+ selector = jQuery.parseHTML( match[1], doc, true );
+ if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
+ this.attr.call( selector, context, true );
+ }
+
+ return jQuery.merge( this, selector );
+
+ // HANDLE: $(#id)
+ } else {
+ elem = document.getElementById( match[2] );
+
+ // Check parentNode to catch when Blackberry 4.6 returns
+ // nodes that are no longer in the document #6963
+ if ( elem && elem.parentNode ) {
+ // Handle the case where IE and Opera return items
+ // by name instead of ID
+ if ( elem.id !== match[2] ) {
+ return rootjQuery.find( selector );
+ }
+
+ // Otherwise, we inject the element directly into the jQuery object
+ this.length = 1;
+ this[0] = elem;
+ }
+
+ this.context = document;
+ this.selector = selector;
+ return this;
+ }
+
+ // HANDLE: $(expr, $(...))
+ } else if ( !context || context.jquery ) {
+ return ( context || rootjQuery ).find( selector );
+
+ // HANDLE: $(expr, context)
+ // (which is just equivalent to: $(context).find(expr)
+ } else {
+ return this.constructor( context ).find( selector );
+ }
+
+ // HANDLE: $(function)
+ // Shortcut for document ready
+ } else if ( jQuery.isFunction( selector ) ) {
+ return rootjQuery.ready( selector );
+ }
+
+ if ( selector.selector !== undefined ) {
+ this.selector = selector.selector;
+ this.context = selector.context;
+ }
+
+ return jQuery.makeArray( selector, this );
+ },
+
+ // Start with an empty selector
+ selector: "",
+
+ // The current version of jQuery being used
+ jquery: "1.8.3",
+
+ // The default length of a jQuery object is 0
+ length: 0,
+
+ // The number of elements contained in the matched element set
+ size: function() {
+ return this.length;
+ },
+
+ toArray: function() {
+ return core_slice.call( this );
+ },
+
+ // Get the Nth element in the matched element set OR
+ // Get the whole matched element set as a clean array
+ get: function( num ) {
+ return num == null ?
+
+ // Return a 'clean' array
+ this.toArray() :
+
+ // Return just the object
+ ( num < 0 ? this[ this.length + num ] : this[ num ] );
+ },
+
+ // Take an array of elements and push it onto the stack
+ // (returning the new matched element set)
+ pushStack: function( elems, name, selector ) {
+
+ // Build a new jQuery matched element set
+ var ret = jQuery.merge( this.constructor(), elems );
+
+ // Add the old object onto the stack (as a reference)
+ ret.prevObject = this;
+
+ ret.context = this.context;
+
+ if ( name === "find" ) {
+ ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
+ } else if ( name ) {
+ ret.selector = this.selector + "." + name + "(" + selector + ")";
+ }
+
+ // Return the newly-formed element set
+ return ret;
+ },
+
+ // Execute a callback for every element in the matched set.
+ // (You can seed the arguments with an array of args, but this is
+ // only used internally.)
+ each: function( callback, args ) {
+ return jQuery.each( this, callback, args );
+ },
+
+ ready: function( fn ) {
+ // Add the callback
+ jQuery.ready.promise().done( fn );
+
+ return this;
+ },
+
+ eq: function( i ) {
+ i = +i;
+ return i === -1 ?
+ this.slice( i ) :
+ this.slice( i, i + 1 );
+ },
+
+ first: function() {
+ return this.eq( 0 );
+ },
+
+ last: function() {
+ return this.eq( -1 );
+ },
+
+ slice: function() {
+ return this.pushStack( core_slice.apply( this, arguments ),
+ "slice", core_slice.call(arguments).join(",") );
+ },
+
+ map: function( callback ) {
+ return this.pushStack( jQuery.map(this, function( elem, i ) {
+ return callback.call( elem, i, elem );
+ }));
+ },
+
+ end: function() {
+ return this.prevObject || this.constructor(null);
+ },
+
+ // For internal use only.
+ // Behaves like an Array's method, not like a jQuery method.
+ push: core_push,
+ sort: [].sort,
+ splice: [].splice
+};
+
+// Give the init function the jQuery prototype for later instantiation
+jQuery.fn.init.prototype = jQuery.fn;
+
+jQuery.extend = jQuery.fn.extend = function() {
+ var options, name, src, copy, copyIsArray, clone,
+ target = arguments[0] || {},
+ i = 1,
+ length = arguments.length,
+ deep = false;
+
+ // Handle a deep copy situation
+ if ( typeof target === "boolean" ) {
+ deep = target;
+ target = arguments[1] || {};
+ // skip the boolean and the target
+ i = 2;
+ }
+
+ // Handle case when target is a string or something (possible in deep copy)
+ if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
+ target = {};
+ }
+
+ // extend jQuery itself if only one argument is passed
+ if ( length === i ) {
+ target = this;
+ --i;
+ }
+
+ for ( ; i < length; i++ ) {
+ // Only deal with non-null/undefined values
+ if ( (options = arguments[ i ]) != null ) {
+ // Extend the base object
+ for ( name in options ) {
+ src = target[ name ];
+ copy = options[ name ];
+
+ // Prevent never-ending loop
+ if ( target === copy ) {
+ continue;
+ }
+
+ // Recurse if we're merging plain objects or arrays
+ if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
+ if ( copyIsArray ) {
+ copyIsArray = false;
+ clone = src && jQuery.isArray(src) ? src : [];
+
+ } else {
+ clone = src && jQuery.isPlainObject(src) ? src : {};
+ }
+
+ // Never move original objects, clone them
+ target[ name ] = jQuery.extend( deep, clone, copy );
+
+ // Don't bring in undefined values
+ } else if ( copy !== undefined ) {
+ target[ name ] = copy;
+ }
+ }
+ }
+ }
+
+ // Return the modified object
+ return target;
+};
+
+jQuery.extend({
+ noConflict: function( deep ) {
+ if ( window.$ === jQuery ) {
+ window.$ = _$;
+ }
+
+ if ( deep && window.jQuery === jQuery ) {
+ window.jQuery = _jQuery;
+ }
+
+ return jQuery;
+ },
+
+ // Is the DOM ready to be used? Set to true once it occurs.
+ isReady: false,
+
+ // A counter to track how many items to wait for before
+ // the ready event fires. See #6781
+ readyWait: 1,
+
+ // Hold (or release) the ready event
+ holdReady: function( hold ) {
+ if ( hold ) {
+ jQuery.readyWait++;
+ } else {
+ jQuery.ready( true );
+ }
+ },
+
+ // Handle when the DOM is ready
+ ready: function( wait ) {
+
+ // Abort if there are pending holds or we're already ready
+ if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
+ return;
+ }
+
+ // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
+ if ( !document.body ) {
+ return setTimeout( jQuery.ready, 1 );
+ }
+
+ // Remember that the DOM is ready
+ jQuery.isReady = true;
+
+ // If a normal DOM Ready event fired, decrement, and wait if need be
+ if ( wait !== true && --jQuery.readyWait > 0 ) {
+ return;
+ }
+
+ // If there are functions bound, to execute
+ readyList.resolveWith( document, [ jQuery ] );
+
+ // Trigger any bound ready events
+ if ( jQuery.fn.trigger ) {
+ jQuery( document ).trigger("ready").off("ready");
+ }
+ },
+
+ // See test/unit/core.js for details concerning isFunction.
+ // Since version 1.3, DOM methods and functions like alert
+ // aren't supported. They return false on IE (#2968).
+ isFunction: function( obj ) {
+ return jQuery.type(obj) === "function";
+ },
+
+ isArray: Array.isArray || function( obj ) {
+ return jQuery.type(obj) === "array";
+ },
+
+ isWindow: function( obj ) {
+ return obj != null && obj == obj.window;
+ },
+
+ isNumeric: function( obj ) {
+ return !isNaN( parseFloat(obj) ) && isFinite( obj );
+ },
+
+ type: function( obj ) {
+ return obj == null ?
+ String( obj ) :
+ class2type[ core_toString.call(obj) ] || "object";
+ },
+
+ isPlainObject: function( obj ) {
+ // Must be an Object.
+ // Because of IE, we also have to check the presence of the constructor property.
+ // Make sure that DOM nodes and window objects don't pass through, as well
+ if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
+ return false;
+ }
+
+ try {
+ // Not own constructor property must be Object
+ if ( obj.constructor &&
+ !core_hasOwn.call(obj, "constructor") &&
+ !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
+ return false;
+ }
+ } catch ( e ) {
+ // IE8,9 Will throw exceptions on certain host objects #9897
+ return false;
+ }
+
+ // Own properties are enumerated firstly, so to speed up,
+ // if last one is own, then all properties are own.
+
+ var key;
+ for ( key in obj ) {}
+
+ return key === undefined || core_hasOwn.call( obj, key );
+ },
+
+ isEmptyObject: function( obj ) {
+ var name;
+ for ( name in obj ) {
+ return false;
+ }
+ return true;
+ },
+
+ error: function( msg ) {
+ throw new Error( msg );
+ },
+
+ // data: string of html
+ // context (optional): If specified, the fragment will be created in this context, defaults to document
+ // scripts (optional): If true, will include scripts passed in the html string
+ parseHTML: function( data, context, scripts ) {
+ var parsed;
+ if ( !data || typeof data !== "string" ) {
+ return null;
+ }
+ if ( typeof context === "boolean" ) {
+ scripts = context;
+ context = 0;
+ }
+ context = context || document;
+
+ // Single tag
+ if ( (parsed = rsingleTag.exec( data )) ) {
+ return [ context.createElement( parsed[1] ) ];
+ }
+
+ parsed = jQuery.buildFragment( [ data ], context, scripts ? null : [] );
+ return jQuery.merge( [],
+ (parsed.cacheable ? jQuery.clone( parsed.fragment ) : parsed.fragment).childNodes );
+ },
+
+ parseJSON: function( data ) {
+ if ( !data || typeof data !== "string") {
+ return null;
+ }
+
+ // Make sure leading/trailing whitespace is removed (IE can't handle it)
+ data = jQuery.trim( data );
+
+ // Attempt to parse using the native JSON parser first
+ if ( window.JSON && window.JSON.parse ) {
+ return window.JSON.parse( data );
+ }
+
+ // Make sure the incoming data is actual JSON
+ // Logic borrowed from http://json.org/json2.js
+ if ( rvalidchars.test( data.replace( rvalidescape, "@" )
+ .replace( rvalidtokens, "]" )
+ .replace( rvalidbraces, "")) ) {
+
+ return ( new Function( "return " + data ) )();
+
+ }
+ jQuery.error( "Invalid JSON: " + data );
+ },
+
+ // Cross-browser xml parsing
+ parseXML: function( data ) {
+ var xml, tmp;
+ if ( !data || typeof data !== "string" ) {
+ return null;
+ }
+ try {
+ if ( window.DOMParser ) { // Standard
+ tmp = new DOMParser();
+ xml = tmp.parseFromString( data , "text/xml" );
+ } else { // IE
+ xml = new ActiveXObject( "Microsoft.XMLDOM" );
+ xml.async = "false";
+ xml.loadXML( data );
+ }
+ } catch( e ) {
+ xml = undefined;
+ }
+ if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
+ jQuery.error( "Invalid XML: " + data );
+ }
+ return xml;
+ },
+
+ noop: function() {},
+
+ // Evaluates a script in a global context
+ // Workarounds based on findings by Jim Driscoll
+ // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
+ globalEval: function( data ) {
+ if ( data && core_rnotwhite.test( data ) ) {
+ // We use execScript on Internet Explorer
+ // We use an anonymous function so that context is window
+ // rather than jQuery in Firefox
+ ( window.execScript || function( data ) {
+ window[ "eval" ].call( window, data );
+ } )( data );
+ }
+ },
+
+ // Convert dashed to camelCase; used by the css and data modules
+ // Microsoft forgot to hump their vendor prefix (#9572)
+ camelCase: function( string ) {
+ return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
+ },
+
+ nodeName: function( elem, name ) {
+ return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
+ },
+
+ // args is for internal usage only
+ each: function( obj, callback, args ) {
+ var name,
+ i = 0,
+ length = obj.length,
+ isObj = length === undefined || jQuery.isFunction( obj );
+
+ if ( args ) {
+ if ( isObj ) {
+ for ( name in obj ) {
+ if ( callback.apply( obj[ name ], args ) === false ) {
+ break;
+ }
+ }
+ } else {
+ for ( ; i < length; ) {
+ if ( callback.apply( obj[ i++ ], args ) === false ) {
+ break;
+ }
+ }
+ }
+
+ // A special, fast, case for the most common use of each
+ } else {
+ if ( isObj ) {
+ for ( name in obj ) {
+ if ( callback.call( obj[ name ], name, obj[ name ] ) === false ) {
+ break;
+ }
+ }
+ } else {
+ for ( ; i < length; ) {
+ if ( callback.call( obj[ i ], i, obj[ i++ ] ) === false ) {
+ break;
+ }
+ }
+ }
+ }
+
+ return obj;
+ },
+
+ // Use native String.trim function wherever possible
+ trim: core_trim && !core_trim.call("\uFEFF\xA0") ?
+ function( text ) {
+ return text == null ?
+ "" :
+ core_trim.call( text );
+ } :
+
+ // Otherwise use our own trimming functionality
+ function( text ) {
+ return text == null ?
+ "" :
+ ( text + "" ).replace( rtrim, "" );
+ },
+
+ // results is for internal usage only
+ makeArray: function( arr, results ) {
+ var type,
+ ret = results || [];
+
+ if ( arr != null ) {
+ // The window, strings (and functions) also have 'length'
+ // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
+ type = jQuery.type( arr );
+
+ if ( arr.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( arr ) ) {
+ core_push.call( ret, arr );
+ } else {
+ jQuery.merge( ret, arr );
+ }
+ }
+
+ return ret;
+ },
+
+ inArray: function( elem, arr, i ) {
+ var len;
+
+ if ( arr ) {
+ if ( core_indexOf ) {
+ return core_indexOf.call( arr, elem, i );
+ }
+
+ len = arr.length;
+ i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
+
+ for ( ; i < len; i++ ) {
+ // Skip accessing in sparse arrays
+ if ( i in arr && arr[ i ] === elem ) {
+ return i;
+ }
+ }
+ }
+
+ return -1;
+ },
+
+ merge: function( first, second ) {
+ var l = second.length,
+ i = first.length,
+ j = 0;
+
+ if ( typeof l === "number" ) {
+ for ( ; j < l; j++ ) {
+ first[ i++ ] = second[ j ];
+ }
+
+ } else {
+ while ( second[j] !== undefined ) {
+ first[ i++ ] = second[ j++ ];
+ }
+ }
+
+ first.length = i;
+
+ return first;
+ },
+
+ grep: function( elems, callback, inv ) {
+ var retVal,
+ ret = [],
+ i = 0,
+ length = elems.length;
+ inv = !!inv;
+
+ // Go through the array, only saving the items
+ // that pass the validator function
+ for ( ; i < length; i++ ) {
+ retVal = !!callback( elems[ i ], i );
+ if ( inv !== retVal ) {
+ ret.push( elems[ i ] );
+ }
+ }
+
+ return ret;
+ },
+
+ // arg is for internal usage only
+ map: function( elems, callback, arg ) {
+ var value, key,
+ ret = [],
+ i = 0,
+ length = elems.length,
+ // jquery objects are treated as arrays
+ isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
+
+ // Go through the array, translating each of the items to their
+ if ( isArray ) {
+ for ( ; i < length; i++ ) {
+ value = callback( elems[ i ], i, arg );
+
+ if ( value != null ) {
+ ret[ ret.length ] = value;
+ }
+ }
+
+ // Go through every key on the object,
+ } else {
+ for ( key in elems ) {
+ value = callback( elems[ key ], key, arg );
+
+ if ( value != null ) {
+ ret[ ret.length ] = value;
+ }
+ }
+ }
+
+ // Flatten any nested arrays
+ return ret.concat.apply( [], ret );
+ },
+
+ // A global GUID counter for objects
+ guid: 1,
+
+ // Bind a function to a context, optionally partially applying any
+ // arguments.
+ proxy: function( fn, context ) {
+ var tmp, args, proxy;
+
+ if ( typeof context === "string" ) {
+ tmp = fn[ context ];
+ context = fn;
+ fn = tmp;
+ }
+
+ // Quick check to determine if target is callable, in the spec
+ // this throws a TypeError, but we will just return undefined.
+ if ( !jQuery.isFunction( fn ) ) {
+ return undefined;
+ }
+
+ // Simulated bind
+ args = core_slice.call( arguments, 2 );
+ proxy = function() {
+ return fn.apply( context, args.concat( core_slice.call( arguments ) ) );
+ };
+
+ // Set the guid of unique handler to the same of original handler, so it can be removed
+ proxy.guid = fn.guid = fn.guid || jQuery.guid++;
+
+ return proxy;
+ },
+
+ // Multifunctional method to get and set values of a collection
+ // The value/s can optionally be executed if it's a function
+ access: function( elems, fn, key, value, chainable, emptyGet, pass ) {
+ var exec,
+ bulk = key == null,
+ i = 0,
+ length = elems.length;
+
+ // Sets many values
+ if ( key && typeof key === "object" ) {
+ for ( i in key ) {
+ jQuery.access( elems, fn, i, key[i], 1, emptyGet, value );
+ }
+ chainable = 1;
+
+ // Sets one value
+ } else if ( value !== undefined ) {
+ // Optionally, function values get executed if exec is true
+ exec = pass === undefined && jQuery.isFunction( value );
+
+ if ( bulk ) {
+ // Bulk operations only iterate when executing function values
+ if ( exec ) {
+ exec = fn;
+ fn = function( elem, key, value ) {
+ return exec.call( jQuery( elem ), value );
+ };
+
+ // Otherwise they run against the entire set
+ } else {
+ fn.call( elems, value );
+ fn = null;
+ }
+ }
+
+ if ( fn ) {
+ for (; i < length; i++ ) {
+ fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
+ }
+ }
+
+ chainable = 1;
+ }
+
+ return chainable ?
+ elems :
+
+ // Gets
+ bulk ?
+ fn.call( elems ) :
+ length ? fn( elems[0], key ) : emptyGet;
+ },
+
+ now: function() {
+ return ( new Date() ).getTime();
+ }
+});
+
+jQuery.ready.promise = function( obj ) {
+ if ( !readyList ) {
+
+ readyList = jQuery.Deferred();
+
+ // Catch cases where $(document).ready() is called after the browser event has already occurred.
+ // we once tried to use readyState "interactive" here, but it caused issues like the one
+ // discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
+ if ( document.readyState === "complete" ) {
+ // Handle it asynchronously to allow scripts the opportunity to delay ready
+ setTimeout( jQuery.ready, 1 );
+
+ // Standards-based browsers support DOMContentLoaded
+ } else if ( document.addEventListener ) {
+ // Use the handy event callback
+ document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
+
+ // A fallback to window.onload, that will always work
+ window.addEventListener( "load", jQuery.ready, false );
+
+ // If IE event model is used
+ } else {
+ // Ensure firing before onload, maybe late but safe also for iframes
+ document.attachEvent( "onreadystatechange", DOMContentLoaded );
+
+ // A fallback to window.onload, that will always work
+ window.attachEvent( "onload", jQuery.ready );
+
+ // If IE and not a frame
+ // continually check to see if the document is ready
+ var top = false;
+
+ try {
+ top = window.frameElement == null && document.documentElement;
+ } catch(e) {}
+
+ if ( top && top.doScroll ) {
+ (function doScrollCheck() {
+ if ( !jQuery.isReady ) {
+
+ try {
+ // Use the trick by Diego Perini
+ // http://javascript.nwbox.com/IEContentLoaded/
+ top.doScroll("left");
+ } catch(e) {
+ return setTimeout( doScrollCheck, 50 );
+ }
+
+ // and execute any waiting functions
+ jQuery.ready();
+ }
+ })();
+ }
+ }
+ }
+ return readyList.promise( obj );
+};
+
+// Populate the class2type map
+jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
+ class2type[ "[object " + name + "]" ] = name.toLowerCase();
+});
+
+// All jQuery objects should point back to these
+rootjQuery = jQuery(document);
+// String to Object options format cache
+var optionsCache = {};
+
+// Convert String-formatted options into Object-formatted ones and store in cache
+function createOptions( options ) {
+ var object = optionsCache[ options ] = {};
+ jQuery.each( options.split( core_rspace ), function( _, flag ) {
+ object[ flag ] = true;
+ });
+ return object;
+}
+
+/*
+ * Create a callback list using the following parameters:
+ *
+ * options: an optional list of space-separated options that will change how
+ * the callback list behaves or a more traditional option object
+ *
+ * By default a callback list will act like an event callback list and can be
+ * "fired" multiple times.
+ *
+ * Possible options:
+ *
+ * once: will ensure the callback list can only be fired once (like a Deferred)
+ *
+ * memory: will keep track of previous values and will call any callback added
+ * after the list has been fired right away with the latest "memorized"
+ * values (like a Deferred)
+ *
+ * unique: will ensure a callback can only be added once (no duplicate in the list)
+ *
+ * stopOnFalse: interrupt callings when a callback returns false
+ *
+ */
+jQuery.Callbacks = function( options ) {
+
+ // Convert options from String-formatted to Object-formatted if needed
+ // (we check in cache first)
+ options = typeof options === "string" ?
+ ( optionsCache[ options ] || createOptions( options ) ) :
+ jQuery.extend( {}, options );
+
+ var // Last fire value (for non-forgettable lists)
+ memory,
+ // Flag to know if list was already fired
+ fired,
+ // Flag to know if list is currently firing
+ firing,
+ // First callback to fire (used internally by add and fireWith)
+ firingStart,
+ // End of the loop when firing
+ firingLength,
+ // Index of currently firing callback (modified by remove if needed)
+ firingIndex,
+ // Actual callback list
+ list = [],
+ // Stack of fire calls for repeatable lists
+ stack = !options.once && [],
+ // Fire callbacks
+ fire = function( data ) {
+ memory = options.memory && data;
+ fired = true;
+ firingIndex = firingStart || 0;
+ firingStart = 0;
+ firingLength = list.length;
+ firing = true;
+ for ( ; list && firingIndex < firingLength; firingIndex++ ) {
+ if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
+ memory = false; // To prevent further calls using add
+ break;
+ }
+ }
+ firing = false;
+ if ( list ) {
+ if ( stack ) {
+ if ( stack.length ) {
+ fire( stack.shift() );
+ }
+ } else if ( memory ) {
+ list = [];
+ } else {
+ self.disable();
+ }
+ }
+ },
+ // Actual Callbacks object
+ self = {
+ // Add a callback or a collection of callbacks to the list
+ add: function() {
+ if ( list ) {
+ // First, we save the current length
+ var start = list.length;
+ (function add( args ) {
+ jQuery.each( args, function( _, arg ) {
+ var type = jQuery.type( arg );
+ if ( type === "function" ) {
+ if ( !options.unique || !self.has( arg ) ) {
+ list.push( arg );
+ }
+ } else if ( arg && arg.length && type !== "string" ) {
+ // Inspect recursively
+ add( arg );
+ }
+ });
+ })( arguments );
+ // Do we need to add the callbacks to the
+ // current firing batch?
+ if ( firing ) {
+ firingLength = list.length;
+ // With memory, if we're not firing then
+ // we should call right away
+ } else if ( memory ) {
+ firingStart = start;
+ fire( memory );
+ }
+ }
+ return this;
+ },
+ // Remove a callback from the list
+ remove: function() {
+ if ( list ) {
+ jQuery.each( arguments, function( _, arg ) {
+ var index;
+ while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
+ list.splice( index, 1 );
+ // Handle firing indexes
+ if ( firing ) {
+ if ( index <= firingLength ) {
+ firingLength--;
+ }
+ if ( index <= firingIndex ) {
+ firingIndex--;
+ }
+ }
+ }
+ });
+ }
+ return this;
+ },
+ // Control if a given callback is in the list
+ has: function( fn ) {
+ return jQuery.inArray( fn, list ) > -1;
+ },
+ // Remove all callbacks from the list
+ empty: function() {
+ list = [];
+ return this;
+ },
+ // Have the list do nothing anymore
+ disable: function() {
+ list = stack = memory = undefined;
+ return this;
+ },
+ // Is it disabled?
+ disabled: function() {
+ return !list;
+ },
+ // Lock the list in its current state
+ lock: function() {
+ stack = undefined;
+ if ( !memory ) {
+ self.disable();
+ }
+ return this;
+ },
+ // Is it locked?
+ locked: function() {
+ return !stack;
+ },
+ // Call all callbacks with the given context and arguments
+ fireWith: function( context, args ) {
+ args = args || [];
+ args = [ context, args.slice ? args.slice() : args ];
+ if ( list && ( !fired || stack ) ) {
+ if ( firing ) {
+ stack.push( args );
+ } else {
+ fire( args );
+ }
+ }
+ return this;
+ },
+ // Call all the callbacks with the given arguments
+ fire: function() {
+ self.fireWith( this, arguments );
+ return this;
+ },
+ // To know if the callbacks have already been called at least once
+ fired: function() {
+ return !!fired;
+ }
+ };
+
+ return self;
+};
+jQuery.extend({
+
+ Deferred: function( func ) {
+ var tuples = [
+ // action, add listener, listener list, final state
+ [ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
+ [ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
+ [ "notify", "progress", jQuery.Callbacks("memory") ]
+ ],
+ state = "pending",
+ promise = {
+ state: function() {
+ return state;
+ },
+ always: function() {
+ deferred.done( arguments ).fail( arguments );
+ return this;
+ },
+ then: function( /* fnDone, fnFail, fnProgress */ ) {
+ var fns = arguments;
+ return jQuery.Deferred(function( newDefer ) {
+ jQuery.each( tuples, function( i, tuple ) {
+ var action = tuple[ 0 ],
+ fn = fns[ i ];
+ // deferred[ done | fail | progress ] for forwarding actions to newDefer
+ deferred[ tuple[1] ]( jQuery.isFunction( fn ) ?
+ function() {
+ var returned = fn.apply( this, arguments );
+ if ( returned && jQuery.isFunction( returned.promise ) ) {
+ returned.promise()
+ .done( newDefer.resolve )
+ .fail( newDefer.reject )
+ .progress( newDefer.notify );
+ } else {
+ newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
+ }
+ } :
+ newDefer[ action ]
+ );
+ });
+ fns = null;
+ }).promise();
+ },
+ // Get a promise for this deferred
+ // If obj is provided, the promise aspect is added to the object
+ promise: function( obj ) {
+ return obj != null ? jQuery.extend( obj, promise ) : promise;
+ }
+ },
+ deferred = {};
+
+ // Keep pipe for back-compat
+ promise.pipe = promise.then;
+
+ // Add list-specific methods
+ jQuery.each( tuples, function( i, tuple ) {
+ var list = tuple[ 2 ],
+ stateString = tuple[ 3 ];
+
+ // promise[ done | fail | progress ] = list.add
+ promise[ tuple[1] ] = list.add;
+
+ // Handle state
+ if ( stateString ) {
+ list.add(function() {
+ // state = [ resolved | rejected ]
+ state = stateString;
+
+ // [ reject_list | resolve_list ].disable; progress_list.lock
+ }, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
+ }
+
+ // deferred[ resolve | reject | notify ] = list.fire
+ deferred[ tuple[0] ] = list.fire;
+ deferred[ tuple[0] + "With" ] = list.fireWith;
+ });
+
+ // Make the deferred a promise
+ promise.promise( deferred );
+
+ // Call given func if any
+ if ( func ) {
+ func.call( deferred, deferred );
+ }
+
+ // All done!
+ return deferred;
+ },
+
+ // Deferred helper
+ when: function( subordinate /* , ..., subordinateN */ ) {
+ var i = 0,
+ resolveValues = core_slice.call( arguments ),
+ length = resolveValues.length,
+
+ // the count of uncompleted subordinates
+ remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
+
+ // the master Deferred. If resolveValues consist of only a single Deferred, just use that.
+ deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
+
+ // Update function for both resolve and progress values
+ updateFunc = function( i, contexts, values ) {
+ return function( value ) {
+ contexts[ i ] = this;
+ values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
+ if( values === progressValues ) {
+ deferred.notifyWith( contexts, values );
+ } else if ( !( --remaining ) ) {
+ deferred.resolveWith( contexts, values );
+ }
+ };
+ },
+
+ progressValues, progressContexts, resolveContexts;
+
+ // add listeners to Deferred subordinates; treat others as resolved
+ if ( length > 1 ) {
+ progressValues = new Array( length );
+ progressContexts = new Array( length );
+ resolveContexts = new Array( length );
+ for ( ; i < length; i++ ) {
+ if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
+ resolveValues[ i ].promise()
+ .done( updateFunc( i, resolveContexts, resolveValues ) )
+ .fail( deferred.reject )
+ .progress( updateFunc( i, progressContexts, progressValues ) );
+ } else {
+ --remaining;
+ }
+ }
+ }
+
+ // if we're not waiting on anything, resolve the master
+ if ( !remaining ) {
+ deferred.resolveWith( resolveContexts, resolveValues );
+ }
+
+ return deferred.promise();
+ }
+});
+jQuery.support = (function() {
+
+ var support,
+ all,
+ a,
+ select,
+ opt,
+ input,
+ fragment,
+ eventName,
+ i,
+ isSupported,
+ clickFn,
+ div = document.createElement("div");
+
+ // Setup
+ div.setAttribute( "className", "t" );
+ div.innerHTML = "
a";
+
+ // Support tests won't run in some limited or non-browser environments
+ all = div.getElementsByTagName("*");
+ a = div.getElementsByTagName("a")[ 0 ];
+ if ( !all || !a || !all.length ) {
+ return {};
+ }
+
+ // First batch of tests
+ select = document.createElement("select");
+ opt = select.appendChild( document.createElement("option") );
+ input = div.getElementsByTagName("input")[ 0 ];
+
+ a.style.cssText = "top:1px;float:left;opacity:.5";
+ support = {
+ // IE strips leading whitespace when .innerHTML is used
+ leadingWhitespace: ( div.firstChild.nodeType === 3 ),
+
+ // Make sure that tbody elements aren't automatically inserted
+ // IE will insert them into empty tables
+ tbody: !div.getElementsByTagName("tbody").length,
+
+ // Make sure that link elements get serialized correctly by innerHTML
+ // This requires a wrapper element in IE
+ htmlSerialize: !!div.getElementsByTagName("link").length,
+
+ // Get the style information from getAttribute
+ // (IE uses .cssText instead)
+ style: /top/.test( a.getAttribute("style") ),
+
+ // Make sure that URLs aren't manipulated
+ // (IE normalizes it by default)
+ hrefNormalized: ( a.getAttribute("href") === "/a" ),
+
+ // Make sure that element opacity exists
+ // (IE uses filter instead)
+ // Use a regex to work around a WebKit issue. See #5145
+ opacity: /^0.5/.test( a.style.opacity ),
+
+ // Verify style float existence
+ // (IE uses styleFloat instead of cssFloat)
+ cssFloat: !!a.style.cssFloat,
+
+ // Make sure that if no value is specified for a checkbox
+ // that it defaults to "on".
+ // (WebKit defaults to "" instead)
+ checkOn: ( input.value === "on" ),
+
+ // Make sure that a selected-by-default option has a working selected property.
+ // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
+ optSelected: opt.selected,
+
+ // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
+ getSetAttribute: div.className !== "t",
+
+ // Tests for enctype support on a form (#6743)
+ enctype: !!document.createElement("form").enctype,
+
+ // Makes sure cloning an html5 element does not cause problems
+ // Where outerHTML is undefined, this still works
+ html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav>",
+
+ // jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode
+ boxModel: ( document.compatMode === "CSS1Compat" ),
+
+ // Will be defined later
+ submitBubbles: true,
+ changeBubbles: true,
+ focusinBubbles: false,
+ deleteExpando: true,
+ noCloneEvent: true,
+ inlineBlockNeedsLayout: false,
+ shrinkWrapBlocks: false,
+ reliableMarginRight: true,
+ boxSizingReliable: true,
+ pixelPosition: false
+ };
+
+ // Make sure checked status is properly cloned
+ input.checked = true;
+ support.noCloneChecked = input.cloneNode( true ).checked;
+
+ // Make sure that the options inside disabled selects aren't marked as disabled
+ // (WebKit marks them as disabled)
+ select.disabled = true;
+ support.optDisabled = !opt.disabled;
+
+ // Test to see if it's possible to delete an expando from an element
+ // Fails in Internet Explorer
+ try {
+ delete div.test;
+ } catch( e ) {
+ support.deleteExpando = false;
+ }
+
+ if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
+ div.attachEvent( "onclick", clickFn = function() {
+ // Cloning a node shouldn't copy over any
+ // bound event handlers (IE does this)
+ support.noCloneEvent = false;
+ });
+ div.cloneNode( true ).fireEvent("onclick");
+ div.detachEvent( "onclick", clickFn );
+ }
+
+ // Check if a radio maintains its value
+ // after being appended to the DOM
+ input = document.createElement("input");
+ input.value = "t";
+ input.setAttribute( "type", "radio" );
+ support.radioValue = input.value === "t";
+
+ input.setAttribute( "checked", "checked" );
+
+ // #11217 - WebKit loses check when the name is after the checked attribute
+ input.setAttribute( "name", "t" );
+
+ div.appendChild( input );
+ fragment = document.createDocumentFragment();
+ fragment.appendChild( div.lastChild );
+
+ // WebKit doesn't clone checked state correctly in fragments
+ support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
+
+ // Check if a disconnected checkbox will retain its checked
+ // value of true after appended to the DOM (IE6/7)
+ support.appendChecked = input.checked;
+
+ fragment.removeChild( input );
+ fragment.appendChild( div );
+
+ // Technique from Juriy Zaytsev
+ // http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
+ // We only care about the case where non-standard event systems
+ // are used, namely in IE. Short-circuiting here helps us to
+ // avoid an eval call (in setAttribute) which can cause CSP
+ // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
+ if ( div.attachEvent ) {
+ for ( i in {
+ submit: true,
+ change: true,
+ focusin: true
+ }) {
+ eventName = "on" + i;
+ isSupported = ( eventName in div );
+ if ( !isSupported ) {
+ div.setAttribute( eventName, "return;" );
+ isSupported = ( typeof div[ eventName ] === "function" );
+ }
+ support[ i + "Bubbles" ] = isSupported;
+ }
+ }
+
+ // Run tests that need a body at doc ready
+ jQuery(function() {
+ var container, div, tds, marginDiv,
+ divReset = "padding:0;margin:0;border:0;display:block;overflow:hidden;",
+ body = document.getElementsByTagName("body")[0];
+
+ if ( !body ) {
+ // Return for frameset docs that don't have a body
+ return;
+ }
+
+ container = document.createElement("div");
+ container.style.cssText = "visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px";
+ body.insertBefore( container, body.firstChild );
+
+ // Construct the test element
+ div = document.createElement("div");
+ container.appendChild( div );
+
+ // Check if table cells still have offsetWidth/Height when they are set
+ // to display:none and there are still other visible table cells in a
+ // table row; if so, offsetWidth/Height are not reliable for use when
+ // determining if an element has been hidden directly using
+ // display:none (it is still safe to use offsets if a parent element is
+ // hidden; don safety goggles and see bug #4512 for more information).
+ // (only IE 8 fails this test)
+ div.innerHTML = "
t
";
+ tds = div.getElementsByTagName("td");
+ tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none";
+ isSupported = ( tds[ 0 ].offsetHeight === 0 );
+
+ tds[ 0 ].style.display = "";
+ tds[ 1 ].style.display = "none";
+
+ // Check if empty table cells still have offsetWidth/Height
+ // (IE <= 8 fail this test)
+ support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
+
+ // Check box-sizing and margin behavior
+ div.innerHTML = "";
+ div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;";
+ support.boxSizing = ( div.offsetWidth === 4 );
+ support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 );
+
+ // NOTE: To any future maintainer, we've window.getComputedStyle
+ // because jsdom on node.js will break without it.
+ if ( window.getComputedStyle ) {
+ support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%";
+ support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";
+
+ // Check if div with explicit width and no margin-right incorrectly
+ // gets computed margin-right based on width of container. For more
+ // info see bug #3333
+ // Fails in WebKit before Feb 2011 nightlies
+ // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
+ marginDiv = document.createElement("div");
+ marginDiv.style.cssText = div.style.cssText = divReset;
+ marginDiv.style.marginRight = marginDiv.style.width = "0";
+ div.style.width = "1px";
+ div.appendChild( marginDiv );
+ support.reliableMarginRight =
+ !parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight );
+ }
+
+ if ( typeof div.style.zoom !== "undefined" ) {
+ // Check if natively block-level elements act like inline-block
+ // elements when setting their display to 'inline' and giving
+ // them layout
+ // (IE < 8 does this)
+ div.innerHTML = "";
+ div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1";
+ support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
+
+ // Check if elements with layout shrink-wrap their children
+ // (IE 6 does this)
+ div.style.display = "block";
+ div.style.overflow = "visible";
+ div.innerHTML = "";
+ div.firstChild.style.width = "5px";
+ support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
+
+ container.style.zoom = 1;
+ }
+
+ // Null elements to avoid leaks in IE
+ body.removeChild( container );
+ container = div = tds = marginDiv = null;
+ });
+
+ // Null elements to avoid leaks in IE
+ fragment.removeChild( div );
+ all = a = select = opt = input = fragment = div = null;
+
+ return support;
+})();
+var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
+ rmultiDash = /([A-Z])/g;
+
+jQuery.extend({
+ cache: {},
+
+ deletedIds: [],
+
+ // Remove at next major release (1.9/2.0)
+ uuid: 0,
+
+ // Unique for each copy of jQuery on the page
+ // Non-digits removed to match rinlinejQuery
+ expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
+
+ // The following elements throw uncatchable exceptions if you
+ // attempt to add expando properties to them.
+ noData: {
+ "embed": true,
+ // Ban all objects except for Flash (which handle expandos)
+ "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
+ "applet": true
+ },
+
+ hasData: function( elem ) {
+ elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
+ return !!elem && !isEmptyDataObject( elem );
+ },
+
+ data: function( elem, name, data, pvt /* Internal Use Only */ ) {
+ if ( !jQuery.acceptData( elem ) ) {
+ return;
+ }
+
+ var thisCache, ret,
+ internalKey = jQuery.expando,
+ getByName = typeof name === "string",
+
+ // We have to handle DOM nodes and JS objects differently because IE6-7
+ // can't GC object references properly across the DOM-JS boundary
+ isNode = elem.nodeType,
+
+ // Only DOM nodes need the global jQuery cache; JS object data is
+ // attached directly to the object so GC can occur automatically
+ cache = isNode ? jQuery.cache : elem,
+
+ // Only defining an ID for JS objects if its cache already exists allows
+ // the code to shortcut on the same path as a DOM node with no cache
+ id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;
+
+ // Avoid doing any more work than we need to when trying to get data on an
+ // object that has no data at all
+ if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) {
+ return;
+ }
+
+ if ( !id ) {
+ // Only DOM nodes need a new unique ID for each element since their data
+ // ends up in the global cache
+ if ( isNode ) {
+ elem[ internalKey ] = id = jQuery.deletedIds.pop() || jQuery.guid++;
+ } else {
+ id = internalKey;
+ }
+ }
+
+ if ( !cache[ id ] ) {
+ cache[ id ] = {};
+
+ // Avoids exposing jQuery metadata on plain JS objects when the object
+ // is serialized using JSON.stringify
+ if ( !isNode ) {
+ cache[ id ].toJSON = jQuery.noop;
+ }
+ }
+
+ // An object can be passed to jQuery.data instead of a key/value pair; this gets
+ // shallow copied over onto the existing cache
+ if ( typeof name === "object" || typeof name === "function" ) {
+ if ( pvt ) {
+ cache[ id ] = jQuery.extend( cache[ id ], name );
+ } else {
+ cache[ id ].data = jQuery.extend( cache[ id ].data, name );
+ }
+ }
+
+ thisCache = cache[ id ];
+
+ // jQuery data() is stored in a separate object inside the object's internal data
+ // cache in order to avoid key collisions between internal data and user-defined
+ // data.
+ if ( !pvt ) {
+ if ( !thisCache.data ) {
+ thisCache.data = {};
+ }
+
+ thisCache = thisCache.data;
+ }
+
+ if ( data !== undefined ) {
+ thisCache[ jQuery.camelCase( name ) ] = data;
+ }
+
+ // Check for both converted-to-camel and non-converted data property names
+ // If a data property was specified
+ if ( getByName ) {
+
+ // First Try to find as-is property data
+ ret = thisCache[ name ];
+
+ // Test for null|undefined property data
+ if ( ret == null ) {
+
+ // Try to find the camelCased property
+ ret = thisCache[ jQuery.camelCase( name ) ];
+ }
+ } else {
+ ret = thisCache;
+ }
+
+ return ret;
+ },
+
+ removeData: function( elem, name, pvt /* Internal Use Only */ ) {
+ if ( !jQuery.acceptData( elem ) ) {
+ return;
+ }
+
+ var thisCache, i, l,
+
+ isNode = elem.nodeType,
+
+ // See jQuery.data for more information
+ cache = isNode ? jQuery.cache : elem,
+ id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
+
+ // If there is already no cache entry for this object, there is no
+ // purpose in continuing
+ if ( !cache[ id ] ) {
+ return;
+ }
+
+ if ( name ) {
+
+ thisCache = pvt ? cache[ id ] : cache[ id ].data;
+
+ if ( thisCache ) {
+
+ // Support array or space separated string names for data keys
+ if ( !jQuery.isArray( name ) ) {
+
+ // try the string as a key before any manipulation
+ if ( name in thisCache ) {
+ name = [ name ];
+ } else {
+
+ // split the camel cased version by spaces unless a key with the spaces exists
+ name = jQuery.camelCase( name );
+ if ( name in thisCache ) {
+ name = [ name ];
+ } else {
+ name = name.split(" ");
+ }
+ }
+ }
+
+ for ( i = 0, l = name.length; i < l; i++ ) {
+ delete thisCache[ name[i] ];
+ }
+
+ // If there is no data left in the cache, we want to continue
+ // and let the cache object itself get destroyed
+ if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
+ return;
+ }
+ }
+ }
+
+ // See jQuery.data for more information
+ if ( !pvt ) {
+ delete cache[ id ].data;
+
+ // Don't destroy the parent cache unless the internal data object
+ // had been the only thing left in it
+ if ( !isEmptyDataObject( cache[ id ] ) ) {
+ return;
+ }
+ }
+
+ // Destroy the cache
+ if ( isNode ) {
+ jQuery.cleanData( [ elem ], true );
+
+ // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
+ } else if ( jQuery.support.deleteExpando || cache != cache.window ) {
+ delete cache[ id ];
+
+ // When all else fails, null
+ } else {
+ cache[ id ] = null;
+ }
+ },
+
+ // For internal use only.
+ _data: function( elem, name, data ) {
+ return jQuery.data( elem, name, data, true );
+ },
+
+ // A method for determining if a DOM node can handle the data expando
+ acceptData: function( elem ) {
+ var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ];
+
+ // nodes accept data unless otherwise specified; rejection can be conditional
+ return !noData || noData !== true && elem.getAttribute("classid") === noData;
+ }
+});
+
+jQuery.fn.extend({
+ data: function( key, value ) {
+ var parts, part, attr, name, l,
+ elem = this[0],
+ i = 0,
+ data = null;
+
+ // Gets all values
+ if ( key === undefined ) {
+ if ( this.length ) {
+ data = jQuery.data( elem );
+
+ if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
+ attr = elem.attributes;
+ for ( l = attr.length; i < l; i++ ) {
+ name = attr[i].name;
+
+ if ( !name.indexOf( "data-" ) ) {
+ name = jQuery.camelCase( name.substring(5) );
+
+ dataAttr( elem, name, data[ name ] );
+ }
+ }
+ jQuery._data( elem, "parsedAttrs", true );
+ }
+ }
+
+ return data;
+ }
+
+ // Sets multiple values
+ if ( typeof key === "object" ) {
+ return this.each(function() {
+ jQuery.data( this, key );
+ });
+ }
+
+ parts = key.split( ".", 2 );
+ parts[1] = parts[1] ? "." + parts[1] : "";
+ part = parts[1] + "!";
+
+ return jQuery.access( this, function( value ) {
+
+ if ( value === undefined ) {
+ data = this.triggerHandler( "getData" + part, [ parts[0] ] );
+
+ // Try to fetch any internally stored data first
+ if ( data === undefined && elem ) {
+ data = jQuery.data( elem, key );
+ data = dataAttr( elem, key, data );
+ }
+
+ return data === undefined && parts[1] ?
+ this.data( parts[0] ) :
+ data;
+ }
+
+ parts[1] = value;
+ this.each(function() {
+ var self = jQuery( this );
+
+ self.triggerHandler( "setData" + part, parts );
+ jQuery.data( this, key, value );
+ self.triggerHandler( "changeData" + part, parts );
+ });
+ }, null, value, arguments.length > 1, null, false );
+ },
+
+ removeData: function( key ) {
+ return this.each(function() {
+ jQuery.removeData( this, key );
+ });
+ }
+});
+
+function dataAttr( elem, key, data ) {
+ // If nothing was found internally, try to fetch any
+ // data from the HTML5 data-* attribute
+ if ( data === undefined && elem.nodeType === 1 ) {
+
+ var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
+
+ data = elem.getAttribute( name );
+
+ if ( typeof data === "string" ) {
+ try {
+ data = data === "true" ? true :
+ data === "false" ? false :
+ data === "null" ? null :
+ // Only convert to a number if it doesn't change the string
+ +data + "" === data ? +data :
+ rbrace.test( data ) ? jQuery.parseJSON( data ) :
+ data;
+ } catch( e ) {}
+
+ // Make sure we set the data so it isn't changed later
+ jQuery.data( elem, key, data );
+
+ } else {
+ data = undefined;
+ }
+ }
+
+ return data;
+}
+
+// checks a cache object for emptiness
+function isEmptyDataObject( obj ) {
+ var name;
+ for ( name in obj ) {
+
+ // if the public data object is empty, the private is still empty
+ if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
+ continue;
+ }
+ if ( name !== "toJSON" ) {
+ return false;
+ }
+ }
+
+ return true;
+}
+jQuery.extend({
+ queue: function( elem, type, data ) {
+ var queue;
+
+ if ( elem ) {
+ type = ( type || "fx" ) + "queue";
+ queue = jQuery._data( elem, type );
+
+ // Speed up dequeue by getting out quickly if this is just a lookup
+ if ( data ) {
+ if ( !queue || jQuery.isArray(data) ) {
+ queue = jQuery._data( elem, type, jQuery.makeArray(data) );
+ } else {
+ queue.push( data );
+ }
+ }
+ return queue || [];
+ }
+ },
+
+ dequeue: function( elem, type ) {
+ type = type || "fx";
+
+ var queue = jQuery.queue( elem, type ),
+ startLength = queue.length,
+ fn = queue.shift(),
+ hooks = jQuery._queueHooks( elem, type ),
+ next = function() {
+ jQuery.dequeue( elem, type );
+ };
+
+ // If the fx queue is dequeued, always remove the progress sentinel
+ if ( fn === "inprogress" ) {
+ fn = queue.shift();
+ startLength--;
+ }
+
+ if ( fn ) {
+
+ // Add a progress sentinel to prevent the fx queue from being
+ // automatically dequeued
+ if ( type === "fx" ) {
+ queue.unshift( "inprogress" );
+ }
+
+ // clear up the last queue stop function
+ delete hooks.stop;
+ fn.call( elem, next, hooks );
+ }
+
+ if ( !startLength && hooks ) {
+ hooks.empty.fire();
+ }
+ },
+
+ // not intended for public consumption - generates a queueHooks object, or returns the current one
+ _queueHooks: function( elem, type ) {
+ var key = type + "queueHooks";
+ return jQuery._data( elem, key ) || jQuery._data( elem, key, {
+ empty: jQuery.Callbacks("once memory").add(function() {
+ jQuery.removeData( elem, type + "queue", true );
+ jQuery.removeData( elem, key, true );
+ })
+ });
+ }
+});
+
+jQuery.fn.extend({
+ queue: function( type, data ) {
+ var setter = 2;
+
+ if ( typeof type !== "string" ) {
+ data = type;
+ type = "fx";
+ setter--;
+ }
+
+ if ( arguments.length < setter ) {
+ return jQuery.queue( this[0], type );
+ }
+
+ return data === undefined ?
+ this :
+ this.each(function() {
+ var queue = jQuery.queue( this, type, data );
+
+ // ensure a hooks for this queue
+ jQuery._queueHooks( this, type );
+
+ if ( type === "fx" && queue[0] !== "inprogress" ) {
+ jQuery.dequeue( this, type );
+ }
+ });
+ },
+ dequeue: function( type ) {
+ return this.each(function() {
+ jQuery.dequeue( this, type );
+ });
+ },
+ // Based off of the plugin by Clint Helfers, with permission.
+ // http://blindsignals.com/index.php/2009/07/jquery-delay/
+ delay: function( time, type ) {
+ time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
+ type = type || "fx";
+
+ return this.queue( type, function( next, hooks ) {
+ var timeout = setTimeout( next, time );
+ hooks.stop = function() {
+ clearTimeout( timeout );
+ };
+ });
+ },
+ clearQueue: function( type ) {
+ return this.queue( type || "fx", [] );
+ },
+ // Get a promise resolved when queues of a certain type
+ // are emptied (fx is the type by default)
+ promise: function( type, obj ) {
+ var tmp,
+ count = 1,
+ defer = jQuery.Deferred(),
+ elements = this,
+ i = this.length,
+ resolve = function() {
+ if ( !( --count ) ) {
+ defer.resolveWith( elements, [ elements ] );
+ }
+ };
+
+ if ( typeof type !== "string" ) {
+ obj = type;
+ type = undefined;
+ }
+ type = type || "fx";
+
+ while( i-- ) {
+ tmp = jQuery._data( elements[ i ], type + "queueHooks" );
+ if ( tmp && tmp.empty ) {
+ count++;
+ tmp.empty.add( resolve );
+ }
+ }
+ resolve();
+ return defer.promise( obj );
+ }
+});
+var nodeHook, boolHook, fixSpecified,
+ rclass = /[\t\r\n]/g,
+ rreturn = /\r/g,
+ rtype = /^(?:button|input)$/i,
+ rfocusable = /^(?:button|input|object|select|textarea)$/i,
+ rclickable = /^a(?:rea|)$/i,
+ rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
+ getSetAttribute = jQuery.support.getSetAttribute;
+
+jQuery.fn.extend({
+ attr: function( name, value ) {
+ return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
+ },
+
+ removeAttr: function( name ) {
+ return this.each(function() {
+ jQuery.removeAttr( this, name );
+ });
+ },
+
+ prop: function( name, value ) {
+ return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
+ },
+
+ removeProp: function( name ) {
+ name = jQuery.propFix[ name ] || name;
+ return this.each(function() {
+ // try/catch handles cases where IE balks (such as removing a property on window)
+ try {
+ this[ name ] = undefined;
+ delete this[ name ];
+ } catch( e ) {}
+ });
+ },
+
+ addClass: function( value ) {
+ var classNames, i, l, elem,
+ setClass, c, cl;
+
+ if ( jQuery.isFunction( value ) ) {
+ return this.each(function( j ) {
+ jQuery( this ).addClass( value.call(this, j, this.className) );
+ });
+ }
+
+ if ( value && typeof value === "string" ) {
+ classNames = value.split( core_rspace );
+
+ for ( i = 0, l = this.length; i < l; i++ ) {
+ elem = this[ i ];
+
+ if ( elem.nodeType === 1 ) {
+ if ( !elem.className && classNames.length === 1 ) {
+ elem.className = value;
+
+ } else {
+ setClass = " " + elem.className + " ";
+
+ for ( c = 0, cl = classNames.length; c < cl; c++ ) {
+ if ( setClass.indexOf( " " + classNames[ c ] + " " ) < 0 ) {
+ setClass += classNames[ c ] + " ";
+ }
+ }
+ elem.className = jQuery.trim( setClass );
+ }
+ }
+ }
+ }
+
+ return this;
+ },
+
+ removeClass: function( value ) {
+ var removes, className, elem, c, cl, i, l;
+
+ if ( jQuery.isFunction( value ) ) {
+ return this.each(function( j ) {
+ jQuery( this ).removeClass( value.call(this, j, this.className) );
+ });
+ }
+ if ( (value && typeof value === "string") || value === undefined ) {
+ removes = ( value || "" ).split( core_rspace );
+
+ for ( i = 0, l = this.length; i < l; i++ ) {
+ elem = this[ i ];
+ if ( elem.nodeType === 1 && elem.className ) {
+
+ className = (" " + elem.className + " ").replace( rclass, " " );
+
+ // loop over each item in the removal list
+ for ( c = 0, cl = removes.length; c < cl; c++ ) {
+ // Remove until there is nothing to remove,
+ while ( className.indexOf(" " + removes[ c ] + " ") >= 0 ) {
+ className = className.replace( " " + removes[ c ] + " " , " " );
+ }
+ }
+ elem.className = value ? jQuery.trim( className ) : "";
+ }
+ }
+ }
+
+ return this;
+ },
+
+ toggleClass: function( value, stateVal ) {
+ var type = typeof value,
+ isBool = typeof stateVal === "boolean";
+
+ if ( jQuery.isFunction( value ) ) {
+ return this.each(function( i ) {
+ jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
+ });
+ }
+
+ return this.each(function() {
+ if ( type === "string" ) {
+ // toggle individual class names
+ var className,
+ i = 0,
+ self = jQuery( this ),
+ state = stateVal,
+ classNames = value.split( core_rspace );
+
+ while ( (className = classNames[ i++ ]) ) {
+ // check each className given, space separated list
+ state = isBool ? state : !self.hasClass( className );
+ self[ state ? "addClass" : "removeClass" ]( className );
+ }
+
+ } else if ( type === "undefined" || type === "boolean" ) {
+ if ( this.className ) {
+ // store className if set
+ jQuery._data( this, "__className__", this.className );
+ }
+
+ // toggle whole className
+ this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
+ }
+ });
+ },
+
+ hasClass: function( selector ) {
+ var className = " " + selector + " ",
+ i = 0,
+ l = this.length;
+ for ( ; i < l; i++ ) {
+ if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) {
+ return true;
+ }
+ }
+
+ return false;
+ },
+
+ val: function( value ) {
+ var hooks, ret, isFunction,
+ elem = this[0];
+
+ if ( !arguments.length ) {
+ if ( elem ) {
+ hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
+
+ if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
+ return ret;
+ }
+
+ ret = elem.value;
+
+ return typeof ret === "string" ?
+ // handle most common string cases
+ ret.replace(rreturn, "") :
+ // handle cases where value is null/undef or number
+ ret == null ? "" : ret;
+ }
+
+ return;
+ }
+
+ isFunction = jQuery.isFunction( value );
+
+ return this.each(function( i ) {
+ var val,
+ self = jQuery(this);
+
+ if ( this.nodeType !== 1 ) {
+ return;
+ }
+
+ if ( isFunction ) {
+ val = value.call( this, i, self.val() );
+ } else {
+ val = value;
+ }
+
+ // Treat null/undefined as ""; convert numbers to string
+ if ( val == null ) {
+ val = "";
+ } else if ( typeof val === "number" ) {
+ val += "";
+ } else if ( jQuery.isArray( val ) ) {
+ val = jQuery.map(val, function ( value ) {
+ return value == null ? "" : value + "";
+ });
+ }
+
+ hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
+
+ // If set returns undefined, fall back to normal setting
+ if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
+ this.value = val;
+ }
+ });
+ }
+});
+
+jQuery.extend({
+ valHooks: {
+ option: {
+ get: function( elem ) {
+ // attributes.value is undefined in Blackberry 4.7 but
+ // uses .value. See #6932
+ var val = elem.attributes.value;
+ return !val || val.specified ? elem.value : elem.text;
+ }
+ },
+ select: {
+ get: function( elem ) {
+ var value, option,
+ options = elem.options,
+ index = elem.selectedIndex,
+ one = elem.type === "select-one" || index < 0,
+ values = one ? null : [],
+ max = one ? index + 1 : options.length,
+ i = index < 0 ?
+ max :
+ one ? index : 0;
+
+ // Loop through all the selected options
+ for ( ; i < max; i++ ) {
+ option = options[ i ];
+
+ // oldIE doesn't update selected after form reset (#2551)
+ if ( ( option.selected || i === index ) &&
+ // Don't return options that are disabled or in a disabled optgroup
+ ( jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null ) &&
+ ( !option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {
+
+ // Get the specific value for the option
+ value = jQuery( option ).val();
+
+ // We don't need an array for one selects
+ if ( one ) {
+ return value;
+ }
+
+ // Multi-Selects return an array
+ values.push( value );
+ }
+ }
+
+ return values;
+ },
+
+ set: function( elem, value ) {
+ var values = jQuery.makeArray( value );
+
+ jQuery(elem).find("option").each(function() {
+ this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
+ });
+
+ if ( !values.length ) {
+ elem.selectedIndex = -1;
+ }
+ return values;
+ }
+ }
+ },
+
+ // Unused in 1.8, left in so attrFn-stabbers won't die; remove in 1.9
+ attrFn: {},
+
+ attr: function( elem, name, value, pass ) {
+ var ret, hooks, notxml,
+ nType = elem.nodeType;
+
+ // don't get/set attributes on text, comment and attribute nodes
+ if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
+ return;
+ }
+
+ if ( pass && jQuery.isFunction( jQuery.fn[ name ] ) ) {
+ return jQuery( elem )[ name ]( value );
+ }
+
+ // Fallback to prop when attributes are not supported
+ if ( typeof elem.getAttribute === "undefined" ) {
+ return jQuery.prop( elem, name, value );
+ }
+
+ notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
+
+ // All attributes are lowercase
+ // Grab necessary hook if one is defined
+ if ( notxml ) {
+ name = name.toLowerCase();
+ hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
+ }
+
+ if ( value !== undefined ) {
+
+ if ( value === null ) {
+ jQuery.removeAttr( elem, name );
+ return;
+
+ } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
+ return ret;
+
+ } else {
+ elem.setAttribute( name, value + "" );
+ return value;
+ }
+
+ } else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
+ return ret;
+
+ } else {
+
+ ret = elem.getAttribute( name );
+
+ // Non-existent attributes return null, we normalize to undefined
+ return ret === null ?
+ undefined :
+ ret;
+ }
+ },
+
+ removeAttr: function( elem, value ) {
+ var propName, attrNames, name, isBool,
+ i = 0;
+
+ if ( value && elem.nodeType === 1 ) {
+
+ attrNames = value.split( core_rspace );
+
+ for ( ; i < attrNames.length; i++ ) {
+ name = attrNames[ i ];
+
+ if ( name ) {
+ propName = jQuery.propFix[ name ] || name;
+ isBool = rboolean.test( name );
+
+ // See #9699 for explanation of this approach (setting first, then removal)
+ // Do not do this for boolean attributes (see #10870)
+ if ( !isBool ) {
+ jQuery.attr( elem, name, "" );
+ }
+ elem.removeAttribute( getSetAttribute ? name : propName );
+
+ // Set corresponding property to false for boolean attributes
+ if ( isBool && propName in elem ) {
+ elem[ propName ] = false;
+ }
+ }
+ }
+ }
+ },
+
+ attrHooks: {
+ type: {
+ set: function( elem, value ) {
+ // We can't allow the type property to be changed (since it causes problems in IE)
+ if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
+ jQuery.error( "type property can't be changed" );
+ } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
+ // Setting the type on a radio button after the value resets the value in IE6-9
+ // Reset value to it's default in case type is set after value
+ // This is for element creation
+ var val = elem.value;
+ elem.setAttribute( "type", value );
+ if ( val ) {
+ elem.value = val;
+ }
+ return value;
+ }
+ }
+ },
+ // Use the value property for back compat
+ // Use the nodeHook for button elements in IE6/7 (#1954)
+ value: {
+ get: function( elem, name ) {
+ if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
+ return nodeHook.get( elem, name );
+ }
+ return name in elem ?
+ elem.value :
+ null;
+ },
+ set: function( elem, value, name ) {
+ if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
+ return nodeHook.set( elem, value, name );
+ }
+ // Does not return so that setAttribute is also used
+ elem.value = value;
+ }
+ }
+ },
+
+ propFix: {
+ tabindex: "tabIndex",
+ readonly: "readOnly",
+ "for": "htmlFor",
+ "class": "className",
+ maxlength: "maxLength",
+ cellspacing: "cellSpacing",
+ cellpadding: "cellPadding",
+ rowspan: "rowSpan",
+ colspan: "colSpan",
+ usemap: "useMap",
+ frameborder: "frameBorder",
+ contenteditable: "contentEditable"
+ },
+
+ prop: function( elem, name, value ) {
+ var ret, hooks, notxml,
+ nType = elem.nodeType;
+
+ // don't get/set properties on text, comment and attribute nodes
+ if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
+ return;
+ }
+
+ notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
+
+ if ( notxml ) {
+ // Fix name and attach hooks
+ name = jQuery.propFix[ name ] || name;
+ hooks = jQuery.propHooks[ name ];
+ }
+
+ if ( value !== undefined ) {
+ if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
+ return ret;
+
+ } else {
+ return ( elem[ name ] = value );
+ }
+
+ } else {
+ if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
+ return ret;
+
+ } else {
+ return elem[ name ];
+ }
+ }
+ },
+
+ propHooks: {
+ tabIndex: {
+ get: function( elem ) {
+ // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
+ // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
+ var attributeNode = elem.getAttributeNode("tabindex");
+
+ return attributeNode && attributeNode.specified ?
+ parseInt( attributeNode.value, 10 ) :
+ rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
+ 0 :
+ undefined;
+ }
+ }
+ }
+});
+
+// Hook for boolean attributes
+boolHook = {
+ get: function( elem, name ) {
+ // Align boolean attributes with corresponding properties
+ // Fall back to attribute presence where some booleans are not supported
+ var attrNode,
+ property = jQuery.prop( elem, name );
+ return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
+ name.toLowerCase() :
+ undefined;
+ },
+ set: function( elem, value, name ) {
+ var propName;
+ if ( value === false ) {
+ // Remove boolean attributes when set to false
+ jQuery.removeAttr( elem, name );
+ } else {
+ // value is true since we know at this point it's type boolean and not false
+ // Set boolean attributes to the same name and set the DOM property
+ propName = jQuery.propFix[ name ] || name;
+ if ( propName in elem ) {
+ // Only set the IDL specifically if it already exists on the element
+ elem[ propName ] = true;
+ }
+
+ elem.setAttribute( name, name.toLowerCase() );
+ }
+ return name;
+ }
+};
+
+// IE6/7 do not support getting/setting some attributes with get/setAttribute
+if ( !getSetAttribute ) {
+
+ fixSpecified = {
+ name: true,
+ id: true,
+ coords: true
+ };
+
+ // Use this for any attribute in IE6/7
+ // This fixes almost every IE6/7 issue
+ nodeHook = jQuery.valHooks.button = {
+ get: function( elem, name ) {
+ var ret;
+ ret = elem.getAttributeNode( name );
+ return ret && ( fixSpecified[ name ] ? ret.value !== "" : ret.specified ) ?
+ ret.value :
+ undefined;
+ },
+ set: function( elem, value, name ) {
+ // Set the existing or create a new attribute node
+ var ret = elem.getAttributeNode( name );
+ if ( !ret ) {
+ ret = document.createAttribute( name );
+ elem.setAttributeNode( ret );
+ }
+ return ( ret.value = value + "" );
+ }
+ };
+
+ // Set width and height to auto instead of 0 on empty string( Bug #8150 )
+ // This is for removals
+ jQuery.each([ "width", "height" ], function( i, name ) {
+ jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
+ set: function( elem, value ) {
+ if ( value === "" ) {
+ elem.setAttribute( name, "auto" );
+ return value;
+ }
+ }
+ });
+ });
+
+ // Set contenteditable to false on removals(#10429)
+ // Setting to empty string throws an error as an invalid value
+ jQuery.attrHooks.contenteditable = {
+ get: nodeHook.get,
+ set: function( elem, value, name ) {
+ if ( value === "" ) {
+ value = "false";
+ }
+ nodeHook.set( elem, value, name );
+ }
+ };
+}
+
+
+// Some attributes require a special call on IE
+if ( !jQuery.support.hrefNormalized ) {
+ jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
+ jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
+ get: function( elem ) {
+ var ret = elem.getAttribute( name, 2 );
+ return ret === null ? undefined : ret;
+ }
+ });
+ });
+}
+
+if ( !jQuery.support.style ) {
+ jQuery.attrHooks.style = {
+ get: function( elem ) {
+ // Return undefined in the case of empty string
+ // Normalize to lowercase since IE uppercases css property names
+ return elem.style.cssText.toLowerCase() || undefined;
+ },
+ set: function( elem, value ) {
+ return ( elem.style.cssText = value + "" );
+ }
+ };
+}
+
+// Safari mis-reports the default selected property of an option
+// Accessing the parent's selectedIndex property fixes it
+if ( !jQuery.support.optSelected ) {
+ jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
+ get: function( elem ) {
+ var parent = elem.parentNode;
+
+ if ( parent ) {
+ parent.selectedIndex;
+
+ // Make sure that it also works with optgroups, see #5701
+ if ( parent.parentNode ) {
+ parent.parentNode.selectedIndex;
+ }
+ }
+ return null;
+ }
+ });
+}
+
+// IE6/7 call enctype encoding
+if ( !jQuery.support.enctype ) {
+ jQuery.propFix.enctype = "encoding";
+}
+
+// Radios and checkboxes getter/setter
+if ( !jQuery.support.checkOn ) {
+ jQuery.each([ "radio", "checkbox" ], function() {
+ jQuery.valHooks[ this ] = {
+ get: function( elem ) {
+ // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
+ return elem.getAttribute("value") === null ? "on" : elem.value;
+ }
+ };
+ });
+}
+jQuery.each([ "radio", "checkbox" ], function() {
+ jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
+ set: function( elem, value ) {
+ if ( jQuery.isArray( value ) ) {
+ return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
+ }
+ }
+ });
+});
+var rformElems = /^(?:textarea|input|select)$/i,
+ rtypenamespace = /^([^\.]*|)(?:\.(.+)|)$/,
+ rhoverHack = /(?:^|\s)hover(\.\S+|)\b/,
+ rkeyEvent = /^key/,
+ rmouseEvent = /^(?:mouse|contextmenu)|click/,
+ rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
+ hoverHack = function( events ) {
+ return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" );
+ };
+
+/*
+ * Helper functions for managing events -- not part of the public interface.
+ * Props to Dean Edwards' addEvent library for many of the ideas.
+ */
+jQuery.event = {
+
+ add: function( elem, types, handler, data, selector ) {
+
+ var elemData, eventHandle, events,
+ t, tns, type, namespaces, handleObj,
+ handleObjIn, handlers, special;
+
+ // Don't attach events to noData or text/comment nodes (allow plain objects tho)
+ if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) {
+ return;
+ }
+
+ // Caller can pass in an object of custom data in lieu of the handler
+ if ( handler.handler ) {
+ handleObjIn = handler;
+ handler = handleObjIn.handler;
+ selector = handleObjIn.selector;
+ }
+
+ // Make sure that the handler has a unique ID, used to find/remove it later
+ if ( !handler.guid ) {
+ handler.guid = jQuery.guid++;
+ }
+
+ // Init the element's event structure and main handler, if this is the first
+ events = elemData.events;
+ if ( !events ) {
+ elemData.events = events = {};
+ }
+ eventHandle = elemData.handle;
+ if ( !eventHandle ) {
+ elemData.handle = eventHandle = function( e ) {
+ // Discard the second event of a jQuery.event.trigger() and
+ // when an event is called after a page has unloaded
+ return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
+ jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
+ undefined;
+ };
+ // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
+ eventHandle.elem = elem;
+ }
+
+ // Handle multiple events separated by a space
+ // jQuery(...).bind("mouseover mouseout", fn);
+ types = jQuery.trim( hoverHack(types) ).split( " " );
+ for ( t = 0; t < types.length; t++ ) {
+
+ tns = rtypenamespace.exec( types[t] ) || [];
+ type = tns[1];
+ namespaces = ( tns[2] || "" ).split( "." ).sort();
+
+ // If event changes its type, use the special event handlers for the changed type
+ special = jQuery.event.special[ type ] || {};
+
+ // If selector defined, determine special event api type, otherwise given type
+ type = ( selector ? special.delegateType : special.bindType ) || type;
+
+ // Update special based on newly reset type
+ special = jQuery.event.special[ type ] || {};
+
+ // handleObj is passed to all event handlers
+ handleObj = jQuery.extend({
+ type: type,
+ origType: tns[1],
+ data: data,
+ handler: handler,
+ guid: handler.guid,
+ selector: selector,
+ needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
+ namespace: namespaces.join(".")
+ }, handleObjIn );
+
+ // Init the event handler queue if we're the first
+ handlers = events[ type ];
+ if ( !handlers ) {
+ handlers = events[ type ] = [];
+ handlers.delegateCount = 0;
+
+ // Only use addEventListener/attachEvent if the special events handler returns false
+ if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
+ // Bind the global event handler to the element
+ if ( elem.addEventListener ) {
+ elem.addEventListener( type, eventHandle, false );
+
+ } else if ( elem.attachEvent ) {
+ elem.attachEvent( "on" + type, eventHandle );
+ }
+ }
+ }
+
+ if ( special.add ) {
+ special.add.call( elem, handleObj );
+
+ if ( !handleObj.handler.guid ) {
+ handleObj.handler.guid = handler.guid;
+ }
+ }
+
+ // Add to the element's handler list, delegates in front
+ if ( selector ) {
+ handlers.splice( handlers.delegateCount++, 0, handleObj );
+ } else {
+ handlers.push( handleObj );
+ }
+
+ // Keep track of which events have ever been used, for event optimization
+ jQuery.event.global[ type ] = true;
+ }
+
+ // Nullify elem to prevent memory leaks in IE
+ elem = null;
+ },
+
+ global: {},
+
+ // Detach an event or set of events from an element
+ remove: function( elem, types, handler, selector, mappedTypes ) {
+
+ var t, tns, type, origType, namespaces, origCount,
+ j, events, special, eventType, handleObj,
+ elemData = jQuery.hasData( elem ) && jQuery._data( elem );
+
+ if ( !elemData || !(events = elemData.events) ) {
+ return;
+ }
+
+ // Once for each type.namespace in types; type may be omitted
+ types = jQuery.trim( hoverHack( types || "" ) ).split(" ");
+ for ( t = 0; t < types.length; t++ ) {
+ tns = rtypenamespace.exec( types[t] ) || [];
+ type = origType = tns[1];
+ namespaces = tns[2];
+
+ // Unbind all events (on this namespace, if provided) for the element
+ if ( !type ) {
+ for ( type in events ) {
+ jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
+ }
+ continue;
+ }
+
+ special = jQuery.event.special[ type ] || {};
+ type = ( selector? special.delegateType : special.bindType ) || type;
+ eventType = events[ type ] || [];
+ origCount = eventType.length;
+ namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
+
+ // Remove matching events
+ for ( j = 0; j < eventType.length; j++ ) {
+ handleObj = eventType[ j ];
+
+ if ( ( mappedTypes || origType === handleObj.origType ) &&
+ ( !handler || handler.guid === handleObj.guid ) &&
+ ( !namespaces || namespaces.test( handleObj.namespace ) ) &&
+ ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
+ eventType.splice( j--, 1 );
+
+ if ( handleObj.selector ) {
+ eventType.delegateCount--;
+ }
+ if ( special.remove ) {
+ special.remove.call( elem, handleObj );
+ }
+ }
+ }
+
+ // Remove generic event handler if we removed something and no more handlers exist
+ // (avoids potential for endless recursion during removal of special event handlers)
+ if ( eventType.length === 0 && origCount !== eventType.length ) {
+ if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
+ jQuery.removeEvent( elem, type, elemData.handle );
+ }
+
+ delete events[ type ];
+ }
+ }
+
+ // Remove the expando if it's no longer used
+ if ( jQuery.isEmptyObject( events ) ) {
+ delete elemData.handle;
+
+ // removeData also checks for emptiness and clears the expando if empty
+ // so use it instead of delete
+ jQuery.removeData( elem, "events", true );
+ }
+ },
+
+ // Events that are safe to short-circuit if no handlers are attached.
+ // Native DOM events should not be added, they may have inline handlers.
+ customEvent: {
+ "getData": true,
+ "setData": true,
+ "changeData": true
+ },
+
+ trigger: function( event, data, elem, onlyHandlers ) {
+ // Don't do events on text and comment nodes
+ if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) {
+ return;
+ }
+
+ // Event object or event type
+ var cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType,
+ type = event.type || event,
+ namespaces = [];
+
+ // focus/blur morphs to focusin/out; ensure we're not firing them right now
+ if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
+ return;
+ }
+
+ if ( type.indexOf( "!" ) >= 0 ) {
+ // Exclusive events trigger only for the exact event (no namespaces)
+ type = type.slice(0, -1);
+ exclusive = true;
+ }
+
+ if ( type.indexOf( "." ) >= 0 ) {
+ // Namespaced trigger; create a regexp to match event type in handle()
+ namespaces = type.split(".");
+ type = namespaces.shift();
+ namespaces.sort();
+ }
+
+ if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
+ // No jQuery handlers for this event type, and it can't have inline handlers
+ return;
+ }
+
+ // Caller can pass in an Event, Object, or just an event type string
+ event = typeof event === "object" ?
+ // jQuery.Event object
+ event[ jQuery.expando ] ? event :
+ // Object literal
+ new jQuery.Event( type, event ) :
+ // Just the event type (string)
+ new jQuery.Event( type );
+
+ event.type = type;
+ event.isTrigger = true;
+ event.exclusive = exclusive;
+ event.namespace = namespaces.join( "." );
+ event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
+ ontype = type.indexOf( ":" ) < 0 ? "on" + type : "";
+
+ // Handle a global trigger
+ if ( !elem ) {
+
+ // TODO: Stop taunting the data cache; remove global events and always attach to document
+ cache = jQuery.cache;
+ for ( i in cache ) {
+ if ( cache[ i ].events && cache[ i ].events[ type ] ) {
+ jQuery.event.trigger( event, data, cache[ i ].handle.elem, true );
+ }
+ }
+ return;
+ }
+
+ // Clean up the event in case it is being reused
+ event.result = undefined;
+ if ( !event.target ) {
+ event.target = elem;
+ }
+
+ // Clone any incoming data and prepend the event, creating the handler arg list
+ data = data != null ? jQuery.makeArray( data ) : [];
+ data.unshift( event );
+
+ // Allow special events to draw outside the lines
+ special = jQuery.event.special[ type ] || {};
+ if ( special.trigger && special.trigger.apply( elem, data ) === false ) {
+ return;
+ }
+
+ // Determine event propagation path in advance, per W3C events spec (#9951)
+ // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
+ eventPath = [[ elem, special.bindType || type ]];
+ if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
+
+ bubbleType = special.delegateType || type;
+ cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode;
+ for ( old = elem; cur; cur = cur.parentNode ) {
+ eventPath.push([ cur, bubbleType ]);
+ old = cur;
+ }
+
+ // Only add window if we got to document (e.g., not plain obj or detached DOM)
+ if ( old === (elem.ownerDocument || document) ) {
+ eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]);
+ }
+ }
+
+ // Fire handlers on the event path
+ for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) {
+
+ cur = eventPath[i][0];
+ event.type = eventPath[i][1];
+
+ handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
+ if ( handle ) {
+ handle.apply( cur, data );
+ }
+ // Note that this is a bare JS function and not a jQuery handler
+ handle = ontype && cur[ ontype ];
+ if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === false ) {
+ event.preventDefault();
+ }
+ }
+ event.type = type;
+
+ // If nobody prevented the default action, do it now
+ if ( !onlyHandlers && !event.isDefaultPrevented() ) {
+
+ if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
+ !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
+
+ // Call a native DOM method on the target with the same name name as the event.
+ // Can't use an .isFunction() check here because IE6/7 fails that test.
+ // Don't do default actions on window, that's where global variables be (#6170)
+ // IE<9 dies on focus/blur to hidden element (#1486)
+ if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) {
+
+ // Don't re-trigger an onFOO event when we call its FOO() method
+ old = elem[ ontype ];
+
+ if ( old ) {
+ elem[ ontype ] = null;
+ }
+
+ // Prevent re-triggering of the same event, since we already bubbled it above
+ jQuery.event.triggered = type;
+ elem[ type ]();
+ jQuery.event.triggered = undefined;
+
+ if ( old ) {
+ elem[ ontype ] = old;
+ }
+ }
+ }
+ }
+
+ return event.result;
+ },
+
+ dispatch: function( event ) {
+
+ // Make a writable jQuery.Event from the native event object
+ event = jQuery.event.fix( event || window.event );
+
+ var i, j, cur, ret, selMatch, matched, matches, handleObj, sel, related,
+ handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []),
+ delegateCount = handlers.delegateCount,
+ args = core_slice.call( arguments ),
+ run_all = !event.exclusive && !event.namespace,
+ special = jQuery.event.special[ event.type ] || {},
+ handlerQueue = [];
+
+ // Use the fix-ed jQuery.Event rather than the (read-only) native event
+ args[0] = event;
+ event.delegateTarget = this;
+
+ // Call the preDispatch hook for the mapped type, and let it bail if desired
+ if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
+ return;
+ }
+
+ // Determine handlers that should run if there are delegated events
+ // Avoid non-left-click bubbling in Firefox (#3861)
+ if ( delegateCount && !(event.button && event.type === "click") ) {
+
+ for ( cur = event.target; cur != this; cur = cur.parentNode || this ) {
+
+ // Don't process clicks (ONLY) on disabled elements (#6911, #8165, #11382, #11764)
+ if ( cur.disabled !== true || event.type !== "click" ) {
+ selMatch = {};
+ matches = [];
+ for ( i = 0; i < delegateCount; i++ ) {
+ handleObj = handlers[ i ];
+ sel = handleObj.selector;
+
+ if ( selMatch[ sel ] === undefined ) {
+ selMatch[ sel ] = handleObj.needsContext ?
+ jQuery( sel, this ).index( cur ) >= 0 :
+ jQuery.find( sel, this, null, [ cur ] ).length;
+ }
+ if ( selMatch[ sel ] ) {
+ matches.push( handleObj );
+ }
+ }
+ if ( matches.length ) {
+ handlerQueue.push({ elem: cur, matches: matches });
+ }
+ }
+ }
+ }
+
+ // Add the remaining (directly-bound) handlers
+ if ( handlers.length > delegateCount ) {
+ handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) });
+ }
+
+ // Run delegates first; they may want to stop propagation beneath us
+ for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) {
+ matched = handlerQueue[ i ];
+ event.currentTarget = matched.elem;
+
+ for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) {
+ handleObj = matched.matches[ j ];
+
+ // Triggered event must either 1) be non-exclusive and have no namespace, or
+ // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
+ if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) {
+
+ event.data = handleObj.data;
+ event.handleObj = handleObj;
+
+ ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
+ .apply( matched.elem, args );
+
+ if ( ret !== undefined ) {
+ event.result = ret;
+ if ( ret === false ) {
+ event.preventDefault();
+ event.stopPropagation();
+ }
+ }
+ }
+ }
+ }
+
+ // Call the postDispatch hook for the mapped type
+ if ( special.postDispatch ) {
+ special.postDispatch.call( this, event );
+ }
+
+ return event.result;
+ },
+
+ // Includes some event props shared by KeyEvent and MouseEvent
+ // *** attrChange attrName relatedNode srcElement are not normalized, non-W3C, deprecated, will be removed in 1.8 ***
+ props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
+
+ fixHooks: {},
+
+ keyHooks: {
+ props: "char charCode key keyCode".split(" "),
+ filter: function( event, original ) {
+
+ // Add which for key events
+ if ( event.which == null ) {
+ event.which = original.charCode != null ? original.charCode : original.keyCode;
+ }
+
+ return event;
+ }
+ },
+
+ mouseHooks: {
+ props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
+ filter: function( event, original ) {
+ var eventDoc, doc, body,
+ button = original.button,
+ fromElement = original.fromElement;
+
+ // Calculate pageX/Y if missing and clientX/Y available
+ if ( event.pageX == null && original.clientX != null ) {
+ eventDoc = event.target.ownerDocument || document;
+ doc = eventDoc.documentElement;
+ body = eventDoc.body;
+
+ event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
+ event.pageY = original.clientY + ( doc && doc.scrollTop || body && body.scrollTop || 0 ) - ( doc && doc.clientTop || body && body.clientTop || 0 );
+ }
+
+ // Add relatedTarget, if necessary
+ if ( !event.relatedTarget && fromElement ) {
+ event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
+ }
+
+ // Add which for click: 1 === left; 2 === middle; 3 === right
+ // Note: button is not normalized, so don't use it
+ if ( !event.which && button !== undefined ) {
+ event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
+ }
+
+ return event;
+ }
+ },
+
+ fix: function( event ) {
+ if ( event[ jQuery.expando ] ) {
+ return event;
+ }
+
+ // Create a writable copy of the event object and normalize some properties
+ var i, prop,
+ originalEvent = event,
+ fixHook = jQuery.event.fixHooks[ event.type ] || {},
+ copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
+
+ event = jQuery.Event( originalEvent );
+
+ for ( i = copy.length; i; ) {
+ prop = copy[ --i ];
+ event[ prop ] = originalEvent[ prop ];
+ }
+
+ // Fix target property, if necessary (#1925, IE 6/7/8 & Safari2)
+ if ( !event.target ) {
+ event.target = originalEvent.srcElement || document;
+ }
+
+ // Target should not be a text node (#504, Safari)
+ if ( event.target.nodeType === 3 ) {
+ event.target = event.target.parentNode;
+ }
+
+ // For mouse/key events, metaKey==false if it's undefined (#3368, #11328; IE6/7/8)
+ event.metaKey = !!event.metaKey;
+
+ return fixHook.filter? fixHook.filter( event, originalEvent ) : event;
+ },
+
+ special: {
+ load: {
+ // Prevent triggered image.load events from bubbling to window.load
+ noBubble: true
+ },
+
+ focus: {
+ delegateType: "focusin"
+ },
+ blur: {
+ delegateType: "focusout"
+ },
+
+ beforeunload: {
+ setup: function( data, namespaces, eventHandle ) {
+ // We only want to do this special case on windows
+ if ( jQuery.isWindow( this ) ) {
+ this.onbeforeunload = eventHandle;
+ }
+ },
+
+ teardown: function( namespaces, eventHandle ) {
+ if ( this.onbeforeunload === eventHandle ) {
+ this.onbeforeunload = null;
+ }
+ }
+ }
+ },
+
+ simulate: function( type, elem, event, bubble ) {
+ // Piggyback on a donor event to simulate a different one.
+ // Fake originalEvent to avoid donor's stopPropagation, but if the
+ // simulated event prevents default then we do the same on the donor.
+ var e = jQuery.extend(
+ new jQuery.Event(),
+ event,
+ { type: type,
+ isSimulated: true,
+ originalEvent: {}
+ }
+ );
+ if ( bubble ) {
+ jQuery.event.trigger( e, null, elem );
+ } else {
+ jQuery.event.dispatch.call( elem, e );
+ }
+ if ( e.isDefaultPrevented() ) {
+ event.preventDefault();
+ }
+ }
+};
+
+// Some plugins are using, but it's undocumented/deprecated and will be removed.
+// The 1.7 special event interface should provide all the hooks needed now.
+jQuery.event.handle = jQuery.event.dispatch;
+
+jQuery.removeEvent = document.removeEventListener ?
+ function( elem, type, handle ) {
+ if ( elem.removeEventListener ) {
+ elem.removeEventListener( type, handle, false );
+ }
+ } :
+ function( elem, type, handle ) {
+ var name = "on" + type;
+
+ if ( elem.detachEvent ) {
+
+ // #8545, #7054, preventing memory leaks for custom events in IE6-8
+ // detachEvent needed property on element, by name of that event, to properly expose it to GC
+ if ( typeof elem[ name ] === "undefined" ) {
+ elem[ name ] = null;
+ }
+
+ elem.detachEvent( name, handle );
+ }
+ };
+
+jQuery.Event = function( src, props ) {
+ // Allow instantiation without the 'new' keyword
+ if ( !(this instanceof jQuery.Event) ) {
+ return new jQuery.Event( src, props );
+ }
+
+ // Event object
+ if ( src && src.type ) {
+ this.originalEvent = src;
+ this.type = src.type;
+
+ // Events bubbling up the document may have been marked as prevented
+ // by a handler lower down the tree; reflect the correct value.
+ this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
+ src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;
+
+ // Event type
+ } else {
+ this.type = src;
+ }
+
+ // Put explicitly provided properties onto the event object
+ if ( props ) {
+ jQuery.extend( this, props );
+ }
+
+ // Create a timestamp if incoming event doesn't have one
+ this.timeStamp = src && src.timeStamp || jQuery.now();
+
+ // Mark it as fixed
+ this[ jQuery.expando ] = true;
+};
+
+function returnFalse() {
+ return false;
+}
+function returnTrue() {
+ return true;
+}
+
+// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
+// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
+jQuery.Event.prototype = {
+ preventDefault: function() {
+ this.isDefaultPrevented = returnTrue;
+
+ var e = this.originalEvent;
+ if ( !e ) {
+ return;
+ }
+
+ // if preventDefault exists run it on the original event
+ if ( e.preventDefault ) {
+ e.preventDefault();
+
+ // otherwise set the returnValue property of the original event to false (IE)
+ } else {
+ e.returnValue = false;
+ }
+ },
+ stopPropagation: function() {
+ this.isPropagationStopped = returnTrue;
+
+ var e = this.originalEvent;
+ if ( !e ) {
+ return;
+ }
+ // if stopPropagation exists run it on the original event
+ if ( e.stopPropagation ) {
+ e.stopPropagation();
+ }
+ // otherwise set the cancelBubble property of the original event to true (IE)
+ e.cancelBubble = true;
+ },
+ stopImmediatePropagation: function() {
+ this.isImmediatePropagationStopped = returnTrue;
+ this.stopPropagation();
+ },
+ isDefaultPrevented: returnFalse,
+ isPropagationStopped: returnFalse,
+ isImmediatePropagationStopped: returnFalse
+};
+
+// Create mouseenter/leave events using mouseover/out and event-time checks
+jQuery.each({
+ mouseenter: "mouseover",
+ mouseleave: "mouseout"
+}, function( orig, fix ) {
+ jQuery.event.special[ orig ] = {
+ delegateType: fix,
+ bindType: fix,
+
+ handle: function( event ) {
+ var ret,
+ target = this,
+ related = event.relatedTarget,
+ handleObj = event.handleObj,
+ selector = handleObj.selector;
+
+ // For mousenter/leave call the handler if related is outside the target.
+ // NB: No relatedTarget if the mouse left/entered the browser window
+ if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
+ event.type = handleObj.origType;
+ ret = handleObj.handler.apply( this, arguments );
+ event.type = fix;
+ }
+ return ret;
+ }
+ };
+});
+
+// IE submit delegation
+if ( !jQuery.support.submitBubbles ) {
+
+ jQuery.event.special.submit = {
+ setup: function() {
+ // Only need this for delegated form submit events
+ if ( jQuery.nodeName( this, "form" ) ) {
+ return false;
+ }
+
+ // Lazy-add a submit handler when a descendant form may potentially be submitted
+ jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
+ // Node name check avoids a VML-related crash in IE (#9807)
+ var elem = e.target,
+ form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
+ if ( form && !jQuery._data( form, "_submit_attached" ) ) {
+ jQuery.event.add( form, "submit._submit", function( event ) {
+ event._submit_bubble = true;
+ });
+ jQuery._data( form, "_submit_attached", true );
+ }
+ });
+ // return undefined since we don't need an event listener
+ },
+
+ postDispatch: function( event ) {
+ // If form was submitted by the user, bubble the event up the tree
+ if ( event._submit_bubble ) {
+ delete event._submit_bubble;
+ if ( this.parentNode && !event.isTrigger ) {
+ jQuery.event.simulate( "submit", this.parentNode, event, true );
+ }
+ }
+ },
+
+ teardown: function() {
+ // Only need this for delegated form submit events
+ if ( jQuery.nodeName( this, "form" ) ) {
+ return false;
+ }
+
+ // Remove delegated handlers; cleanData eventually reaps submit handlers attached above
+ jQuery.event.remove( this, "._submit" );
+ }
+ };
+}
+
+// IE change delegation and checkbox/radio fix
+if ( !jQuery.support.changeBubbles ) {
+
+ jQuery.event.special.change = {
+
+ setup: function() {
+
+ if ( rformElems.test( this.nodeName ) ) {
+ // IE doesn't fire change on a check/radio until blur; trigger it on click
+ // after a propertychange. Eat the blur-change in special.change.handle.
+ // This still fires onchange a second time for check/radio after blur.
+ if ( this.type === "checkbox" || this.type === "radio" ) {
+ jQuery.event.add( this, "propertychange._change", function( event ) {
+ if ( event.originalEvent.propertyName === "checked" ) {
+ this._just_changed = true;
+ }
+ });
+ jQuery.event.add( this, "click._change", function( event ) {
+ if ( this._just_changed && !event.isTrigger ) {
+ this._just_changed = false;
+ }
+ // Allow triggered, simulated change events (#11500)
+ jQuery.event.simulate( "change", this, event, true );
+ });
+ }
+ return false;
+ }
+ // Delegated event; lazy-add a change handler on descendant inputs
+ jQuery.event.add( this, "beforeactivate._change", function( e ) {
+ var elem = e.target;
+
+ if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "_change_attached" ) ) {
+ jQuery.event.add( elem, "change._change", function( event ) {
+ if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
+ jQuery.event.simulate( "change", this.parentNode, event, true );
+ }
+ });
+ jQuery._data( elem, "_change_attached", true );
+ }
+ });
+ },
+
+ handle: function( event ) {
+ var elem = event.target;
+
+ // Swallow native change events from checkbox/radio, we already triggered them above
+ if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
+ return event.handleObj.handler.apply( this, arguments );
+ }
+ },
+
+ teardown: function() {
+ jQuery.event.remove( this, "._change" );
+
+ return !rformElems.test( this.nodeName );
+ }
+ };
+}
+
+// Create "bubbling" focus and blur events
+if ( !jQuery.support.focusinBubbles ) {
+ jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
+
+ // Attach a single capturing handler while someone wants focusin/focusout
+ var attaches = 0,
+ handler = function( event ) {
+ jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
+ };
+
+ jQuery.event.special[ fix ] = {
+ setup: function() {
+ if ( attaches++ === 0 ) {
+ document.addEventListener( orig, handler, true );
+ }
+ },
+ teardown: function() {
+ if ( --attaches === 0 ) {
+ document.removeEventListener( orig, handler, true );
+ }
+ }
+ };
+ });
+}
+
+jQuery.fn.extend({
+
+ on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
+ var origFn, type;
+
+ // Types can be a map of types/handlers
+ if ( typeof types === "object" ) {
+ // ( types-Object, selector, data )
+ if ( typeof selector !== "string" ) { // && selector != null
+ // ( types-Object, data )
+ data = data || selector;
+ selector = undefined;
+ }
+ for ( type in types ) {
+ this.on( type, selector, data, types[ type ], one );
+ }
+ return this;
+ }
+
+ if ( data == null && fn == null ) {
+ // ( types, fn )
+ fn = selector;
+ data = selector = undefined;
+ } else if ( fn == null ) {
+ if ( typeof selector === "string" ) {
+ // ( types, selector, fn )
+ fn = data;
+ data = undefined;
+ } else {
+ // ( types, data, fn )
+ fn = data;
+ data = selector;
+ selector = undefined;
+ }
+ }
+ if ( fn === false ) {
+ fn = returnFalse;
+ } else if ( !fn ) {
+ return this;
+ }
+
+ if ( one === 1 ) {
+ origFn = fn;
+ fn = function( event ) {
+ // Can use an empty set, since event contains the info
+ jQuery().off( event );
+ return origFn.apply( this, arguments );
+ };
+ // Use same guid so caller can remove using origFn
+ fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
+ }
+ return this.each( function() {
+ jQuery.event.add( this, types, fn, data, selector );
+ });
+ },
+ one: function( types, selector, data, fn ) {
+ return this.on( types, selector, data, fn, 1 );
+ },
+ off: function( types, selector, fn ) {
+ var handleObj, type;
+ if ( types && types.preventDefault && types.handleObj ) {
+ // ( event ) dispatched jQuery.Event
+ handleObj = types.handleObj;
+ jQuery( types.delegateTarget ).off(
+ handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
+ handleObj.selector,
+ handleObj.handler
+ );
+ return this;
+ }
+ if ( typeof types === "object" ) {
+ // ( types-object [, selector] )
+ for ( type in types ) {
+ this.off( type, selector, types[ type ] );
+ }
+ return this;
+ }
+ if ( selector === false || typeof selector === "function" ) {
+ // ( types [, fn] )
+ fn = selector;
+ selector = undefined;
+ }
+ if ( fn === false ) {
+ fn = returnFalse;
+ }
+ return this.each(function() {
+ jQuery.event.remove( this, types, fn, selector );
+ });
+ },
+
+ bind: function( types, data, fn ) {
+ return this.on( types, null, data, fn );
+ },
+ unbind: function( types, fn ) {
+ return this.off( types, null, fn );
+ },
+
+ live: function( types, data, fn ) {
+ jQuery( this.context ).on( types, this.selector, data, fn );
+ return this;
+ },
+ die: function( types, fn ) {
+ jQuery( this.context ).off( types, this.selector || "**", fn );
+ return this;
+ },
+
+ delegate: function( selector, types, data, fn ) {
+ return this.on( types, selector, data, fn );
+ },
+ undelegate: function( selector, types, fn ) {
+ // ( namespace ) or ( selector, types [, fn] )
+ return arguments.length === 1 ? this.off( selector, "**" ) : this.off( types, selector || "**", fn );
+ },
+
+ trigger: function( type, data ) {
+ return this.each(function() {
+ jQuery.event.trigger( type, data, this );
+ });
+ },
+ triggerHandler: function( type, data ) {
+ if ( this[0] ) {
+ return jQuery.event.trigger( type, data, this[0], true );
+ }
+ },
+
+ toggle: function( fn ) {
+ // Save reference to arguments for access in closure
+ var args = arguments,
+ guid = fn.guid || jQuery.guid++,
+ i = 0,
+ toggler = function( event ) {
+ // Figure out which function to execute
+ var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;
+ jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );
+
+ // Make sure that clicks stop
+ event.preventDefault();
+
+ // and execute the function
+ return args[ lastToggle ].apply( this, arguments ) || false;
+ };
+
+ // link all the functions, so any of them can unbind this click handler
+ toggler.guid = guid;
+ while ( i < args.length ) {
+ args[ i++ ].guid = guid;
+ }
+
+ return this.click( toggler );
+ },
+
+ hover: function( fnOver, fnOut ) {
+ return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
+ }
+});
+
+jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
+ "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
+ "change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
+
+ // Handle event binding
+ jQuery.fn[ name ] = function( data, fn ) {
+ if ( fn == null ) {
+ fn = data;
+ data = null;
+ }
+
+ return arguments.length > 0 ?
+ this.on( name, null, data, fn ) :
+ this.trigger( name );
+ };
+
+ if ( rkeyEvent.test( name ) ) {
+ jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks;
+ }
+
+ if ( rmouseEvent.test( name ) ) {
+ jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks;
+ }
+});
+/*!
+ * Sizzle CSS Selector Engine
+ * Copyright 2012 jQuery Foundation and other contributors
+ * Released under the MIT license
+ * http://sizzlejs.com/
+ */
+(function( window, undefined ) {
+
+var cachedruns,
+ assertGetIdNotName,
+ Expr,
+ getText,
+ isXML,
+ contains,
+ compile,
+ sortOrder,
+ hasDuplicate,
+ outermostContext,
+
+ baseHasDuplicate = true,
+ strundefined = "undefined",
+
+ expando = ( "sizcache" + Math.random() ).replace( ".", "" ),
+
+ Token = String,
+ document = window.document,
+ docElem = document.documentElement,
+ dirruns = 0,
+ done = 0,
+ pop = [].pop,
+ push = [].push,
+ slice = [].slice,
+ // Use a stripped-down indexOf if a native one is unavailable
+ indexOf = [].indexOf || function( elem ) {
+ var i = 0,
+ len = this.length;
+ for ( ; i < len; i++ ) {
+ if ( this[i] === elem ) {
+ return i;
+ }
+ }
+ return -1;
+ },
+
+ // Augment a function for special use by Sizzle
+ markFunction = function( fn, value ) {
+ fn[ expando ] = value == null || value;
+ return fn;
+ },
+
+ createCache = function() {
+ var cache = {},
+ keys = [];
+
+ return markFunction(function( key, value ) {
+ // Only keep the most recent entries
+ if ( keys.push( key ) > Expr.cacheLength ) {
+ delete cache[ keys.shift() ];
+ }
+
+ // Retrieve with (key + " ") to avoid collision with native Object.prototype properties (see Issue #157)
+ return (cache[ key + " " ] = value);
+ }, cache );
+ },
+
+ classCache = createCache(),
+ tokenCache = createCache(),
+ compilerCache = createCache(),
+
+ // Regex
+
+ // Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
+ whitespace = "[\\x20\\t\\r\\n\\f]",
+ // http://www.w3.org/TR/css3-syntax/#characters
+ characterEncoding = "(?:\\\\.|[-\\w]|[^\\x00-\\xa0])+",
+
+ // Loosely modeled on CSS identifier characters
+ // An unquoted value should be a CSS identifier (http://www.w3.org/TR/css3-selectors/#attribute-selectors)
+ // Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
+ identifier = characterEncoding.replace( "w", "w#" ),
+
+ // Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors
+ operators = "([*^$|!~]?=)",
+ attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace +
+ "*(?:" + operators + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]",
+
+ // Prefer arguments not in parens/brackets,
+ // then attribute selectors and non-pseudos (denoted by :),
+ // then anything else
+ // These preferences are here to reduce the number of selectors
+ // needing tokenize in the PSEUDO preFilter
+ pseudos = ":(" + characterEncoding + ")(?:\\((?:(['\"])((?:\\\\.|[^\\\\])*?)\\2|([^()[\\]]*|(?:(?:" + attributes + ")|[^:]|\\\\.)*|.*))\\)|)",
+
+ // For matchExpr.POS and matchExpr.needsContext
+ pos = ":(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
+ "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)",
+
+ // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
+ rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
+
+ rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
+ rcombinators = new RegExp( "^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*" ),
+ rpseudo = new RegExp( pseudos ),
+
+ // Easily-parseable/retrievable ID or TAG or CLASS selectors
+ rquickExpr = /^(?:#([\w\-]+)|(\w+)|\.([\w\-]+))$/,
+
+ rnot = /^:not/,
+ rsibling = /[\x20\t\r\n\f]*[+~]/,
+ rendsWithNot = /:not\($/,
+
+ rheader = /h\d/i,
+ rinputs = /input|select|textarea|button/i,
+
+ rbackslash = /\\(?!\\)/g,
+
+ matchExpr = {
+ "ID": new RegExp( "^#(" + characterEncoding + ")" ),
+ "CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
+ "NAME": new RegExp( "^\\[name=['\"]?(" + characterEncoding + ")['\"]?\\]" ),
+ "TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ),
+ "ATTR": new RegExp( "^" + attributes ),
+ "PSEUDO": new RegExp( "^" + pseudos ),
+ "POS": new RegExp( pos, "i" ),
+ "CHILD": new RegExp( "^:(only|nth|first|last)-child(?:\\(" + whitespace +
+ "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
+ "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
+ // For use in libraries implementing .is()
+ "needsContext": new RegExp( "^" + whitespace + "*[>+~]|" + pos, "i" )
+ },
+
+ // Support
+
+ // Used for testing something on an element
+ assert = function( fn ) {
+ var div = document.createElement("div");
+
+ try {
+ return fn( div );
+ } catch (e) {
+ return false;
+ } finally {
+ // release memory in IE
+ div = null;
+ }
+ },
+
+ // Check if getElementsByTagName("*") returns only elements
+ assertTagNameNoComments = assert(function( div ) {
+ div.appendChild( document.createComment("") );
+ return !div.getElementsByTagName("*").length;
+ }),
+
+ // Check if getAttribute returns normalized href attributes
+ assertHrefNotNormalized = assert(function( div ) {
+ div.innerHTML = "";
+ return div.firstChild && typeof div.firstChild.getAttribute !== strundefined &&
+ div.firstChild.getAttribute("href") === "#";
+ }),
+
+ // Check if attributes should be retrieved by attribute nodes
+ assertAttributes = assert(function( div ) {
+ div.innerHTML = "";
+ var type = typeof div.lastChild.getAttribute("multiple");
+ // IE8 returns a string for some attributes even when not present
+ return type !== "boolean" && type !== "string";
+ }),
+
+ // Check if getElementsByClassName can be trusted
+ assertUsableClassName = assert(function( div ) {
+ // Opera can't find a second classname (in 9.6)
+ div.innerHTML = "";
+ if ( !div.getElementsByClassName || !div.getElementsByClassName("e").length ) {
+ return false;
+ }
+
+ // Safari 3.2 caches class attributes and doesn't catch changes
+ div.lastChild.className = "e";
+ return div.getElementsByClassName("e").length === 2;
+ }),
+
+ // Check if getElementById returns elements by name
+ // Check if getElementsByName privileges form controls or returns elements by ID
+ assertUsableName = assert(function( div ) {
+ // Inject content
+ div.id = expando + 0;
+ div.innerHTML = "";
+ docElem.insertBefore( div, docElem.firstChild );
+
+ // Test
+ var pass = document.getElementsByName &&
+ // buggy browsers will return fewer than the correct 2
+ document.getElementsByName( expando ).length === 2 +
+ // buggy browsers will return more than the correct 0
+ document.getElementsByName( expando + 0 ).length;
+ assertGetIdNotName = !document.getElementById( expando );
+
+ // Cleanup
+ docElem.removeChild( div );
+
+ return pass;
+ });
+
+// If slice is not available, provide a backup
+try {
+ slice.call( docElem.childNodes, 0 )[0].nodeType;
+} catch ( e ) {
+ slice = function( i ) {
+ var elem,
+ results = [];
+ for ( ; (elem = this[i]); i++ ) {
+ results.push( elem );
+ }
+ return results;
+ };
+}
+
+function Sizzle( selector, context, results, seed ) {
+ results = results || [];
+ context = context || document;
+ var match, elem, xml, m,
+ nodeType = context.nodeType;
+
+ if ( !selector || typeof selector !== "string" ) {
+ return results;
+ }
+
+ if ( nodeType !== 1 && nodeType !== 9 ) {
+ return [];
+ }
+
+ xml = isXML( context );
+
+ if ( !xml && !seed ) {
+ if ( (match = rquickExpr.exec( selector )) ) {
+ // Speed-up: Sizzle("#ID")
+ if ( (m = match[1]) ) {
+ if ( nodeType === 9 ) {
+ elem = context.getElementById( m );
+ // Check parentNode to catch when Blackberry 4.6 returns
+ // nodes that are no longer in the document #6963
+ if ( elem && elem.parentNode ) {
+ // Handle the case where IE, Opera, and Webkit return items
+ // by name instead of ID
+ if ( elem.id === m ) {
+ results.push( elem );
+ return results;
+ }
+ } else {
+ return results;
+ }
+ } else {
+ // Context is not a document
+ if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
+ contains( context, elem ) && elem.id === m ) {
+ results.push( elem );
+ return results;
+ }
+ }
+
+ // Speed-up: Sizzle("TAG")
+ } else if ( match[2] ) {
+ push.apply( results, slice.call(context.getElementsByTagName( selector ), 0) );
+ return results;
+
+ // Speed-up: Sizzle(".CLASS")
+ } else if ( (m = match[3]) && assertUsableClassName && context.getElementsByClassName ) {
+ push.apply( results, slice.call(context.getElementsByClassName( m ), 0) );
+ return results;
+ }
+ }
+ }
+
+ // All others
+ return select( selector.replace( rtrim, "$1" ), context, results, seed, xml );
+}
+
+Sizzle.matches = function( expr, elements ) {
+ return Sizzle( expr, null, null, elements );
+};
+
+Sizzle.matchesSelector = function( elem, expr ) {
+ return Sizzle( expr, null, null, [ elem ] ).length > 0;
+};
+
+// Returns a function to use in pseudos for input types
+function createInputPseudo( type ) {
+ return function( elem ) {
+ var name = elem.nodeName.toLowerCase();
+ return name === "input" && elem.type === type;
+ };
+}
+
+// Returns a function to use in pseudos for buttons
+function createButtonPseudo( type ) {
+ return function( elem ) {
+ var name = elem.nodeName.toLowerCase();
+ return (name === "input" || name === "button") && elem.type === type;
+ };
+}
+
+// Returns a function to use in pseudos for positionals
+function createPositionalPseudo( fn ) {
+ return markFunction(function( argument ) {
+ argument = +argument;
+ return markFunction(function( seed, matches ) {
+ var j,
+ matchIndexes = fn( [], seed.length, argument ),
+ i = matchIndexes.length;
+
+ // Match elements found at the specified indexes
+ while ( i-- ) {
+ if ( seed[ (j = matchIndexes[i]) ] ) {
+ seed[j] = !(matches[j] = seed[j]);
+ }
+ }
+ });
+ });
+}
+
+/**
+ * Utility function for retrieving the text value of an array of DOM nodes
+ * @param {Array|Element} elem
+ */
+getText = Sizzle.getText = function( elem ) {
+ var node,
+ ret = "",
+ i = 0,
+ nodeType = elem.nodeType;
+
+ if ( nodeType ) {
+ if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
+ // Use textContent for elements
+ // innerText usage removed for consistency of new lines (see #11153)
+ if ( typeof elem.textContent === "string" ) {
+ return elem.textContent;
+ } else {
+ // Traverse its children
+ for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
+ ret += getText( elem );
+ }
+ }
+ } else if ( nodeType === 3 || nodeType === 4 ) {
+ return elem.nodeValue;
+ }
+ // Do not include comment or processing instruction nodes
+ } else {
+
+ // If no nodeType, this is expected to be an array
+ for ( ; (node = elem[i]); i++ ) {
+ // Do not traverse comment nodes
+ ret += getText( node );
+ }
+ }
+ return ret;
+};
+
+isXML = Sizzle.isXML = function( elem ) {
+ // documentElement is verified for cases where it doesn't yet exist
+ // (such as loading iframes in IE - #4833)
+ var documentElement = elem && (elem.ownerDocument || elem).documentElement;
+ return documentElement ? documentElement.nodeName !== "HTML" : false;
+};
+
+// Element contains another
+contains = Sizzle.contains = docElem.contains ?
+ function( a, b ) {
+ var adown = a.nodeType === 9 ? a.documentElement : a,
+ bup = b && b.parentNode;
+ return a === bup || !!( bup && bup.nodeType === 1 && adown.contains && adown.contains(bup) );
+ } :
+ docElem.compareDocumentPosition ?
+ function( a, b ) {
+ return b && !!( a.compareDocumentPosition( b ) & 16 );
+ } :
+ function( a, b ) {
+ while ( (b = b.parentNode) ) {
+ if ( b === a ) {
+ return true;
+ }
+ }
+ return false;
+ };
+
+Sizzle.attr = function( elem, name ) {
+ var val,
+ xml = isXML( elem );
+
+ if ( !xml ) {
+ name = name.toLowerCase();
+ }
+ if ( (val = Expr.attrHandle[ name ]) ) {
+ return val( elem );
+ }
+ if ( xml || assertAttributes ) {
+ return elem.getAttribute( name );
+ }
+ val = elem.getAttributeNode( name );
+ return val ?
+ typeof elem[ name ] === "boolean" ?
+ elem[ name ] ? name : null :
+ val.specified ? val.value : null :
+ null;
+};
+
+Expr = Sizzle.selectors = {
+
+ // Can be adjusted by the user
+ cacheLength: 50,
+
+ createPseudo: markFunction,
+
+ match: matchExpr,
+
+ // IE6/7 return a modified href
+ attrHandle: assertHrefNotNormalized ?
+ {} :
+ {
+ "href": function( elem ) {
+ return elem.getAttribute( "href", 2 );
+ },
+ "type": function( elem ) {
+ return elem.getAttribute("type");
+ }
+ },
+
+ find: {
+ "ID": assertGetIdNotName ?
+ function( id, context, xml ) {
+ if ( typeof context.getElementById !== strundefined && !xml ) {
+ var m = context.getElementById( id );
+ // Check parentNode to catch when Blackberry 4.6 returns
+ // nodes that are no longer in the document #6963
+ return m && m.parentNode ? [m] : [];
+ }
+ } :
+ function( id, context, xml ) {
+ if ( typeof context.getElementById !== strundefined && !xml ) {
+ var m = context.getElementById( id );
+
+ return m ?
+ m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode("id").value === id ?
+ [m] :
+ undefined :
+ [];
+ }
+ },
+
+ "TAG": assertTagNameNoComments ?
+ function( tag, context ) {
+ if ( typeof context.getElementsByTagName !== strundefined ) {
+ return context.getElementsByTagName( tag );
+ }
+ } :
+ function( tag, context ) {
+ var results = context.getElementsByTagName( tag );
+
+ // Filter out possible comments
+ if ( tag === "*" ) {
+ var elem,
+ tmp = [],
+ i = 0;
+
+ for ( ; (elem = results[i]); i++ ) {
+ if ( elem.nodeType === 1 ) {
+ tmp.push( elem );
+ }
+ }
+
+ return tmp;
+ }
+ return results;
+ },
+
+ "NAME": assertUsableName && function( tag, context ) {
+ if ( typeof context.getElementsByName !== strundefined ) {
+ return context.getElementsByName( name );
+ }
+ },
+
+ "CLASS": assertUsableClassName && function( className, context, xml ) {
+ if ( typeof context.getElementsByClassName !== strundefined && !xml ) {
+ return context.getElementsByClassName( className );
+ }
+ }
+ },
+
+ relative: {
+ ">": { dir: "parentNode", first: true },
+ " ": { dir: "parentNode" },
+ "+": { dir: "previousSibling", first: true },
+ "~": { dir: "previousSibling" }
+ },
+
+ preFilter: {
+ "ATTR": function( match ) {
+ match[1] = match[1].replace( rbackslash, "" );
+
+ // Move the given value to match[3] whether quoted or unquoted
+ match[3] = ( match[4] || match[5] || "" ).replace( rbackslash, "" );
+
+ if ( match[2] === "~=" ) {
+ match[3] = " " + match[3] + " ";
+ }
+
+ return match.slice( 0, 4 );
+ },
+
+ "CHILD": function( match ) {
+ /* matches from matchExpr["CHILD"]
+ 1 type (only|nth|...)
+ 2 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
+ 3 xn-component of xn+y argument ([+-]?\d*n|)
+ 4 sign of xn-component
+ 5 x of xn-component
+ 6 sign of y-component
+ 7 y of y-component
+ */
+ match[1] = match[1].toLowerCase();
+
+ if ( match[1] === "nth" ) {
+ // nth-child requires argument
+ if ( !match[2] ) {
+ Sizzle.error( match[0] );
+ }
+
+ // numeric x and y parameters for Expr.filter.CHILD
+ // remember that false/true cast respectively to 0/1
+ match[3] = +( match[3] ? match[4] + (match[5] || 1) : 2 * ( match[2] === "even" || match[2] === "odd" ) );
+ match[4] = +( ( match[6] + match[7] ) || match[2] === "odd" );
+
+ // other types prohibit arguments
+ } else if ( match[2] ) {
+ Sizzle.error( match[0] );
+ }
+
+ return match;
+ },
+
+ "PSEUDO": function( match ) {
+ var unquoted, excess;
+ if ( matchExpr["CHILD"].test( match[0] ) ) {
+ return null;
+ }
+
+ if ( match[3] ) {
+ match[2] = match[3];
+ } else if ( (unquoted = match[4]) ) {
+ // Only check arguments that contain a pseudo
+ if ( rpseudo.test(unquoted) &&
+ // Get excess from tokenize (recursively)
+ (excess = tokenize( unquoted, true )) &&
+ // advance to the next closing parenthesis
+ (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
+
+ // excess is a negative index
+ unquoted = unquoted.slice( 0, excess );
+ match[0] = match[0].slice( 0, excess );
+ }
+ match[2] = unquoted;
+ }
+
+ // Return only captures needed by the pseudo filter method (type and argument)
+ return match.slice( 0, 3 );
+ }
+ },
+
+ filter: {
+ "ID": assertGetIdNotName ?
+ function( id ) {
+ id = id.replace( rbackslash, "" );
+ return function( elem ) {
+ return elem.getAttribute("id") === id;
+ };
+ } :
+ function( id ) {
+ id = id.replace( rbackslash, "" );
+ return function( elem ) {
+ var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
+ return node && node.value === id;
+ };
+ },
+
+ "TAG": function( nodeName ) {
+ if ( nodeName === "*" ) {
+ return function() { return true; };
+ }
+ nodeName = nodeName.replace( rbackslash, "" ).toLowerCase();
+
+ return function( elem ) {
+ return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
+ };
+ },
+
+ "CLASS": function( className ) {
+ var pattern = classCache[ expando ][ className + " " ];
+
+ return pattern ||
+ (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
+ classCache( className, function( elem ) {
+ return pattern.test( elem.className || (typeof elem.getAttribute !== strundefined && elem.getAttribute("class")) || "" );
+ });
+ },
+
+ "ATTR": function( name, operator, check ) {
+ return function( elem, context ) {
+ var result = Sizzle.attr( elem, name );
+
+ if ( result == null ) {
+ return operator === "!=";
+ }
+ if ( !operator ) {
+ return true;
+ }
+
+ result += "";
+
+ return operator === "=" ? result === check :
+ operator === "!=" ? result !== check :
+ operator === "^=" ? check && result.indexOf( check ) === 0 :
+ operator === "*=" ? check && result.indexOf( check ) > -1 :
+ operator === "$=" ? check && result.substr( result.length - check.length ) === check :
+ operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
+ operator === "|=" ? result === check || result.substr( 0, check.length + 1 ) === check + "-" :
+ false;
+ };
+ },
+
+ "CHILD": function( type, argument, first, last ) {
+
+ if ( type === "nth" ) {
+ return function( elem ) {
+ var node, diff,
+ parent = elem.parentNode;
+
+ if ( first === 1 && last === 0 ) {
+ return true;
+ }
+
+ if ( parent ) {
+ diff = 0;
+ for ( node = parent.firstChild; node; node = node.nextSibling ) {
+ if ( node.nodeType === 1 ) {
+ diff++;
+ if ( elem === node ) {
+ break;
+ }
+ }
+ }
+ }
+
+ // Incorporate the offset (or cast to NaN), then check against cycle size
+ diff -= last;
+ return diff === first || ( diff % first === 0 && diff / first >= 0 );
+ };
+ }
+
+ return function( elem ) {
+ var node = elem;
+
+ switch ( type ) {
+ case "only":
+ case "first":
+ while ( (node = node.previousSibling) ) {
+ if ( node.nodeType === 1 ) {
+ return false;
+ }
+ }
+
+ if ( type === "first" ) {
+ return true;
+ }
+
+ node = elem;
+
+ /* falls through */
+ case "last":
+ while ( (node = node.nextSibling) ) {
+ if ( node.nodeType === 1 ) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+ };
+ },
+
+ "PSEUDO": function( pseudo, argument ) {
+ // pseudo-class names are case-insensitive
+ // http://www.w3.org/TR/selectors/#pseudo-classes
+ // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
+ // Remember that setFilters inherits from pseudos
+ var args,
+ fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
+ Sizzle.error( "unsupported pseudo: " + pseudo );
+
+ // The user may use createPseudo to indicate that
+ // arguments are needed to create the filter function
+ // just as Sizzle does
+ if ( fn[ expando ] ) {
+ return fn( argument );
+ }
+
+ // But maintain support for old signatures
+ if ( fn.length > 1 ) {
+ args = [ pseudo, pseudo, "", argument ];
+ return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
+ markFunction(function( seed, matches ) {
+ var idx,
+ matched = fn( seed, argument ),
+ i = matched.length;
+ while ( i-- ) {
+ idx = indexOf.call( seed, matched[i] );
+ seed[ idx ] = !( matches[ idx ] = matched[i] );
+ }
+ }) :
+ function( elem ) {
+ return fn( elem, 0, args );
+ };
+ }
+
+ return fn;
+ }
+ },
+
+ pseudos: {
+ "not": markFunction(function( selector ) {
+ // Trim the selector passed to compile
+ // to avoid treating leading and trailing
+ // spaces as combinators
+ var input = [],
+ results = [],
+ matcher = compile( selector.replace( rtrim, "$1" ) );
+
+ return matcher[ expando ] ?
+ markFunction(function( seed, matches, context, xml ) {
+ var elem,
+ unmatched = matcher( seed, null, xml, [] ),
+ i = seed.length;
+
+ // Match elements unmatched by `matcher`
+ while ( i-- ) {
+ if ( (elem = unmatched[i]) ) {
+ seed[i] = !(matches[i] = elem);
+ }
+ }
+ }) :
+ function( elem, context, xml ) {
+ input[0] = elem;
+ matcher( input, null, xml, results );
+ return !results.pop();
+ };
+ }),
+
+ "has": markFunction(function( selector ) {
+ return function( elem ) {
+ return Sizzle( selector, elem ).length > 0;
+ };
+ }),
+
+ "contains": markFunction(function( text ) {
+ return function( elem ) {
+ return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
+ };
+ }),
+
+ "enabled": function( elem ) {
+ return elem.disabled === false;
+ },
+
+ "disabled": function( elem ) {
+ return elem.disabled === true;
+ },
+
+ "checked": function( elem ) {
+ // In CSS3, :checked should return both checked and selected elements
+ // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
+ var nodeName = elem.nodeName.toLowerCase();
+ return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
+ },
+
+ "selected": function( elem ) {
+ // Accessing this property makes selected-by-default
+ // options in Safari work properly
+ if ( elem.parentNode ) {
+ elem.parentNode.selectedIndex;
+ }
+
+ return elem.selected === true;
+ },
+
+ "parent": function( elem ) {
+ return !Expr.pseudos["empty"]( elem );
+ },
+
+ "empty": function( elem ) {
+ // http://www.w3.org/TR/selectors/#empty-pseudo
+ // :empty is only affected by element nodes and content nodes(including text(3), cdata(4)),
+ // not comment, processing instructions, or others
+ // Thanks to Diego Perini for the nodeName shortcut
+ // Greater than "@" means alpha characters (specifically not starting with "#" or "?")
+ var nodeType;
+ elem = elem.firstChild;
+ while ( elem ) {
+ if ( elem.nodeName > "@" || (nodeType = elem.nodeType) === 3 || nodeType === 4 ) {
+ return false;
+ }
+ elem = elem.nextSibling;
+ }
+ return true;
+ },
+
+ "header": function( elem ) {
+ return rheader.test( elem.nodeName );
+ },
+
+ "text": function( elem ) {
+ var type, attr;
+ // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
+ // use getAttribute instead to test this case
+ return elem.nodeName.toLowerCase() === "input" &&
+ (type = elem.type) === "text" &&
+ ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === type );
+ },
+
+ // Input types
+ "radio": createInputPseudo("radio"),
+ "checkbox": createInputPseudo("checkbox"),
+ "file": createInputPseudo("file"),
+ "password": createInputPseudo("password"),
+ "image": createInputPseudo("image"),
+
+ "submit": createButtonPseudo("submit"),
+ "reset": createButtonPseudo("reset"),
+
+ "button": function( elem ) {
+ var name = elem.nodeName.toLowerCase();
+ return name === "input" && elem.type === "button" || name === "button";
+ },
+
+ "input": function( elem ) {
+ return rinputs.test( elem.nodeName );
+ },
+
+ "focus": function( elem ) {
+ var doc = elem.ownerDocument;
+ return elem === doc.activeElement && (!doc.hasFocus || doc.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
+ },
+
+ "active": function( elem ) {
+ return elem === elem.ownerDocument.activeElement;
+ },
+
+ // Positional types
+ "first": createPositionalPseudo(function() {
+ return [ 0 ];
+ }),
+
+ "last": createPositionalPseudo(function( matchIndexes, length ) {
+ return [ length - 1 ];
+ }),
+
+ "eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
+ return [ argument < 0 ? argument + length : argument ];
+ }),
+
+ "even": createPositionalPseudo(function( matchIndexes, length ) {
+ for ( var i = 0; i < length; i += 2 ) {
+ matchIndexes.push( i );
+ }
+ return matchIndexes;
+ }),
+
+ "odd": createPositionalPseudo(function( matchIndexes, length ) {
+ for ( var i = 1; i < length; i += 2 ) {
+ matchIndexes.push( i );
+ }
+ return matchIndexes;
+ }),
+
+ "lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
+ for ( var i = argument < 0 ? argument + length : argument; --i >= 0; ) {
+ matchIndexes.push( i );
+ }
+ return matchIndexes;
+ }),
+
+ "gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
+ for ( var i = argument < 0 ? argument + length : argument; ++i < length; ) {
+ matchIndexes.push( i );
+ }
+ return matchIndexes;
+ })
+ }
+};
+
+function siblingCheck( a, b, ret ) {
+ if ( a === b ) {
+ return ret;
+ }
+
+ var cur = a.nextSibling;
+
+ while ( cur ) {
+ if ( cur === b ) {
+ return -1;
+ }
+
+ cur = cur.nextSibling;
+ }
+
+ return 1;
+}
+
+sortOrder = docElem.compareDocumentPosition ?
+ function( a, b ) {
+ if ( a === b ) {
+ hasDuplicate = true;
+ return 0;
+ }
+
+ return ( !a.compareDocumentPosition || !b.compareDocumentPosition ?
+ a.compareDocumentPosition :
+ a.compareDocumentPosition(b) & 4
+ ) ? -1 : 1;
+ } :
+ function( a, b ) {
+ // The nodes are identical, we can exit early
+ if ( a === b ) {
+ hasDuplicate = true;
+ return 0;
+
+ // Fallback to using sourceIndex (in IE) if it's available on both nodes
+ } else if ( a.sourceIndex && b.sourceIndex ) {
+ return a.sourceIndex - b.sourceIndex;
+ }
+
+ var al, bl,
+ ap = [],
+ bp = [],
+ aup = a.parentNode,
+ bup = b.parentNode,
+ cur = aup;
+
+ // If the nodes are siblings (or identical) we can do a quick check
+ if ( aup === bup ) {
+ return siblingCheck( a, b );
+
+ // If no parents were found then the nodes are disconnected
+ } else if ( !aup ) {
+ return -1;
+
+ } else if ( !bup ) {
+ return 1;
+ }
+
+ // Otherwise they're somewhere else in the tree so we need
+ // to build up a full list of the parentNodes for comparison
+ while ( cur ) {
+ ap.unshift( cur );
+ cur = cur.parentNode;
+ }
+
+ cur = bup;
+
+ while ( cur ) {
+ bp.unshift( cur );
+ cur = cur.parentNode;
+ }
+
+ al = ap.length;
+ bl = bp.length;
+
+ // Start walking down the tree looking for a discrepancy
+ for ( var i = 0; i < al && i < bl; i++ ) {
+ if ( ap[i] !== bp[i] ) {
+ return siblingCheck( ap[i], bp[i] );
+ }
+ }
+
+ // We ended someplace up the tree so do a sibling check
+ return i === al ?
+ siblingCheck( a, bp[i], -1 ) :
+ siblingCheck( ap[i], b, 1 );
+ };
+
+// Always assume the presence of duplicates if sort doesn't
+// pass them to our comparison function (as in Google Chrome).
+[0, 0].sort( sortOrder );
+baseHasDuplicate = !hasDuplicate;
+
+// Document sorting and removing duplicates
+Sizzle.uniqueSort = function( results ) {
+ var elem,
+ duplicates = [],
+ i = 1,
+ j = 0;
+
+ hasDuplicate = baseHasDuplicate;
+ results.sort( sortOrder );
+
+ if ( hasDuplicate ) {
+ for ( ; (elem = results[i]); i++ ) {
+ if ( elem === results[ i - 1 ] ) {
+ j = duplicates.push( i );
+ }
+ }
+ while ( j-- ) {
+ results.splice( duplicates[ j ], 1 );
+ }
+ }
+
+ return results;
+};
+
+Sizzle.error = function( msg ) {
+ throw new Error( "Syntax error, unrecognized expression: " + msg );
+};
+
+function tokenize( selector, parseOnly ) {
+ var matched, match, tokens, type,
+ soFar, groups, preFilters,
+ cached = tokenCache[ expando ][ selector + " " ];
+
+ if ( cached ) {
+ return parseOnly ? 0 : cached.slice( 0 );
+ }
+
+ soFar = selector;
+ groups = [];
+ preFilters = Expr.preFilter;
+
+ while ( soFar ) {
+
+ // Comma and first run
+ if ( !matched || (match = rcomma.exec( soFar )) ) {
+ if ( match ) {
+ // Don't consume trailing commas as valid
+ soFar = soFar.slice( match[0].length ) || soFar;
+ }
+ groups.push( tokens = [] );
+ }
+
+ matched = false;
+
+ // Combinators
+ if ( (match = rcombinators.exec( soFar )) ) {
+ tokens.push( matched = new Token( match.shift() ) );
+ soFar = soFar.slice( matched.length );
+
+ // Cast descendant combinators to space
+ matched.type = match[0].replace( rtrim, " " );
+ }
+
+ // Filters
+ for ( type in Expr.filter ) {
+ if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
+ (match = preFilters[ type ]( match ))) ) {
+
+ tokens.push( matched = new Token( match.shift() ) );
+ soFar = soFar.slice( matched.length );
+ matched.type = type;
+ matched.matches = match;
+ }
+ }
+
+ if ( !matched ) {
+ break;
+ }
+ }
+
+ // Return the length of the invalid excess
+ // if we're just parsing
+ // Otherwise, throw an error or return tokens
+ return parseOnly ?
+ soFar.length :
+ soFar ?
+ Sizzle.error( selector ) :
+ // Cache the tokens
+ tokenCache( selector, groups ).slice( 0 );
+}
+
+function addCombinator( matcher, combinator, base ) {
+ var dir = combinator.dir,
+ checkNonElements = base && combinator.dir === "parentNode",
+ doneName = done++;
+
+ return combinator.first ?
+ // Check against closest ancestor/preceding element
+ function( elem, context, xml ) {
+ while ( (elem = elem[ dir ]) ) {
+ if ( checkNonElements || elem.nodeType === 1 ) {
+ return matcher( elem, context, xml );
+ }
+ }
+ } :
+
+ // Check against all ancestor/preceding elements
+ function( elem, context, xml ) {
+ // We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
+ if ( !xml ) {
+ var cache,
+ dirkey = dirruns + " " + doneName + " ",
+ cachedkey = dirkey + cachedruns;
+ while ( (elem = elem[ dir ]) ) {
+ if ( checkNonElements || elem.nodeType === 1 ) {
+ if ( (cache = elem[ expando ]) === cachedkey ) {
+ return elem.sizset;
+ } else if ( typeof cache === "string" && cache.indexOf(dirkey) === 0 ) {
+ if ( elem.sizset ) {
+ return elem;
+ }
+ } else {
+ elem[ expando ] = cachedkey;
+ if ( matcher( elem, context, xml ) ) {
+ elem.sizset = true;
+ return elem;
+ }
+ elem.sizset = false;
+ }
+ }
+ }
+ } else {
+ while ( (elem = elem[ dir ]) ) {
+ if ( checkNonElements || elem.nodeType === 1 ) {
+ if ( matcher( elem, context, xml ) ) {
+ return elem;
+ }
+ }
+ }
+ }
+ };
+}
+
+function elementMatcher( matchers ) {
+ return matchers.length > 1 ?
+ function( elem, context, xml ) {
+ var i = matchers.length;
+ while ( i-- ) {
+ if ( !matchers[i]( elem, context, xml ) ) {
+ return false;
+ }
+ }
+ return true;
+ } :
+ matchers[0];
+}
+
+function condense( unmatched, map, filter, context, xml ) {
+ var elem,
+ newUnmatched = [],
+ i = 0,
+ len = unmatched.length,
+ mapped = map != null;
+
+ for ( ; i < len; i++ ) {
+ if ( (elem = unmatched[i]) ) {
+ if ( !filter || filter( elem, context, xml ) ) {
+ newUnmatched.push( elem );
+ if ( mapped ) {
+ map.push( i );
+ }
+ }
+ }
+ }
+
+ return newUnmatched;
+}
+
+function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
+ if ( postFilter && !postFilter[ expando ] ) {
+ postFilter = setMatcher( postFilter );
+ }
+ if ( postFinder && !postFinder[ expando ] ) {
+ postFinder = setMatcher( postFinder, postSelector );
+ }
+ return markFunction(function( seed, results, context, xml ) {
+ var temp, i, elem,
+ preMap = [],
+ postMap = [],
+ preexisting = results.length,
+
+ // Get initial elements from seed or context
+ elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
+
+ // Prefilter to get matcher input, preserving a map for seed-results synchronization
+ matcherIn = preFilter && ( seed || !selector ) ?
+ condense( elems, preMap, preFilter, context, xml ) :
+ elems,
+
+ matcherOut = matcher ?
+ // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
+ postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
+
+ // ...intermediate processing is necessary
+ [] :
+
+ // ...otherwise use results directly
+ results :
+ matcherIn;
+
+ // Find primary matches
+ if ( matcher ) {
+ matcher( matcherIn, matcherOut, context, xml );
+ }
+
+ // Apply postFilter
+ if ( postFilter ) {
+ temp = condense( matcherOut, postMap );
+ postFilter( temp, [], context, xml );
+
+ // Un-match failing elements by moving them back to matcherIn
+ i = temp.length;
+ while ( i-- ) {
+ if ( (elem = temp[i]) ) {
+ matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
+ }
+ }
+ }
+
+ if ( seed ) {
+ if ( postFinder || preFilter ) {
+ if ( postFinder ) {
+ // Get the final matcherOut by condensing this intermediate into postFinder contexts
+ temp = [];
+ i = matcherOut.length;
+ while ( i-- ) {
+ if ( (elem = matcherOut[i]) ) {
+ // Restore matcherIn since elem is not yet a final match
+ temp.push( (matcherIn[i] = elem) );
+ }
+ }
+ postFinder( null, (matcherOut = []), temp, xml );
+ }
+
+ // Move matched elements from seed to results to keep them synchronized
+ i = matcherOut.length;
+ while ( i-- ) {
+ if ( (elem = matcherOut[i]) &&
+ (temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) {
+
+ seed[temp] = !(results[temp] = elem);
+ }
+ }
+ }
+
+ // Add elements to results, through postFinder if defined
+ } else {
+ matcherOut = condense(
+ matcherOut === results ?
+ matcherOut.splice( preexisting, matcherOut.length ) :
+ matcherOut
+ );
+ if ( postFinder ) {
+ postFinder( null, results, matcherOut, xml );
+ } else {
+ push.apply( results, matcherOut );
+ }
+ }
+ });
+}
+
+function matcherFromTokens( tokens ) {
+ var checkContext, matcher, j,
+ len = tokens.length,
+ leadingRelative = Expr.relative[ tokens[0].type ],
+ implicitRelative = leadingRelative || Expr.relative[" "],
+ i = leadingRelative ? 1 : 0,
+
+ // The foundational matcher ensures that elements are reachable from top-level context(s)
+ matchContext = addCombinator( function( elem ) {
+ return elem === checkContext;
+ }, implicitRelative, true ),
+ matchAnyContext = addCombinator( function( elem ) {
+ return indexOf.call( checkContext, elem ) > -1;
+ }, implicitRelative, true ),
+ matchers = [ function( elem, context, xml ) {
+ return ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
+ (checkContext = context).nodeType ?
+ matchContext( elem, context, xml ) :
+ matchAnyContext( elem, context, xml ) );
+ } ];
+
+ for ( ; i < len; i++ ) {
+ if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
+ matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
+ } else {
+ matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
+
+ // Return special upon seeing a positional matcher
+ if ( matcher[ expando ] ) {
+ // Find the next relative operator (if any) for proper handling
+ j = ++i;
+ for ( ; j < len; j++ ) {
+ if ( Expr.relative[ tokens[j].type ] ) {
+ break;
+ }
+ }
+ return setMatcher(
+ i > 1 && elementMatcher( matchers ),
+ i > 1 && tokens.slice( 0, i - 1 ).join("").replace( rtrim, "$1" ),
+ matcher,
+ i < j && matcherFromTokens( tokens.slice( i, j ) ),
+ j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
+ j < len && tokens.join("")
+ );
+ }
+ matchers.push( matcher );
+ }
+ }
+
+ return elementMatcher( matchers );
+}
+
+function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
+ var bySet = setMatchers.length > 0,
+ byElement = elementMatchers.length > 0,
+ superMatcher = function( seed, context, xml, results, expandContext ) {
+ var elem, j, matcher,
+ setMatched = [],
+ matchedCount = 0,
+ i = "0",
+ unmatched = seed && [],
+ outermost = expandContext != null,
+ contextBackup = outermostContext,
+ // We must always have either seed elements or context
+ elems = seed || byElement && Expr.find["TAG"]( "*", expandContext && context.parentNode || context ),
+ // Nested matchers should use non-integer dirruns
+ dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.E);
+
+ if ( outermost ) {
+ outermostContext = context !== document && context;
+ cachedruns = superMatcher.el;
+ }
+
+ // Add elements passing elementMatchers directly to results
+ for ( ; (elem = elems[i]) != null; i++ ) {
+ if ( byElement && elem ) {
+ for ( j = 0; (matcher = elementMatchers[j]); j++ ) {
+ if ( matcher( elem, context, xml ) ) {
+ results.push( elem );
+ break;
+ }
+ }
+ if ( outermost ) {
+ dirruns = dirrunsUnique;
+ cachedruns = ++superMatcher.el;
+ }
+ }
+
+ // Track unmatched elements for set filters
+ if ( bySet ) {
+ // They will have gone through all possible matchers
+ if ( (elem = !matcher && elem) ) {
+ matchedCount--;
+ }
+
+ // Lengthen the array for every element, matched or not
+ if ( seed ) {
+ unmatched.push( elem );
+ }
+ }
+ }
+
+ // Apply set filters to unmatched elements
+ matchedCount += i;
+ if ( bySet && i !== matchedCount ) {
+ for ( j = 0; (matcher = setMatchers[j]); j++ ) {
+ matcher( unmatched, setMatched, context, xml );
+ }
+
+ if ( seed ) {
+ // Reintegrate element matches to eliminate the need for sorting
+ if ( matchedCount > 0 ) {
+ while ( i-- ) {
+ if ( !(unmatched[i] || setMatched[i]) ) {
+ setMatched[i] = pop.call( results );
+ }
+ }
+ }
+
+ // Discard index placeholder values to get only actual matches
+ setMatched = condense( setMatched );
+ }
+
+ // Add matches to results
+ push.apply( results, setMatched );
+
+ // Seedless set matches succeeding multiple successful matchers stipulate sorting
+ if ( outermost && !seed && setMatched.length > 0 &&
+ ( matchedCount + setMatchers.length ) > 1 ) {
+
+ Sizzle.uniqueSort( results );
+ }
+ }
+
+ // Override manipulation of globals by nested matchers
+ if ( outermost ) {
+ dirruns = dirrunsUnique;
+ outermostContext = contextBackup;
+ }
+
+ return unmatched;
+ };
+
+ superMatcher.el = 0;
+ return bySet ?
+ markFunction( superMatcher ) :
+ superMatcher;
+}
+
+compile = Sizzle.compile = function( selector, group /* Internal Use Only */ ) {
+ var i,
+ setMatchers = [],
+ elementMatchers = [],
+ cached = compilerCache[ expando ][ selector + " " ];
+
+ if ( !cached ) {
+ // Generate a function of recursive functions that can be used to check each element
+ if ( !group ) {
+ group = tokenize( selector );
+ }
+ i = group.length;
+ while ( i-- ) {
+ cached = matcherFromTokens( group[i] );
+ if ( cached[ expando ] ) {
+ setMatchers.push( cached );
+ } else {
+ elementMatchers.push( cached );
+ }
+ }
+
+ // Cache the compiled function
+ cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
+ }
+ return cached;
+};
+
+function multipleContexts( selector, contexts, results ) {
+ var i = 0,
+ len = contexts.length;
+ for ( ; i < len; i++ ) {
+ Sizzle( selector, contexts[i], results );
+ }
+ return results;
+}
+
+function select( selector, context, results, seed, xml ) {
+ var i, tokens, token, type, find,
+ match = tokenize( selector ),
+ j = match.length;
+
+ if ( !seed ) {
+ // Try to minimize operations if there is only one group
+ if ( match.length === 1 ) {
+
+ // Take a shortcut and set the context if the root selector is an ID
+ tokens = match[0] = match[0].slice( 0 );
+ if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
+ context.nodeType === 9 && !xml &&
+ Expr.relative[ tokens[1].type ] ) {
+
+ context = Expr.find["ID"]( token.matches[0].replace( rbackslash, "" ), context, xml )[0];
+ if ( !context ) {
+ return results;
+ }
+
+ selector = selector.slice( tokens.shift().length );
+ }
+
+ // Fetch a seed set for right-to-left matching
+ for ( i = matchExpr["POS"].test( selector ) ? -1 : tokens.length - 1; i >= 0; i-- ) {
+ token = tokens[i];
+
+ // Abort if we hit a combinator
+ if ( Expr.relative[ (type = token.type) ] ) {
+ break;
+ }
+ if ( (find = Expr.find[ type ]) ) {
+ // Search, expanding context for leading sibling combinators
+ if ( (seed = find(
+ token.matches[0].replace( rbackslash, "" ),
+ rsibling.test( tokens[0].type ) && context.parentNode || context,
+ xml
+ )) ) {
+
+ // If seed is empty or no tokens remain, we can return early
+ tokens.splice( i, 1 );
+ selector = seed.length && tokens.join("");
+ if ( !selector ) {
+ push.apply( results, slice.call( seed, 0 ) );
+ return results;
+ }
+
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ // Compile and execute a filtering function
+ // Provide `match` to avoid retokenization if we modified the selector above
+ compile( selector, match )(
+ seed,
+ context,
+ xml,
+ results,
+ rsibling.test( selector )
+ );
+ return results;
+}
+
+if ( document.querySelectorAll ) {
+ (function() {
+ var disconnectedMatch,
+ oldSelect = select,
+ rescape = /'|\\/g,
+ rattributeQuotes = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g,
+
+ // qSa(:focus) reports false when true (Chrome 21), no need to also add to buggyMatches since matches checks buggyQSA
+ // A support test would require too much code (would include document ready)
+ rbuggyQSA = [ ":focus" ],
+
+ // matchesSelector(:active) reports false when true (IE9/Opera 11.5)
+ // A support test would require too much code (would include document ready)
+ // just skip matchesSelector for :active
+ rbuggyMatches = [ ":active" ],
+ matches = docElem.matchesSelector ||
+ docElem.mozMatchesSelector ||
+ docElem.webkitMatchesSelector ||
+ docElem.oMatchesSelector ||
+ docElem.msMatchesSelector;
+
+ // Build QSA regex
+ // Regex strategy adopted from Diego Perini
+ assert(function( div ) {
+ // Select is set to empty string on purpose
+ // This is to test IE's treatment of not explictly
+ // setting a boolean content attribute,
+ // since its presence should be enough
+ // http://bugs.jquery.com/ticket/12359
+ div.innerHTML = "";
+
+ // IE8 - Some boolean attributes are not treated correctly
+ if ( !div.querySelectorAll("[selected]").length ) {
+ rbuggyQSA.push( "\\[" + whitespace + "*(?:checked|disabled|ismap|multiple|readonly|selected|value)" );
+ }
+
+ // Webkit/Opera - :checked should return selected option elements
+ // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
+ // IE8 throws error here (do not put tests after this one)
+ if ( !div.querySelectorAll(":checked").length ) {
+ rbuggyQSA.push(":checked");
+ }
+ });
+
+ assert(function( div ) {
+
+ // Opera 10-12/IE9 - ^= $= *= and empty values
+ // Should not select anything
+ div.innerHTML = "";
+ if ( div.querySelectorAll("[test^='']").length ) {
+ rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:\"\"|'')" );
+ }
+
+ // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
+ // IE8 throws error here (do not put tests after this one)
+ div.innerHTML = "";
+ if ( !div.querySelectorAll(":enabled").length ) {
+ rbuggyQSA.push(":enabled", ":disabled");
+ }
+ });
+
+ // rbuggyQSA always contains :focus, so no need for a length check
+ rbuggyQSA = /* rbuggyQSA.length && */ new RegExp( rbuggyQSA.join("|") );
+
+ select = function( selector, context, results, seed, xml ) {
+ // Only use querySelectorAll when not filtering,
+ // when this is not xml,
+ // and when no QSA bugs apply
+ if ( !seed && !xml && !rbuggyQSA.test( selector ) ) {
+ var groups, i,
+ old = true,
+ nid = expando,
+ newContext = context,
+ newSelector = context.nodeType === 9 && selector;
+
+ // qSA works strangely on Element-rooted queries
+ // We can work around this by specifying an extra ID on the root
+ // and working up from there (Thanks to Andrew Dupont for the technique)
+ // IE 8 doesn't work on object elements
+ if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
+ groups = tokenize( selector );
+
+ if ( (old = context.getAttribute("id")) ) {
+ nid = old.replace( rescape, "\\$&" );
+ } else {
+ context.setAttribute( "id", nid );
+ }
+ nid = "[id='" + nid + "'] ";
+
+ i = groups.length;
+ while ( i-- ) {
+ groups[i] = nid + groups[i].join("");
+ }
+ newContext = rsibling.test( selector ) && context.parentNode || context;
+ newSelector = groups.join(",");
+ }
+
+ if ( newSelector ) {
+ try {
+ push.apply( results, slice.call( newContext.querySelectorAll(
+ newSelector
+ ), 0 ) );
+ return results;
+ } catch(qsaError) {
+ } finally {
+ if ( !old ) {
+ context.removeAttribute("id");
+ }
+ }
+ }
+ }
+
+ return oldSelect( selector, context, results, seed, xml );
+ };
+
+ if ( matches ) {
+ assert(function( div ) {
+ // Check to see if it's possible to do matchesSelector
+ // on a disconnected node (IE 9)
+ disconnectedMatch = matches.call( div, "div" );
+
+ // This should fail with an exception
+ // Gecko does not error, returns false instead
+ try {
+ matches.call( div, "[test!='']:sizzle" );
+ rbuggyMatches.push( "!=", pseudos );
+ } catch ( e ) {}
+ });
+
+ // rbuggyMatches always contains :active and :focus, so no need for a length check
+ rbuggyMatches = /* rbuggyMatches.length && */ new RegExp( rbuggyMatches.join("|") );
+
+ Sizzle.matchesSelector = function( elem, expr ) {
+ // Make sure that attribute selectors are quoted
+ expr = expr.replace( rattributeQuotes, "='$1']" );
+
+ // rbuggyMatches always contains :active, so no need for an existence check
+ if ( !isXML( elem ) && !rbuggyMatches.test( expr ) && !rbuggyQSA.test( expr ) ) {
+ try {
+ var ret = matches.call( elem, expr );
+
+ // IE 9's matchesSelector returns false on disconnected nodes
+ if ( ret || disconnectedMatch ||
+ // As well, disconnected nodes are said to be in a document
+ // fragment in IE 9
+ elem.document && elem.document.nodeType !== 11 ) {
+ return ret;
+ }
+ } catch(e) {}
+ }
+
+ return Sizzle( expr, null, null, [ elem ] ).length > 0;
+ };
+ }
+ })();
+}
+
+// Deprecated
+Expr.pseudos["nth"] = Expr.pseudos["eq"];
+
+// Back-compat
+function setFilters() {}
+Expr.filters = setFilters.prototype = Expr.pseudos;
+Expr.setFilters = new setFilters();
+
+// Override sizzle attribute retrieval
+Sizzle.attr = jQuery.attr;
+jQuery.find = Sizzle;
+jQuery.expr = Sizzle.selectors;
+jQuery.expr[":"] = jQuery.expr.pseudos;
+jQuery.unique = Sizzle.uniqueSort;
+jQuery.text = Sizzle.getText;
+jQuery.isXMLDoc = Sizzle.isXML;
+jQuery.contains = Sizzle.contains;
+
+
+})( window );
+var runtil = /Until$/,
+ rparentsprev = /^(?:parents|prev(?:Until|All))/,
+ isSimple = /^.[^:#\[\.,]*$/,
+ rneedsContext = jQuery.expr.match.needsContext,
+ // methods guaranteed to produce a unique set when starting from a unique set
+ guaranteedUnique = {
+ children: true,
+ contents: true,
+ next: true,
+ prev: true
+ };
+
+jQuery.fn.extend({
+ find: function( selector ) {
+ var i, l, length, n, r, ret,
+ self = this;
+
+ if ( typeof selector !== "string" ) {
+ return jQuery( selector ).filter(function() {
+ for ( i = 0, l = self.length; i < l; i++ ) {
+ if ( jQuery.contains( self[ i ], this ) ) {
+ return true;
+ }
+ }
+ });
+ }
+
+ ret = this.pushStack( "", "find", selector );
+
+ for ( i = 0, l = this.length; i < l; i++ ) {
+ length = ret.length;
+ jQuery.find( selector, this[i], ret );
+
+ if ( i > 0 ) {
+ // Make sure that the results are unique
+ for ( n = length; n < ret.length; n++ ) {
+ for ( r = 0; r < length; r++ ) {
+ if ( ret[r] === ret[n] ) {
+ ret.splice(n--, 1);
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ return ret;
+ },
+
+ has: function( target ) {
+ var i,
+ targets = jQuery( target, this ),
+ len = targets.length;
+
+ return this.filter(function() {
+ for ( i = 0; i < len; i++ ) {
+ if ( jQuery.contains( this, targets[i] ) ) {
+ return true;
+ }
+ }
+ });
+ },
+
+ not: function( selector ) {
+ return this.pushStack( winnow(this, selector, false), "not", selector);
+ },
+
+ filter: function( selector ) {
+ return this.pushStack( winnow(this, selector, true), "filter", selector );
+ },
+
+ is: function( selector ) {
+ return !!selector && (
+ typeof selector === "string" ?
+ // If this is a positional/relative selector, check membership in the returned set
+ // so $("p:first").is("p:last") won't return true for a doc with two "p".
+ rneedsContext.test( selector ) ?
+ jQuery( selector, this.context ).index( this[0] ) >= 0 :
+ jQuery.filter( selector, this ).length > 0 :
+ this.filter( selector ).length > 0 );
+ },
+
+ closest: function( selectors, context ) {
+ var cur,
+ i = 0,
+ l = this.length,
+ ret = [],
+ pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
+ jQuery( selectors, context || this.context ) :
+ 0;
+
+ for ( ; i < l; i++ ) {
+ cur = this[i];
+
+ while ( cur && cur.ownerDocument && cur !== context && cur.nodeType !== 11 ) {
+ if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
+ ret.push( cur );
+ break;
+ }
+ cur = cur.parentNode;
+ }
+ }
+
+ ret = ret.length > 1 ? jQuery.unique( ret ) : ret;
+
+ return this.pushStack( ret, "closest", selectors );
+ },
+
+ // Determine the position of an element within
+ // the matched set of elements
+ index: function( elem ) {
+
+ // No argument, return index in parent
+ if ( !elem ) {
+ return ( this[0] && this[0].parentNode ) ? this.prevAll().length : -1;
+ }
+
+ // index in selector
+ if ( typeof elem === "string" ) {
+ return jQuery.inArray( this[0], jQuery( elem ) );
+ }
+
+ // Locate the position of the desired element
+ return jQuery.inArray(
+ // If it receives a jQuery object, the first element is used
+ elem.jquery ? elem[0] : elem, this );
+ },
+
+ add: function( selector, context ) {
+ var set = typeof selector === "string" ?
+ jQuery( selector, context ) :
+ jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
+ all = jQuery.merge( this.get(), set );
+
+ return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
+ all :
+ jQuery.unique( all ) );
+ },
+
+ addBack: function( selector ) {
+ return this.add( selector == null ?
+ this.prevObject : this.prevObject.filter(selector)
+ );
+ }
+});
+
+jQuery.fn.andSelf = jQuery.fn.addBack;
+
+// A painfully simple check to see if an element is disconnected
+// from a document (should be improved, where feasible).
+function isDisconnected( node ) {
+ return !node || !node.parentNode || node.parentNode.nodeType === 11;
+}
+
+function sibling( cur, dir ) {
+ do {
+ cur = cur[ dir ];
+ } while ( cur && cur.nodeType !== 1 );
+
+ return cur;
+}
+
+jQuery.each({
+ parent: function( elem ) {
+ var parent = elem.parentNode;
+ return parent && parent.nodeType !== 11 ? parent : null;
+ },
+ parents: function( elem ) {
+ return jQuery.dir( elem, "parentNode" );
+ },
+ parentsUntil: function( elem, i, until ) {
+ return jQuery.dir( elem, "parentNode", until );
+ },
+ next: function( elem ) {
+ return sibling( elem, "nextSibling" );
+ },
+ prev: function( elem ) {
+ return sibling( elem, "previousSibling" );
+ },
+ nextAll: function( elem ) {
+ return jQuery.dir( elem, "nextSibling" );
+ },
+ prevAll: function( elem ) {
+ return jQuery.dir( elem, "previousSibling" );
+ },
+ nextUntil: function( elem, i, until ) {
+ return jQuery.dir( elem, "nextSibling", until );
+ },
+ prevUntil: function( elem, i, until ) {
+ return jQuery.dir( elem, "previousSibling", until );
+ },
+ siblings: function( elem ) {
+ return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );
+ },
+ children: function( elem ) {
+ return jQuery.sibling( elem.firstChild );
+ },
+ contents: function( elem ) {
+ return jQuery.nodeName( elem, "iframe" ) ?
+ elem.contentDocument || elem.contentWindow.document :
+ jQuery.merge( [], elem.childNodes );
+ }
+}, function( name, fn ) {
+ jQuery.fn[ name ] = function( until, selector ) {
+ var ret = jQuery.map( this, fn, until );
+
+ if ( !runtil.test( name ) ) {
+ selector = until;
+ }
+
+ if ( selector && typeof selector === "string" ) {
+ ret = jQuery.filter( selector, ret );
+ }
+
+ ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
+
+ if ( this.length > 1 && rparentsprev.test( name ) ) {
+ ret = ret.reverse();
+ }
+
+ return this.pushStack( ret, name, core_slice.call( arguments ).join(",") );
+ };
+});
+
+jQuery.extend({
+ filter: function( expr, elems, not ) {
+ if ( not ) {
+ expr = ":not(" + expr + ")";
+ }
+
+ return elems.length === 1 ?
+ jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
+ jQuery.find.matches(expr, elems);
+ },
+
+ dir: function( elem, dir, until ) {
+ var matched = [],
+ cur = elem[ dir ];
+
+ while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
+ if ( cur.nodeType === 1 ) {
+ matched.push( cur );
+ }
+ cur = cur[dir];
+ }
+ return matched;
+ },
+
+ sibling: function( n, elem ) {
+ var r = [];
+
+ for ( ; n; n = n.nextSibling ) {
+ if ( n.nodeType === 1 && n !== elem ) {
+ r.push( n );
+ }
+ }
+
+ return r;
+ }
+});
+
+// Implement the identical functionality for filter and not
+function winnow( elements, qualifier, keep ) {
+
+ // Can't pass null or undefined to indexOf in Firefox 4
+ // Set to 0 to skip string check
+ qualifier = qualifier || 0;
+
+ if ( jQuery.isFunction( qualifier ) ) {
+ return jQuery.grep(elements, function( elem, i ) {
+ var retVal = !!qualifier.call( elem, i, elem );
+ return retVal === keep;
+ });
+
+ } else if ( qualifier.nodeType ) {
+ return jQuery.grep(elements, function( elem, i ) {
+ return ( elem === qualifier ) === keep;
+ });
+
+ } else if ( typeof qualifier === "string" ) {
+ var filtered = jQuery.grep(elements, function( elem ) {
+ return elem.nodeType === 1;
+ });
+
+ if ( isSimple.test( qualifier ) ) {
+ return jQuery.filter(qualifier, filtered, !keep);
+ } else {
+ qualifier = jQuery.filter( qualifier, filtered );
+ }
+ }
+
+ return jQuery.grep(elements, function( elem, i ) {
+ return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep;
+ });
+}
+function createSafeFragment( document ) {
+ var list = nodeNames.split( "|" ),
+ safeFrag = document.createDocumentFragment();
+
+ if ( safeFrag.createElement ) {
+ while ( list.length ) {
+ safeFrag.createElement(
+ list.pop()
+ );
+ }
+ }
+ return safeFrag;
+}
+
+var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|" +
+ "header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",
+ rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g,
+ rleadingWhitespace = /^\s+/,
+ rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,
+ rtagName = /<([\w:]+)/,
+ rtbody = /]", "i"),
+ rcheckableType = /^(?:checkbox|radio)$/,
+ // checked="checked" or checked
+ rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
+ rscriptType = /\/(java|ecma)script/i,
+ rcleanScript = /^\s*\s*$/g,
+ wrapMap = {
+ option: [ 1, "" ],
+ legend: [ 1, "" ],
+ thead: [ 1, "
", "
" ],
+ tr: [ 2, "
", "
" ],
+ td: [ 3, "
", "
" ],
+ col: [ 2, "
", "
" ],
+ area: [ 1, "" ],
+ _default: [ 0, "", "" ]
+ },
+ safeFragment = createSafeFragment( document ),
+ fragmentDiv = safeFragment.appendChild( document.createElement("div") );
+
+wrapMap.optgroup = wrapMap.option;
+wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
+wrapMap.th = wrapMap.td;
+
+// IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
+// unless wrapped in a div with non-breaking characters in front of it.
+if ( !jQuery.support.htmlSerialize ) {
+ wrapMap._default = [ 1, "X
", "
" ];
+}
+
+jQuery.fn.extend({
+ text: function( value ) {
+ return jQuery.access( this, function( value ) {
+ return value === undefined ?
+ jQuery.text( this ) :
+ this.empty().append( ( this[0] && this[0].ownerDocument || document ).createTextNode( value ) );
+ }, null, value, arguments.length );
+ },
+
+ wrapAll: function( html ) {
+ if ( jQuery.isFunction( html ) ) {
+ return this.each(function(i) {
+ jQuery(this).wrapAll( html.call(this, i) );
+ });
+ }
+
+ if ( this[0] ) {
+ // The elements to wrap the target around
+ var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
+
+ if ( this[0].parentNode ) {
+ wrap.insertBefore( this[0] );
+ }
+
+ wrap.map(function() {
+ var elem = this;
+
+ while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
+ elem = elem.firstChild;
+ }
+
+ return elem;
+ }).append( this );
+ }
+
+ return this;
+ },
+
+ wrapInner: function( html ) {
+ if ( jQuery.isFunction( html ) ) {
+ return this.each(function(i) {
+ jQuery(this).wrapInner( html.call(this, i) );
+ });
+ }
+
+ return this.each(function() {
+ var self = jQuery( this ),
+ contents = self.contents();
+
+ if ( contents.length ) {
+ contents.wrapAll( html );
+
+ } else {
+ self.append( html );
+ }
+ });
+ },
+
+ wrap: function( html ) {
+ var isFunction = jQuery.isFunction( html );
+
+ return this.each(function(i) {
+ jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html );
+ });
+ },
+
+ unwrap: function() {
+ return this.parent().each(function() {
+ if ( !jQuery.nodeName( this, "body" ) ) {
+ jQuery( this ).replaceWith( this.childNodes );
+ }
+ }).end();
+ },
+
+ append: function() {
+ return this.domManip(arguments, true, function( elem ) {
+ if ( this.nodeType === 1 || this.nodeType === 11 ) {
+ this.appendChild( elem );
+ }
+ });
+ },
+
+ prepend: function() {
+ return this.domManip(arguments, true, function( elem ) {
+ if ( this.nodeType === 1 || this.nodeType === 11 ) {
+ this.insertBefore( elem, this.firstChild );
+ }
+ });
+ },
+
+ before: function() {
+ if ( !isDisconnected( this[0] ) ) {
+ return this.domManip(arguments, false, function( elem ) {
+ this.parentNode.insertBefore( elem, this );
+ });
+ }
+
+ if ( arguments.length ) {
+ var set = jQuery.clean( arguments );
+ return this.pushStack( jQuery.merge( set, this ), "before", this.selector );
+ }
+ },
+
+ after: function() {
+ if ( !isDisconnected( this[0] ) ) {
+ return this.domManip(arguments, false, function( elem ) {
+ this.parentNode.insertBefore( elem, this.nextSibling );
+ });
+ }
+
+ if ( arguments.length ) {
+ var set = jQuery.clean( arguments );
+ return this.pushStack( jQuery.merge( this, set ), "after", this.selector );
+ }
+ },
+
+ // keepData is for internal use only--do not document
+ remove: function( selector, keepData ) {
+ var elem,
+ i = 0;
+
+ for ( ; (elem = this[i]) != null; i++ ) {
+ if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
+ if ( !keepData && elem.nodeType === 1 ) {
+ jQuery.cleanData( elem.getElementsByTagName("*") );
+ jQuery.cleanData( [ elem ] );
+ }
+
+ if ( elem.parentNode ) {
+ elem.parentNode.removeChild( elem );
+ }
+ }
+ }
+
+ return this;
+ },
+
+ empty: function() {
+ var elem,
+ i = 0;
+
+ for ( ; (elem = this[i]) != null; i++ ) {
+ // Remove element nodes and prevent memory leaks
+ if ( elem.nodeType === 1 ) {
+ jQuery.cleanData( elem.getElementsByTagName("*") );
+ }
+
+ // Remove any remaining nodes
+ while ( elem.firstChild ) {
+ elem.removeChild( elem.firstChild );
+ }
+ }
+
+ return this;
+ },
+
+ clone: function( dataAndEvents, deepDataAndEvents ) {
+ dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
+ deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
+
+ return this.map( function () {
+ return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
+ });
+ },
+
+ html: function( value ) {
+ return jQuery.access( this, function( value ) {
+ var elem = this[0] || {},
+ i = 0,
+ l = this.length;
+
+ if ( value === undefined ) {
+ return elem.nodeType === 1 ?
+ elem.innerHTML.replace( rinlinejQuery, "" ) :
+ undefined;
+ }
+
+ // See if we can take a shortcut and just use innerHTML
+ if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
+ ( jQuery.support.htmlSerialize || !rnoshimcache.test( value ) ) &&
+ ( jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value ) ) &&
+ !wrapMap[ ( rtagName.exec( value ) || ["", ""] )[1].toLowerCase() ] ) {
+
+ value = value.replace( rxhtmlTag, "<$1>$2>" );
+
+ try {
+ for (; i < l; i++ ) {
+ // Remove element nodes and prevent memory leaks
+ elem = this[i] || {};
+ if ( elem.nodeType === 1 ) {
+ jQuery.cleanData( elem.getElementsByTagName( "*" ) );
+ elem.innerHTML = value;
+ }
+ }
+
+ elem = 0;
+
+ // If using innerHTML throws an exception, use the fallback method
+ } catch(e) {}
+ }
+
+ if ( elem ) {
+ this.empty().append( value );
+ }
+ }, null, value, arguments.length );
+ },
+
+ replaceWith: function( value ) {
+ if ( !isDisconnected( this[0] ) ) {
+ // Make sure that the elements are removed from the DOM before they are inserted
+ // this can help fix replacing a parent with child elements
+ if ( jQuery.isFunction( value ) ) {
+ return this.each(function(i) {
+ var self = jQuery(this), old = self.html();
+ self.replaceWith( value.call( this, i, old ) );
+ });
+ }
+
+ if ( typeof value !== "string" ) {
+ value = jQuery( value ).detach();
+ }
+
+ return this.each(function() {
+ var next = this.nextSibling,
+ parent = this.parentNode;
+
+ jQuery( this ).remove();
+
+ if ( next ) {
+ jQuery(next).before( value );
+ } else {
+ jQuery(parent).append( value );
+ }
+ });
+ }
+
+ return this.length ?
+ this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
+ this;
+ },
+
+ detach: function( selector ) {
+ return this.remove( selector, true );
+ },
+
+ domManip: function( args, table, callback ) {
+
+ // Flatten any nested arrays
+ args = [].concat.apply( [], args );
+
+ var results, first, fragment, iNoClone,
+ i = 0,
+ value = args[0],
+ scripts = [],
+ l = this.length;
+
+ // We can't cloneNode fragments that contain checked, in WebKit
+ if ( !jQuery.support.checkClone && l > 1 && typeof value === "string" && rchecked.test( value ) ) {
+ return this.each(function() {
+ jQuery(this).domManip( args, table, callback );
+ });
+ }
+
+ if ( jQuery.isFunction(value) ) {
+ return this.each(function(i) {
+ var self = jQuery(this);
+ args[0] = value.call( this, i, table ? self.html() : undefined );
+ self.domManip( args, table, callback );
+ });
+ }
+
+ if ( this[0] ) {
+ results = jQuery.buildFragment( args, this, scripts );
+ fragment = results.fragment;
+ first = fragment.firstChild;
+
+ if ( fragment.childNodes.length === 1 ) {
+ fragment = first;
+ }
+
+ if ( first ) {
+ table = table && jQuery.nodeName( first, "tr" );
+
+ // Use the original fragment for the last item instead of the first because it can end up
+ // being emptied incorrectly in certain situations (#8070).
+ // Fragments from the fragment cache must always be cloned and never used in place.
+ for ( iNoClone = results.cacheable || l - 1; i < l; i++ ) {
+ callback.call(
+ table && jQuery.nodeName( this[i], "table" ) ?
+ findOrAppend( this[i], "tbody" ) :
+ this[i],
+ i === iNoClone ?
+ fragment :
+ jQuery.clone( fragment, true, true )
+ );
+ }
+ }
+
+ // Fix #11809: Avoid leaking memory
+ fragment = first = null;
+
+ if ( scripts.length ) {
+ jQuery.each( scripts, function( i, elem ) {
+ if ( elem.src ) {
+ if ( jQuery.ajax ) {
+ jQuery.ajax({
+ url: elem.src,
+ type: "GET",
+ dataType: "script",
+ async: false,
+ global: false,
+ "throws": true
+ });
+ } else {
+ jQuery.error("no ajax");
+ }
+ } else {
+ jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "" ) );
+ }
+
+ if ( elem.parentNode ) {
+ elem.parentNode.removeChild( elem );
+ }
+ });
+ }
+ }
+
+ return this;
+ }
+});
+
+function findOrAppend( elem, tag ) {
+ return elem.getElementsByTagName( tag )[0] || elem.appendChild( elem.ownerDocument.createElement( tag ) );
+}
+
+function cloneCopyEvent( src, dest ) {
+
+ if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
+ return;
+ }
+
+ var type, i, l,
+ oldData = jQuery._data( src ),
+ curData = jQuery._data( dest, oldData ),
+ events = oldData.events;
+
+ if ( events ) {
+ delete curData.handle;
+ curData.events = {};
+
+ for ( type in events ) {
+ for ( i = 0, l = events[ type ].length; i < l; i++ ) {
+ jQuery.event.add( dest, type, events[ type ][ i ] );
+ }
+ }
+ }
+
+ // make the cloned public data object a copy from the original
+ if ( curData.data ) {
+ curData.data = jQuery.extend( {}, curData.data );
+ }
+}
+
+function cloneFixAttributes( src, dest ) {
+ var nodeName;
+
+ // We do not need to do anything for non-Elements
+ if ( dest.nodeType !== 1 ) {
+ return;
+ }
+
+ // clearAttributes removes the attributes, which we don't want,
+ // but also removes the attachEvent events, which we *do* want
+ if ( dest.clearAttributes ) {
+ dest.clearAttributes();
+ }
+
+ // mergeAttributes, in contrast, only merges back on the
+ // original attributes, not the events
+ if ( dest.mergeAttributes ) {
+ dest.mergeAttributes( src );
+ }
+
+ nodeName = dest.nodeName.toLowerCase();
+
+ if ( nodeName === "object" ) {
+ // IE6-10 improperly clones children of object elements using classid.
+ // IE10 throws NoModificationAllowedError if parent is null, #12132.
+ if ( dest.parentNode ) {
+ dest.outerHTML = src.outerHTML;
+ }
+
+ // This path appears unavoidable for IE9. When cloning an object
+ // element in IE9, the outerHTML strategy above is not sufficient.
+ // If the src has innerHTML and the destination does not,
+ // copy the src.innerHTML into the dest.innerHTML. #10324
+ if ( jQuery.support.html5Clone && (src.innerHTML && !jQuery.trim(dest.innerHTML)) ) {
+ dest.innerHTML = src.innerHTML;
+ }
+
+ } else if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
+ // IE6-8 fails to persist the checked state of a cloned checkbox
+ // or radio button. Worse, IE6-7 fail to give the cloned element
+ // a checked appearance if the defaultChecked value isn't also set
+
+ dest.defaultChecked = dest.checked = src.checked;
+
+ // IE6-7 get confused and end up setting the value of a cloned
+ // checkbox/radio button to an empty string instead of "on"
+ if ( dest.value !== src.value ) {
+ dest.value = src.value;
+ }
+
+ // IE6-8 fails to return the selected option to the default selected
+ // state when cloning options
+ } else if ( nodeName === "option" ) {
+ dest.selected = src.defaultSelected;
+
+ // IE6-8 fails to set the defaultValue to the correct value when
+ // cloning other types of input fields
+ } else if ( nodeName === "input" || nodeName === "textarea" ) {
+ dest.defaultValue = src.defaultValue;
+
+ // IE blanks contents when cloning scripts
+ } else if ( nodeName === "script" && dest.text !== src.text ) {
+ dest.text = src.text;
+ }
+
+ // Event data gets referenced instead of copied if the expando
+ // gets copied too
+ dest.removeAttribute( jQuery.expando );
+}
+
+jQuery.buildFragment = function( args, context, scripts ) {
+ var fragment, cacheable, cachehit,
+ first = args[ 0 ];
+
+ // Set context from what may come in as undefined or a jQuery collection or a node
+ // Updated to fix #12266 where accessing context[0] could throw an exception in IE9/10 &
+ // also doubles as fix for #8950 where plain objects caused createDocumentFragment exception
+ context = context || document;
+ context = !context.nodeType && context[0] || context;
+ context = context.ownerDocument || context;
+
+ // Only cache "small" (1/2 KB) HTML strings that are associated with the main document
+ // Cloning options loses the selected state, so don't cache them
+ // IE 6 doesn't like it when you put