fabric 5.3.0 → 6.0.0-beta1

package/src/shapes/ActiveSelection.ts

@@ -0,0 +1,157 @@
+import { ControlRenderingStyleOverride } from '../controls/controls.render';
+import { TClassProperties } from '../typedefs';
+import { classRegistry } from '../util/class_registry';
+import { Group } from './Group';
+import type { FabricObject } from './Object/FabricObject';
+
+export class ActiveSelection extends Group {
+  declare _objects: FabricObject[];
+
+  constructor(
+    objects?: FabricObject[],
+    options?: any,
+    objectsRelativeToGroup?: boolean
+  ) {
+    super(objects, options, objectsRelativeToGroup);
+    this.setCoords();
+  }
+
+  /**
+   * @private
+   */
+  _shouldSetNestedCoords() {
+    return true;
+  }
+
+  /**
+   * @private
+   * @param {FabricObject} object
+   * @param {boolean} [removeParentTransform] true if object is in canvas coordinate plane
+   * @returns {boolean} true if object entered group
+   */
+  enterGroup(object: FabricObject, removeParentTransform?: boolean) {
+    if (object.group) {
+      //  save ref to group for later in order to return to it
+      const parent = object.group;
+      parent._exitGroup(object);
+      object.__owningGroup = parent;
+    }
+    this._enterGroup(object, removeParentTransform);
+    return true;
+  }
+
+  /**
+   * we want objects to retain their canvas ref when exiting instance
+   * @private
+   * @param {FabricObject} object
+   * @param {boolean} [removeParentTransform] true if object should exit group without applying group's transform to it
+   */
+  exitGroup(object: FabricObject, removeParentTransform?: boolean) {
+    this._exitGroup(object, removeParentTransform);
+    const parent = object.__owningGroup;
+    if (parent) {
+      //  return to owning group
+      parent.enterGroup(object);
+      delete object.__owningGroup;
+    }
+  }
+
+  /**
+   * @private
+   * @param {'added'|'removed'} type
+   * @param {FabricObject[]} targets
+   */
+  _onAfterObjectsChange(type: 'added' | 'removed', targets: FabricObject[]) {
+    super._onAfterObjectsChange(type, targets);
+    const groups: Group[] = [];
+    targets.forEach((object) => {
+      object.group &&
+        !groups.includes(object.group) &&
+        groups.push(object.group);
+    });
+    if (type === 'removed') {
+      //  invalidate groups' layout and mark as dirty
+      groups.forEach((group) => {
+        group._onAfterObjectsChange('added', targets);
+      });
+    } else {
+      //  mark groups as dirty
+      groups.forEach((group) => {
+        group._set('dirty', true);
+      });
+    }
+  }
+
+  /**
+   * If returns true, deselection is cancelled.
+   * @since 2.0.0
+   * @return {Boolean} [cancel]
+   */
+  onDeselect() {
+    this.removeAll();
+    return false;
+  }
+
+  /**
+   * Returns string representation of a group
+   * @return {String}
+   */
+  toString() {
+    return `#<ActiveSelection: (${this.complexity()})>`;
+  }
+
+  /**
+   * Decide if the object should cache or not. Create its own cache level
+   * objectCaching is a global flag, wins over everything
+   * needsItsOwnCache should be used when the object drawing method requires
+   * a cache step. None of the fabric classes requires it.
+   * Generally you do not cache objects in groups because the group outside is cached.
+   * @return {Boolean}
+   */
+  shouldCache() {
+    return false;
+  }
+
+  /**
+   * Check if this group or its parent group are caching, recursively up
+   * @return {Boolean}
+   */
+  isOnACache() {
+    return false;
+  }
+
+  /**
+   * Renders controls and borders for the object
+   * @param {CanvasRenderingContext2D} ctx Context to render on
+   * @param {Object} [styleOverride] properties to override the object style
+   * @param {Object} [childrenOverride] properties to override the children overrides
+   */
+  _renderControls(
+    ctx: CanvasRenderingContext2D,
+    styleOverride?: ControlRenderingStyleOverride,
+    childrenOverride?: ControlRenderingStyleOverride
+  ) {
+    ctx.save();
+    ctx.globalAlpha = this.isMoving ? this.borderOpacityWhenMoving : 1;
+    super._renderControls(ctx, styleOverride);
+    const options = {
+      hasControls: false,
+      ...childrenOverride,
+      forActiveSelection: true,
+    };
+    for (let i = 0; i < this._objects.length; i++) {
+      this._objects[i]._renderControls(ctx, options);
+    }
+    ctx.restore();
+  }
+}
+
+export const activeSelectionDefaultValues: Partial<
+  TClassProperties<ActiveSelection>
+> = {
+  type: 'activeSelection',
+};
+
+Object.assign(ActiveSelection.prototype, activeSelectionDefaultValues);
+
+classRegistry.setClass(ActiveSelection);

