@mlightcad/data-model 1.10.7 → 1.11.1

package/lib/entity/AcDbOle2Frame.js

@@ -0,0 +1,717 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { AcGeBox3d, AcGeMatrix3d, AcGePoint3d, AcGeVector3d } from '@mlightcad/geometry-engine';
+import { acdbDrawImageFrame } from '../misc/acdbDrawImageFrame';
+import { acdbExtractOleImageBlob } from '../misc/AcDbOleImageExtractor';
+import { AcDbOsnapMode } from '../misc/AcDbOsnapMode';
+import { acdbBytesToHexString } from '../misc/proxyGraphic';
+import { AcDbEntity } from './AcDbEntity';
+import { acdbForEachGripIndex, acdbMovePointArrayGripAt } from './AcDbGripHelpers';
+import { AcDbOleFrame } from './AcDbOleFrame';
+import { acdbCollectVertexPathOsnapPoints } from './AcDbOsnapHelpers';
+/**
+ * OLE object type stored with an {@link AcDbOle2Frame} (DXF group code 71).
+ *
+ * @see https://help.autodesk.com/cloudhelp/2018/ENU/AutoCAD-DXF/files/GUID-77747CE6-82C6-4452-97ED-4CEEB38BE960.htm
+ */
+export var AcDbOleObjectType;
+(function (AcDbOleObjectType) {
+    /** Linked OLE object */
+    AcDbOleObjectType[AcDbOleObjectType["Link"] = 1] = "Link";
+    /** Embedded OLE object */
+    AcDbOleObjectType[AcDbOleObjectType["Embedded"] = 2] = "Embedded";
+    /** Static OLE object */
+    AcDbOleObjectType[AcDbOleObjectType["Static"] = 3] = "Static";
+})(AcDbOleObjectType || (AcDbOleObjectType = {}));
+/**
+ * Tile-mode descriptor stored with an {@link AcDbOle2Frame} (DXF group code 72).
+ *
+ * Distinct from the common entity paper-space flag (group code 67).
+ */
+export var AcDbOleTileMode;
+(function (AcDbOleTileMode) {
+    /** Object resides in model space */
+    AcDbOleTileMode[AcDbOleTileMode["ModelSpace"] = 0] = "ModelSpace";
+    /** Object resides in paper space */
+    AcDbOleTileMode[AcDbOleTileMode["PaperSpace"] = 1] = "PaperSpace";
+})(AcDbOleTileMode || (AcDbOleTileMode = {}));
+/**
+ * Represents an OLE 2 frame entity in AutoCAD.
+ *
+ * {@link AcDbOle2Frame} provides a display frame for an OLE 2 object. It stores
+ * frame geometry (location, width, height, rotation), display settings, link
+ * metadata, and the embedded OLE binary payload inherited from
+ * {@link AcDbOleFrame}.
+ *
+ * Platform-specific MFC types such as `COleClientItem` are represented as opaque
+ * values in this TypeScript port.
+ *
+ * @see https://help.autodesk.com/view/OARX/2024/ENU/?guid=OARX-RefGuide-AcDbOle2Frame
+ * @see https://help.autodesk.com/view/OARX/2024/ENU/?guid=OARX-RefGuide-__MEMBERTYPE_Methods_AcDbOle2Frame
+ *
+ * @example
+ * ```typescript
+ * const ole = new AcDbOle2Frame()
+ * ole.setLocation(new AcGePoint3d(0, 10, 0))
+ * ole.setWcsWidth(100)
+ * ole.setWcsHeight(75)
+ * ole.userType = 'Paintbrush Picture'
+ * ole.oleObjectType = AcDbOleObjectType.Embedded
+ * ```
+ */
+var AcDbOle2Frame = /** @class */ (function (_super) {
+    __extends(AcDbOle2Frame, _super);
+    /**
+     * Creates a new OLE 2 frame entity.
+     *
+     * Objects created with this constructor must receive a valid OLE payload
+     * through {@link setOleObject} (or host-specific client-item APIs) before they
+     * represent a complete OLE entity.
+     */
+    function AcDbOle2Frame() {
+        var _this = _super.call(this) || this;
+        /** Upper-left corner of the frame in WCS. */
+        _this._upperLeft = new AcGePoint3d();
+        /** Lower-right corner of the frame in WCS. */
+        _this._lowerRight = new AcGePoint3d();
+        /** Rotation angle in radians. */
+        _this._rotation = 0;
+        /** Relative scale factor applied to the frame width. */
+        _this._scaleWidth = 1;
+        /** Relative scale factor applied to the frame height. */
+        _this._scaleHeight = 1;
+        /** Whether the aspect ratio is locked. */
+        _this._lockAspect = false;
+        /** Output quality value (DXF group code 73 when present). */
+        _this._outputQuality = 0;
+        /** Automatic output quality flag. */
+        _this._autoOutputQuality = 0;
+        /** OLE object type (link / embedded / static). */
+        _this._oleObjectType = AcDbOleObjectType.Embedded;
+        /** Tile-mode descriptor. */
+        _this._tileMode = AcDbOleTileMode.ModelSpace;
+        /** User-visible OLE type description (DXF group code 3). */
+        _this._userType = '';
+        /** Linked OLE object name. */
+        _this._linkName = '';
+        /** Linked OLE object path. */
+        _this._linkPath = '';
+        /**
+         * Opaque host OLE client item.
+         *
+         * Mirrors ObjectARX `COleClientItem*`. There is no MFC host in the browser
+         * runtime, so this value is application-defined.
+         */
+        _this._oleClientItem = null;
+        /** Whether image extraction from the current OLE payload has been attempted. */
+        _this._imageResolved = false;
+        return _this;
+    }
+    Object.defineProperty(AcDbOle2Frame.prototype, "dxfTypeName", {
+        get: function () {
+            return 'OLE2FRAME';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbOle2Frame.prototype, "upperLeftCorner", {
+        /**
+         * Gets the upper-left corner of this frame in WCS.
+         */
+        get: function () {
+            return this._upperLeft;
+        },
+        /**
+         * Sets the upper-left corner of this frame in WCS.
+         */
+        set: function (value) {
+            this._upperLeft.copy(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbOle2Frame.prototype, "lowerRightCorner", {
+        /**
+         * Gets the lower-right corner of this frame in WCS.
+         */
+        get: function () {
+            return this._lowerRight;
+        },
+        /**
+         * Sets the lower-right corner of this frame in WCS.
+         */
+        set: function (value) {
+            this._lowerRight.copy(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Gets the location (upper-left corner) of this OLE frame in WCS.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::getLocation`.
+     */
+    AcDbOle2Frame.prototype.getLocation = function (result) {
+        if (result) {
+            return result.copy(this._upperLeft);
+        }
+        return this._upperLeft.clone();
+    };
+    /**
+     * Sets the location (upper-left corner) of this OLE frame in WCS.
+     *
+     * The lower-right corner is translated by the same delta so the frame size is
+     * preserved.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::setLocation`.
+     */
+    AcDbOle2Frame.prototype.setLocation = function (value) {
+        var _a;
+        var dx = value.x - this._upperLeft.x;
+        var dy = value.y - this._upperLeft.y;
+        var dz = ((_a = value.z) !== null && _a !== void 0 ? _a : 0) - this._upperLeft.z;
+        this._upperLeft.copy(value);
+        this._lowerRight.x += dx;
+        this._lowerRight.y += dy;
+        this._lowerRight.z += dz;
+    };
+    /**
+     * Gets the frame rectangle in WCS.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::position(CRectangle3d&)`.
+     */
+    AcDbOle2Frame.prototype.position = function () {
+        return {
+            upperLeft: this._upperLeft.clone(),
+            upperRight: this.cornerUpperRight(),
+            lowerLeft: this.cornerLowerLeft(),
+            lowerRight: this._lowerRight.clone()
+        };
+    };
+    /**
+     * Sets the frame rectangle in WCS from the given corner points.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::setPosition(const CRectangle3d&)`.
+     * Only the upper-left and lower-right corners are stored; the other two
+     * corners are derived.
+     */
+    AcDbOle2Frame.prototype.setPosition = function (rect) {
+        this._upperLeft.copy(rect.upperLeft);
+        this._lowerRight.copy(rect.lowerRight);
+    };
+    /**
+     * Gets the frame width in WCS units.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::wcsWidth`.
+     */
+    AcDbOle2Frame.prototype.wcsWidth = function () {
+        return Math.abs(this._lowerRight.x - this._upperLeft.x);
+    };
+    /**
+     * Sets the frame width in WCS units, keeping the upper-left corner fixed.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::setWcsWidth`.
+     */
+    AcDbOle2Frame.prototype.setWcsWidth = function (value) {
+        var sign = this._lowerRight.x >= this._upperLeft.x ? 1 : -1;
+        this._lowerRight.x = this._upperLeft.x + sign * Math.abs(value);
+        if (this._lockAspect) {
+            this.syncHeightFromAspect();
+        }
+    };
+    /**
+     * Gets the frame height in WCS units.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::wcsHeight`.
+     */
+    AcDbOle2Frame.prototype.wcsHeight = function () {
+        return Math.abs(this._upperLeft.y - this._lowerRight.y);
+    };
+    /**
+     * Sets the frame height in WCS units, keeping the upper-left corner fixed.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::setWcsHeight`.
+     */
+    AcDbOle2Frame.prototype.setWcsHeight = function (value) {
+        var sign = this._upperLeft.y >= this._lowerRight.y ? 1 : -1;
+        this._lowerRight.y = this._upperLeft.y - sign * Math.abs(value);
+        if (this._lockAspect) {
+            this.syncWidthFromAspect();
+        }
+    };
+    /**
+     * Gets the relative width scale factor.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::scaleWidth`.
+     */
+    AcDbOle2Frame.prototype.scaleWidth = function () {
+        return this._scaleWidth;
+    };
+    /**
+     * Sets the relative width scale factor.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::setScaleWidth`.
+     */
+    AcDbOle2Frame.prototype.setScaleWidth = function (value) {
+        this._scaleWidth = value;
+    };
+    /**
+     * Gets the relative height scale factor.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::scaleHeight`.
+     */
+    AcDbOle2Frame.prototype.scaleHeight = function () {
+        return this._scaleHeight;
+    };
+    /**
+     * Sets the relative height scale factor.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::setScaleHeight`.
+     */
+    AcDbOle2Frame.prototype.setScaleHeight = function (value) {
+        this._scaleHeight = value;
+    };
+    /**
+     * Gets the rotation angle of this frame in radians.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::rotation`.
+     */
+    AcDbOle2Frame.prototype.rotation = function () {
+        return this._rotation;
+    };
+    /**
+     * Sets the rotation angle of this frame in radians.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::setRotation`.
+     */
+    AcDbOle2Frame.prototype.setRotation = function (value) {
+        this._rotation = value;
+    };
+    /**
+     * Returns whether the frame aspect ratio is locked.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::lockAspect`.
+     */
+    AcDbOle2Frame.prototype.lockAspect = function () {
+        return this._lockAspect;
+    };
+    /**
+     * Sets whether the frame aspect ratio is locked.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::setLockAspect`.
+     */
+    AcDbOle2Frame.prototype.setLockAspect = function (value) {
+        this._lockAspect = !!value;
+    };
+    /**
+     * Gets the output quality value.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::outputQuality`.
+     */
+    AcDbOle2Frame.prototype.outputQuality = function () {
+        return this._outputQuality;
+    };
+    /**
+     * Sets the output quality value.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::setOutputQuality`.
+     */
+    AcDbOle2Frame.prototype.setOutputQuality = function (value) {
+        this._outputQuality = value & 0xff;
+    };
+    /**
+     * Gets the automatic output quality flag.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::autoOutputQuality`.
+     */
+    AcDbOle2Frame.prototype.autoOutputQuality = function () {
+        return this._autoOutputQuality;
+    };
+    /**
+     * Sets the automatic output quality flag.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::setAutoOutputQuality`.
+     */
+    AcDbOle2Frame.prototype.setAutoOutputQuality = function (value) {
+        this._autoOutputQuality = value & 0xff;
+    };
+    /**
+     * Gets the OLE object type (link / embedded / static).
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::getType`.
+     */
+    AcDbOle2Frame.prototype.getType = function () {
+        return this._oleObjectType;
+    };
+    /**
+     * Sets the OLE object type (link / embedded / static).
+     */
+    AcDbOle2Frame.prototype.setType = function (value) {
+        this._oleObjectType = value;
+    };
+    Object.defineProperty(AcDbOle2Frame.prototype, "oleObjectType", {
+        /**
+         * Gets the OLE object type (link / embedded / static).
+         *
+         * Prefer {@link getType} when matching ObjectARX naming.
+         */
+        get: function () {
+            return this._oleObjectType;
+        },
+        set: function (value) {
+            this._oleObjectType = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbOle2Frame.prototype, "tileMode", {
+        /**
+         * Gets the tile-mode descriptor for this frame.
+         */
+        get: function () {
+            return this._tileMode;
+        },
+        set: function (value) {
+            this._tileMode = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Gets the user-visible OLE type description.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::getUserType`. Corresponds to DXF group
+     * code **3**.
+     */
+    AcDbOle2Frame.prototype.getUserType = function () {
+        return this._userType;
+    };
+    /**
+     * Sets the user-visible OLE type description.
+     */
+    AcDbOle2Frame.prototype.setUserType = function (value) {
+        this._userType = value;
+    };
+    Object.defineProperty(AcDbOle2Frame.prototype, "userType", {
+        /**
+         * Gets the user-visible OLE type description.
+         *
+         * Prefer {@link getUserType} when matching ObjectARX naming.
+         */
+        get: function () {
+            return this._userType;
+        },
+        set: function (value) {
+            this._userType = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Gets the linked OLE object name.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::getLinkName`.
+     */
+    AcDbOle2Frame.prototype.getLinkName = function () {
+        return this._linkName;
+    };
+    /**
+     * Sets the linked OLE object name.
+     */
+    AcDbOle2Frame.prototype.setLinkName = function (value) {
+        this._linkName = value;
+    };
+    /**
+     * Gets the linked OLE object path.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::getLinkPath`.
+     */
+    AcDbOle2Frame.prototype.getLinkPath = function () {
+        return this._linkPath;
+    };
+    /**
+     * Sets the linked OLE object path.
+     */
+    AcDbOle2Frame.prototype.setLinkPath = function (value) {
+        this._linkPath = value;
+    };
+    /**
+     * Returns the opaque host OLE client item associated with this frame.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::getOleClientItem`. There is no MFC
+     * `COleClientItem` in the browser runtime; the value is application-defined.
+     */
+    AcDbOle2Frame.prototype.getOleClientItem = function () {
+        return this._oleClientItem;
+    };
+    /**
+     * Associates an opaque host OLE client item with this frame.
+     *
+     * Mirrors ObjectARX `AcDbOle2Frame::setOleClientItem`.
+     */
+    AcDbOle2Frame.prototype.setOleClientItem = function (value) {
+        this._oleClientItem = value !== null && value !== void 0 ? value : null;
+    };
+    Object.defineProperty(AcDbOle2Frame.prototype, "geometricExtents", {
+        /**
+         * @inheritdoc
+         */
+        get: function () {
+            return new AcGeBox3d().setFromPoints(this.boundaryPath());
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * @inheritdoc
+     */
+    AcDbOle2Frame.prototype.subGetGripPoints = function () {
+        return this.boundaryPath().slice(0, 4);
+    };
+    /** @inheritdoc */
+    AcDbOle2Frame.prototype.subMoveGripPointsAt = function (indices, offset) {
+        var _this = this;
+        var corners = this.boundaryPath().slice(0, 4);
+        acdbMovePointArrayGripAt(indices, offset, corners);
+        acdbForEachGripIndex(indices, function (index) {
+            if (index === 0) {
+                _this._upperLeft.copy(corners[0]);
+            }
+            else if (index === 2) {
+                _this._lowerRight.copy(corners[2]);
+            }
+            else if (index === 1) {
+                _this._upperLeft.y = corners[1].y;
+                _this._lowerRight.x = corners[1].x;
+                _this._upperLeft.z = corners[1].z;
+                _this._lowerRight.z = corners[1].z;
+            }
+            else if (index === 3) {
+                _this._upperLeft.x = corners[3].x;
+                _this._lowerRight.y = corners[3].y;
+                _this._upperLeft.z = corners[3].z;
+                _this._lowerRight.z = corners[3].z;
+            }
+        });
+        return this;
+    };
+    /**
+     * Gets object snap points for this OLE frame.
+     */
+    AcDbOle2Frame.prototype.subGetOsnapPoints = function (osnapMode, pickPoint, _lastPoint, snapPoints) {
+        if (osnapMode === AcDbOsnapMode.Insertion) {
+            snapPoints.push(this._upperLeft.clone());
+            return;
+        }
+        var vertices = this.boundaryPath().slice(0, 4);
+        if (osnapMode === AcDbOsnapMode.EndPoint) {
+            snapPoints.push.apply(snapPoints, __spreadArray([], __read(vertices), false));
+            return;
+        }
+        acdbCollectVertexPathOsnapPoints(vertices, true, osnapMode, pickPoint, snapPoints);
+    };
+    /**
+     * Transforms this OLE frame by the specified matrix.
+     */
+    AcDbOle2Frame.prototype.transformBy = function (matrix) {
+        var signedWidth = this._lowerRight.x - this._upperLeft.x;
+        var signedHeight = this._upperLeft.y - this._lowerRight.y;
+        var cos = Math.cos(this._rotation);
+        var sin = Math.sin(this._rotation);
+        var origin = this._upperLeft.clone();
+        var uPoint = origin
+            .clone()
+            .add(new AcGeVector3d(signedWidth * cos, signedWidth * sin, 0));
+        var vPoint = origin
+            .clone()
+            .add(new AcGeVector3d(signedHeight * sin, -signedHeight * cos, 0));
+        origin.applyMatrix4(matrix);
+        uPoint.applyMatrix4(matrix);
+        vPoint.applyMatrix4(matrix);
+        var transformedU = new AcGeVector3d().subVectors(uPoint, origin);
+        var transformedV = new AcGeVector3d().subVectors(vPoint, origin);
+        this._upperLeft.copy(origin);
+        this._rotation = Math.atan2(transformedU.y, transformedU.x);
+        this._lowerRight.set(origin.x + transformedU.length(), origin.y - transformedV.length(), origin.z);
+        return this;
+    };
+    Object.defineProperty(AcDbOle2Frame.prototype, "image", {
+        /**
+         * Gets the image blob extracted from the embedded OLE object, when the
+         * payload contains a recognizable bitmap / PNG / JPEG presentation.
+         *
+         * Extraction is performed lazily on first access and cached until the OLE
+         * binary payload changes.
+         */
+        get: function () {
+            return this.resolveImage();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Draws the embedded OLE picture when an image can be extracted from the
+     * OLE binary payload; otherwise draws a pickable rectangular frame
+     * (transparent fill + outline).
+     */
+    AcDbOle2Frame.prototype.subWorldDraw = function (renderer) {
+        var image = this.resolveImage();
+        var points = this.imageBoundaryPath();
+        if (image) {
+            return renderer.image(image, {
+                boundary: points,
+                roation: this._rotation
+            });
+        }
+        return acdbDrawImageFrame(renderer, this.boundaryPath());
+    };
+    /** @inheritdoc */
+    AcDbOle2Frame.prototype.onOleObjectChanged = function () {
+        this._image = undefined;
+        this._imageResolved = false;
+    };
+    AcDbOle2Frame.prototype.resolveImage = function () {
+        if (this._imageResolved) {
+            return this._image;
+        }
+        this._imageResolved = true;
+        this._image = acdbExtractOleImageBlob(this.oleObjectData);
+        return this._image;
+    };
+    /**
+     * Image quad in the same corner order as {@link AcDbRasterImage}:
+     * lower-left, lower-right, upper-right, upper-left, then close.
+     */
+    AcDbOle2Frame.prototype.imageBoundaryPath = function () {
+        var frame = this.boundaryPath();
+        var points = [frame[3], frame[2], frame[1], frame[0]];
+        points.push(points[0].clone());
+        return points;
+    };
+    /**
+     * Writes DXF fields for this OLE 2 frame.
+     *
+     * Emits the `AcDbOle2Frame` subclass marker and Autodesk OLE2FRAME group
+     * codes. Entity-level fields come from {@link AcDbEntity.dxfOutFields};
+     * {@link AcDbOleFrame} fields are skipped because OLE2FRAME uses its own
+     * layout.
+     *
+     * @param filer - DXF output writer.
+     * @returns The instance (for chaining).
+     * @see https://help.autodesk.com/cloudhelp/2018/ENU/AutoCAD-DXF/files/GUID-77747CE6-82C6-4452-97ED-4CEEB38BE960.htm
+     */
+    AcDbOle2Frame.prototype.dxfOutFields = function (filer) {
+        AcDbEntity.prototype.dxfOutFields.call(this, filer);
+        filer.writeSubclassMarker('AcDbOle2Frame');
+        filer.writeInt16(70, this.oleVersion);
+        if (this._userType) {
+            filer.writeString(3, this._userType);
+        }
+        filer.writePoint3d(10, this._upperLeft);
+        filer.writePoint3d(11, this._lowerRight);
+        filer.writeInt16(71, this._oleObjectType);
+        filer.writeInt16(72, this._tileMode);
+        if (this._outputQuality) {
+            filer.writeInt16(73, this._outputQuality);
+        }
+        var oleObject = this.getOleObject();
+        if (oleObject === null || oleObject === void 0 ? void 0 : oleObject.length) {
+            filer.writeInt32(90, oleObject.length);
+            var index = 0;
+            while (index < oleObject.length) {
+                var chunk = oleObject.subarray(index, index + 127);
+                filer.writeString(310, acdbBytesToHexString(chunk));
+                index += 127;
+            }
+        }
+        filer.writeString(1, 'OLE');
+        return this;
+    };
+    AcDbOle2Frame.prototype.cornerUpperRight = function () {
+        return new AcGePoint3d(this._lowerRight.x, this._upperLeft.y, this._upperLeft.z);
+    };
+    AcDbOle2Frame.prototype.cornerLowerLeft = function () {
+        return new AcGePoint3d(this._upperLeft.x, this._lowerRight.y, this._lowerRight.z);
+    };
+    AcDbOle2Frame.prototype.boundaryPath = function () {
+        var points = [
+            this._upperLeft.clone(),
+            this.cornerUpperRight(),
+            this._lowerRight.clone(),
+            this.cornerLowerLeft()
+        ];
+        if (this._rotation !== 0) {
+            var origin_1 = this._upperLeft;
+            for (var index = 1; index < points.length; index++) {
+                points[index]
+                    .sub(origin_1)
+                    .applyMatrix4(new AcGeMatrix3d().makeRotationZ(this._rotation));
+                points[index].add(origin_1);
+            }
+        }
+        // Closed path for line rendering
+        points.push(points[0].clone());
+        return points;
+    };
+    AcDbOle2Frame.prototype.syncHeightFromAspect = function () {
+        var width = this.wcsWidth();
+        if (width === 0 || this._scaleWidth === 0)
+            return;
+        var aspect = this._scaleHeight / this._scaleWidth;
+        var height = width * aspect;
+        var sign = this._upperLeft.y >= this._lowerRight.y ? 1 : -1;
+        this._lowerRight.y = this._upperLeft.y - sign * Math.abs(height);
+    };
+    AcDbOle2Frame.prototype.syncWidthFromAspect = function () {
+        var height = this.wcsHeight();
+        if (height === 0 || this._scaleHeight === 0)
+            return;
+        var aspect = this._scaleWidth / this._scaleHeight;
+        var width = height * aspect;
+        var sign = this._lowerRight.x >= this._upperLeft.x ? 1 : -1;
+        this._lowerRight.x = this._upperLeft.x + sign * Math.abs(width);
+    };
+    /** The entity type name */
+    AcDbOle2Frame.typeName = 'Ole2Frame';
+    return AcDbOle2Frame;
+}(AcDbOleFrame));
+export { AcDbOle2Frame };
+//# sourceMappingURL=AcDbOle2Frame.js.map