fabric-rails 1.0.12 → 1.0.12.1

data/vendor/assets/javascripts/fabric/polygon.class.js

@@ -0,0 +1,184 @@
+(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
+     * @param {Boolean} Whether points offsetting should be skipped
+     * @return {fabric.Polygon} thisArg
+     */
+    initialize: function(points, options, skipOffset) {
+      options = options || { };
+      this.points = points;
+      this.callSuper('initialize', options);
+      this._calcDimensions(skipOffset);
+    },
+
+    /**
+     * @private
+     * @method _calcDimensions
+     */
+    _calcDimensions: function(skipOffset) {
+
+      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;
+
+      if (skipOffset) return;
+
+      var halfWidth = this.width / 2,
+          halfHeight = this.height / 2;
+
+      // change points to offset polygon into a bounding box
+      this.points.forEach(function(p) {
+        p.x -= halfWidth;
+        p.y -= halfHeight;
+      }, this);
+    },
+
+    /**
+     * 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 [
+        '<polygon ',
+          'points="', points.join(''), '" ',
+          'style="', this.getSvgStyles(), '" ',
+          'transform="', this.getSvgTransform(), '" ',
+        '/>'
+      ].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();
+      }
+      this._removeShadow(ctx);
+      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), true);
+  };
+
+  /**
+   * 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, true);
+  };
+
+})(typeof exports !== 'undefined' ? exports : this);

data/vendor/assets/javascripts/fabric/polyline.class.js

@@ -0,0 +1,157 @@
+(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
+     * @param {Boolean} Whether points offsetting should be skipped
+     * @return {Object} thisArg
+     */
+    initialize: function(points, options, skipOffset) {
+      options = options || { };
+      this.set('points', points);
+      this.callSuper('initialize', options);
+      this._calcDimensions(skipOffset);
+    },
+
+    /**
+     * @private
+     * @method _calcDimensions
+     */
+    _calcDimensions: function(skipOffset) {
+      return fabric.Polygon.prototype._calcDimensions.call(this, skipOffset);
+    },
+
+    /**
+     * 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 [
+        '<polyline ',
+          'points="', points.join(''), '" ',
+          'style="', this.getSvgStyles(), '" ',
+          'transform="', this.getSvgTransform(), '" ',
+        '/>'
+      ].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();
+      }
+      this._removeShadow(ctx);
+      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), true);
+  };
+
+  /**
+   * 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, true);
+  };
+
+})(typeof exports !== 'undefined' ? exports : this);

data/vendor/assets/javascripts/fabric/rect.class.js

@@ -0,0 +1,298 @@
+(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();
+      }
+
+      this._removeShadow(ctx);
+
+      if (this.strokeDashArray) {
+        this._renderDashedStroke(ctx);
+      }
+      else if (this.stroke) {
+        ctx.stroke();
+      }
+    },
+
+    /**
+     * @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();
+    },
+
+    /**
+     * @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 '<rect ' +
+              'x="' + (-1 * this.width / 2) + '" y="' + (-1 * this.height / 2) + '" ' +
+              'rx="' + this.get('rx') + '" ry="' + this.get('ry') + '" ' +
+              'width="' + this.width + '" height="' + this.height + '" ' +
+              'style="' + this.getSvgStyles() + '" ' +
+              'transform="' + this.getSvgTransform() + '" ' +
+              '/>';
+    }
+  });
+
+  /**
+   * 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);