package/src/shapes/Circle.ts

@@ -0,0 +1,205 @@
+import { SHARED_ATTRIBUTES } from '../parser/attributes';
+import { parseAttributes } from '../parser/parseAttributes';
+import { cos } from '../util/misc/cos';
+import { degreesToRadians } from '../util/misc/radiansDegreesConversion';
+import { sin } from '../util/misc/sin';
+import { classRegistry } from '../util/class_registry';
+import { FabricObject, cacheProperties } from './Object/FabricObject';
+import { TClassProperties } from '../typedefs';
+
+export class Circle extends FabricObject {
+  /**
+   * Radius of this circle
+   * @type Number
+   * @default 0
+   */
+  declare radius: number;
+
+  /**
+   * degrees of start of the circle.
+   * probably will change to degrees in next major version
+   * @type Number 0 - 359
+   * @default 0
+   */
+  declare startAngle: number;
+
+  /**
+   * End angle of the circle
+   * probably will change to degrees in next major version
+   * @type Number 1 - 360
+   * @default 360
+   */
+  declare endAngle: number;
+
+  /**
+   * @private
+   * @param {String} key
+   * @param {*} value
+   */
+  _set(key: string, value: any) {
+    super._set(key, value);
+
+    if (key === 'radius') {
+      this.setRadius(value);
+    }
+
+    return this;
+  }
+
+  /**
+   * @private
+   * @param {CanvasRenderingContext2D} ctx context to render on
+   */
+  _render(ctx: CanvasRenderingContext2D) {
+    ctx.beginPath();
+    ctx.arc(
+      0,
+      0,
+      this.radius,
+      degreesToRadians(this.startAngle),
+      degreesToRadians(this.endAngle),
+      false
+    );
+    this._renderPaintInOrder(ctx);
+  }
+
+  /**
+   * Returns horizontal radius of an object (according to how an object is scaled)
+   * @return {Number}
+   */
+  getRadiusX(): number {
+    return this.get('radius') * this.get('scaleX');
+  }
+
+  /**
+   * Returns vertical radius of an object (according to how an object is scaled)
+   * @return {Number}
+   */
+  getRadiusY(): number {
+    return this.get('radius') * this.get('scaleY');
+  }
+
+  /**
+   * Sets radius of an object (and updates width accordingly)
+   */
+  setRadius(value: number) {
+    this.radius = value;
+    this.set({ width: value * 2, height: value * 2 });
+  }
+
+  /**
+   * Returns object representation of an instance
+   * @param {Array} [propertiesToInclude] Any properties that you might want to additionally include in the output
+   * @return {Object} object representation of an instance
+   */
+  toObject(propertiesToInclude: string[] = []): object {
+    return super.toObject([
+      'radius',
+      'startAngle',
+      'endAngle',
+      ...propertiesToInclude,
+    ]);
+  }
+
+  /* _TO_SVG_START_ */
+
+  /**
+   * Returns svg representation of an instance
+   * @return {Array} an array of strings with the specific svg representation
+   * of the instance
+   */
+  _toSVG(): (string | number)[] {
+    const angle = (this.endAngle - this.startAngle) % 360;
+
+    if (angle === 0) {
+      return [
+        '<circle ',
+        'COMMON_PARTS',
+        'cx="0" cy="0" ',
+        'r="',
+        this.radius,
+        '" />\n',
+      ];
+    } else {
+      const { radius } = this;
+      const start = degreesToRadians(this.startAngle),
+        end = degreesToRadians(this.endAngle),
+        startX = cos(start) * radius,
+        startY = sin(start) * radius,
+        endX = cos(end) * radius,
+        endY = sin(end) * radius,
+        largeFlag = angle > 180 ? '1' : '0';
+      return [
+        `<path d="M ${startX} ${startY}`,
+        ` A ${radius} ${radius}`,
+        ' 0 ',
+        `${largeFlag} 1`,
+        ` ${endX} ${endY}`,
+        '" ',
+        'COMMON_PARTS',
+        ' />\n',
+      ];
+    }
+  }
+  /* _TO_SVG_END_ */
+
+  /* _FROM_SVG_START_ */
+  /**
+   * List of attribute names to account for when parsing SVG element (used by {@link Circle.fromElement})
+   * @static
+   * @memberOf Circle
+   * @see: http://www.w3.org/TR/SVG/shapes.html#CircleElement
+   */
+  static ATTRIBUTE_NAMES = ['cx', 'cy', 'r', ...SHARED_ATTRIBUTES];
+
+  /**
+   * Returns {@link Circle} instance from an SVG element
+   * @static
+   * @memberOf Circle
+   * @param {SVGElement} element Element to parse
+   * @param {Function} [callback] Options callback invoked after parsing is finished
+   * @param {Object} [options] Partial Circle object to default missing properties on the element.
+   * @throws {Error} If value of `r` attribute is missing or invalid
+   */
+  static fromElement(element: SVGElement, callback: (circle: Circle) => any) {
+    const {
+      left = 0,
+      top = 0,
+      radius,
+      ...otherParsedAttributes
+    } = parseAttributes(element, this.ATTRIBUTE_NAMES);
+
+    if (!radius || radius < 0) {
+      throw new Error(
+        'value of `r` attribute is required and can not be negative'
+      );
+    }
+
+    // this probably requires to be fixed for default origins not being top/left.
+    callback(
+      new this({
+        ...otherParsedAttributes,
+        radius,
+        left: left - radius,
+        top: top - radius,
+      })
+    );
+  }
+
+  /* _FROM_SVG_END_ */
+}
+
+export const circleDefaultValues: Partial<TClassProperties<Circle>> = {
+  type: 'circle',
+  radius: 0,
+  startAngle: 0,
+  endAngle: 360,
+};
+
+Object.assign(Circle.prototype, {
+  ...circleDefaultValues,
+  cacheProperties: [...cacheProperties, 'radius', 'startAngle', 'endAngle'],
+});
+
+classRegistry.setClass(Circle);
+classRegistry.setSVGClass(Circle);

package/src/shapes/Ellipse.ts

@@ -0,0 +1,154 @@
+import { twoMathPi } from '../constants';
+import { SHARED_ATTRIBUTES } from '../parser/attributes';
+import { parseAttributes } from '../parser/parseAttributes';
+import { TClassProperties } from '../typedefs';
+import { classRegistry } from '../util/class_registry';
+import { FabricObject, cacheProperties } from './Object/FabricObject';
+
+export class Ellipse extends FabricObject {
+  /**
+   * Horizontal radius
+   * @type Number
+   * @default
+   */
+  declare rx: number;
+
+  /**
+   * Vertical radius
+   * @type Number
+   * @default
+   */
+  declare ry: number;
+
+  /**
+   * Constructor
+   * @param {Object} [options] Options object
+   * @return {Ellipse} thisArg
+   */
+  constructor(options: Record<string, unknown>) {
+    super(options);
+  }
+
+  /**
+   * @private
+   * @param {String} key
+   * @param {*} value
+   * @return {Ellipse} thisArg
+   */
+  _set(key: string, value: any) {
+    super._set(key, value);
+    switch (key) {
+      case 'rx':
+        this.rx = value;
+        this.set('width', value * 2);
+        break;
+
+      case 'ry':
+        this.ry = value;
+        this.set('height', value * 2);
+        break;
+    }
+    return this;
+  }
+
+  /**
+   * Returns horizontal radius of an object (according to how an object is scaled)
+   * @return {Number}
+   */
+  getRx() {
+    return this.get('rx') * this.get('scaleX');
+  }
+
+  /**
+   * Returns Vertical radius of an object (according to how an object is scaled)
+   * @return {Number}
+   */
+  getRy() {
+    return this.get('ry') * this.get('scaleY');
+  }
+
+  /**
+   * Returns object representation of an instance
+   * @param {Array} [propertiesToInclude] Any properties that you might want to additionally include in the output
+   * @return {Object} object representation of an instance
+   */
+  toObject(propertiesToInclude: string[] = []) {
+    return super.toObject(['rx', 'ry', ...propertiesToInclude]);
+  }
+
+  /**
+   * Returns svg representation of an instance
+   * @return {Array} an array of strings with the specific svg representation
+   * of the instance
+   */
+  _toSVG() {
+    return [
+      '<ellipse ',
+      'COMMON_PARTS',
+      'cx="0" cy="0" ',
+      'rx="',
+      this.rx,
+      '" ry="',
+      this.ry,
+      '" />\n',
+    ];
+  }
+
+  /**
+   * @private
+   * @param {CanvasRenderingContext2D} ctx context to render on
+   */
+  _render(ctx: CanvasRenderingContext2D) {
+    ctx.beginPath();
+    ctx.save();
+    ctx.transform(1, 0, 0, this.ry / this.rx, 0, 0);
+    ctx.arc(0, 0, this.rx, 0, twoMathPi, false);
+    ctx.restore();
+    this._renderPaintInOrder(ctx);
+  }
+
+  /* _FROM_SVG_START_ */
+
+  /**
+   * List of attribute names to account for when parsing SVG element (used by {@link Ellipse.fromElement})
+   * @static
+   * @memberOf Ellipse
+   * @see http://www.w3.org/TR/SVG/shapes.html#EllipseElement
+   */
+  static ATTRIBUTE_NAMES = [...SHARED_ATTRIBUTES, 'cx', 'cy', 'rx', 'ry'];
+
+  /**
+   * Returns {@link Ellipse} instance from an SVG element
+   * @static
+   * @memberOf Ellipse
+   * @param {SVGElement} element Element to parse
+   * @param {Function} [callback] Options callback invoked after parsing is finished
+   * @return {Ellipse}
+   */
+  static fromElement(
+    element: SVGElement,
+    callback: (ellipse: Ellipse) => void
+  ) {
+    const parsedAttributes = parseAttributes(element, this.ATTRIBUTE_NAMES);
+
+    parsedAttributes.left = (parsedAttributes.left || 0) - parsedAttributes.rx;
+    parsedAttributes.top = (parsedAttributes.top || 0) - parsedAttributes.ry;
+    callback(new this(parsedAttributes));
+  }
+
+  /* _FROM_SVG_END_ */
+}
+
+export const ellipseDefaultValues: Partial<TClassProperties<Ellipse>> = {
+  type: 'ellipse',
+  rx: 0,
+  ry: 0,
+};
+
+Object.assign(Ellipse.prototype, {
+  ...ellipseDefaultValues,
+  cacheProperties: [...cacheProperties, 'rx', 'ry'],
+});
+
+classRegistry.setClass(Ellipse);
+classRegistry.setSVGClass(Ellipse);