@yamcs/opi 1.3.13 → 1.4.0

package/dist/types/scripting/PVWrapper.d.ts

@@ -1,6 +1,7 @@
 import { PV } from "../pv/PV";
 export declare class PVWrapper {
     readonly _pv: PV;
+    private listeners;
     constructor(_pv: PV);
     getName(): string;
     getValue(): any;

package/dist/types/scripting/WidgetWrapper.d.ts

@@ -7,9 +7,11 @@ import { PVWrapper } from "./PVWrapper";
 export declare class WidgetWrapper {
     private widget;
     constructor(widget: Widget);
+    getWidget(): Widget;
     executeAction(index: number): void;
     getPVByName(name: string): PVWrapper | null;
     getPV(propertyName?: string): PVWrapper | null;
+    getChild(name: string): WidgetWrapper | null;
     getHookedActions(): ArrayList;
     getVar(name: string): any;
     setVar(name: string, value: any): void;

package/dist/types/widgets/controls/ActionButton.d.ts

@@ -12,6 +12,13 @@ export declare class ActionButton extends Widget {
     private imageLoaded;
     constructor(display: Display, parent: AbstractContainerWidget);
     init(): void;
+    /**
+     * Truncates `text` with a trailing ellipsis so it fits within `maxWidth`,
+     * matching Draw2D Label's default text-clipping behavior (the underlying
+     * figure ActionButtonFigure wraps in Yamcs Studio). Assumes `ctx.font` is
+     * already set to the font `text` should be measured with.
+     */
+    private truncateWithEllipsis;
     draw(g: Graphics): void;
     getHookedActions(): Action[];
     get font(): Font;

package/dist/types/widgets/controls/BooleanButton.d.ts

@@ -10,6 +10,7 @@ export declare class BooleanButton extends Widget {
     private areaRegion?;
     constructor(display: Display, parent: AbstractContainerWidget);
     init(): void;
+    private openConfirmDialog;
     private toggleOn;
     private toggleOff;
     get booleanValue(): boolean;
@@ -23,6 +24,9 @@ export declare class BooleanButton extends Widget {
     get toggleButton(): boolean;
     get pushActionIndex(): number;
     get releaseActionIndex(): number;
+    get showConfirmDialog(): number;
+    get password(): string;
+    get confirmMessage(): string;
     get squareButton(): boolean;
     get showLed(): boolean;
     get showBooleanLabel(): boolean;

package/dist/types/widgets/controls/BooleanSwitch.d.ts

@@ -8,6 +8,7 @@ export declare class BooleanSwitch extends Widget {
     private shaftRegion?;
     constructor(display: Display, parent: AbstractContainerWidget);
     init(): void;
+    private openConfirmDialog;
     private toggleOn;
     private toggleOff;
     get booleanValue(): boolean;
@@ -22,6 +23,9 @@ export declare class BooleanSwitch extends Widget {
     get toggleButton(): boolean;
     get pushActionIndex(): number;
     get releaseActionIndex(): number;
+    get showConfirmDialog(): number;
+    get password(): string;
+    get confirmMessage(): string;
     get effect3d(): boolean;
     get onColor(): Color;
     get onLabel(): string;

package/dist/types/widgets/controls/CheckBox.d.ts

@@ -13,9 +13,11 @@ export declare class CheckBox extends Widget {
     private toggleOn;
     private toggleOff;
     get booleanValue(): boolean;
+    drawHolder(g: Graphics): void;
     draw(g: Graphics): void;
     get boxSize(): number;
     get gap(): number;
+    get autoSize(): boolean;
     get bit(): number;
     get enabled(): boolean;
     get selectedColor(): Color;

package/dist/types/widgets/controls/ImageBooleanButton.d.ts

@@ -12,15 +12,31 @@ export declare class ImageBooleanButton extends Widget {
     private areaRegion?;
     constructor(display: Display, parent: AbstractContainerWidget);
     init(): void;
+    private openConfirmDialog;
     private toggleOn;
     private toggleOff;
     get booleanValue(): boolean;
+    /**
+     * Mirrors ImageBoolButtonEditPart#autoSizeWidget(): once the currently-shown
+     * (on/off) image has loaded, snap the widget's own width/height to that
+     * image's natural size - unless stretch_to_fit is set, in which case the
+     * image follows the widget's declared bounds instead, so there's nothing to
+     * auto-size to.
+     */
+    private applyAutoSize;
+    autoScale(widthRatio: number, heightRatio: number): void;
     draw(g: Graphics): void;
+    get autoSize(): boolean;
+    get stretchToFit(): boolean;
+    get transparency(): boolean;
     get bit(): number;
     get dataType(): number;
     get toggleButton(): boolean;
     get pushActionIndex(): number;
     get releaseActionIndex(): number;
+    get showConfirmDialog(): number;
+    get password(): string;
+    get confirmMessage(): string;
     get showBooleanLabel(): boolean;
     get effect3d(): boolean;
     get onImage(): string;

package/dist/types/widgets/controls/Knob.d.ts

@@ -0,0 +1,64 @@
+import { Color } from "../../Color";
+import { Display } from "../../Display";
+import { Font } from "../../Font";
+import { Graphics } from "../../Graphics";
+import { Widget } from "../../Widget";
+import { AbstractContainerWidget } from "../others/AbstractContainerWidget";
+export declare class Knob extends Widget {
+    private thumbRegion?;
+    private dragValue?;
+    private dragAngle?;
+    private scaleLayoutCache?;
+    private valueLabelFormatCache?;
+    constructor(display: Display, parent: AbstractContainerWidget);
+    init(): void;
+    draw(g: Graphics): void;
+    private computeLimits;
+    private buildScale;
+    private getLayoutScale;
+    private drawRamp;
+    private drawBulb;
+    private drawValueLabel;
+    private drawThumb;
+    private getValuePosition;
+    private getValueInRange;
+    private getAbsoluteCenter;
+    private pointToAbsoluteAngle;
+    private toRelativeAngle;
+    private calcValueChange;
+    private setCoercedValue;
+    private formatLabelValue;
+    get majorTickLength(): number;
+    get minorTickLength(): number;
+    get colorLo(): Color;
+    get colorLoLo(): Color;
+    get colorHi(): Color;
+    get colorHiHi(): Color;
+    get effect3d(): boolean;
+    get font(): Font;
+    get increment(): number;
+    get knobColor(): Color;
+    get levelLo(): number;
+    get levelLoLo(): number;
+    get levelHi(): number;
+    get levelHiHi(): number;
+    get limitsFromPv(): boolean;
+    get logScale(): boolean;
+    get majorTickStepHint(): number;
+    get maximum(): number;
+    get minimum(): number;
+    get rampGradient(): boolean;
+    get scaleFont(): Font;
+    get scaleFormat(): string;
+    get showHi(): boolean;
+    get showHiHi(): boolean;
+    get showLo(): boolean;
+    get showLoLo(): boolean;
+    get showMarkers(): boolean;
+    get showMinorTicks(): boolean;
+    get showScale(): boolean;
+    get showValueLabel(): boolean;
+    get thumbColor(): Color;
+    get transparentBackground(): boolean;
+    get valueLabelFormat(): string;
+}

package/dist/types/widgets/controls/ScaledSlider.d.ts

@@ -0,0 +1,81 @@
+import { Color } from "../../Color";
+import { Display } from "../../Display";
+import { Font } from "../../Font";
+import { Graphics } from "../../Graphics";
+import { Widget } from "../../Widget";
+import { AbstractContainerWidget } from "../others/AbstractContainerWidget";
+export declare class ScaledSlider extends Widget {
+    private trackRegion?;
+    private thumbRegion?;
+    private grabStartValue?;
+    private trackScale?;
+    private pageTimeout?;
+    private pageUp;
+    private pagePressedValue;
+    private hoveringThumb;
+    private draggingThumb;
+    constructor(display: Display, parent: AbstractContainerWidget);
+    init(): void;
+    draw(g: Graphics): void;
+    private drawVertical;
+    private drawVerticalMarkers;
+    private drawVerticalTrack;
+    private drawHorizontal;
+    private drawHorizontalMarkers;
+    private drawHorizontalTrack;
+    private drawThumb;
+    private drawValueLabel;
+    private pageRepeatedly;
+    private stopPaging;
+    private getAncestorOffset;
+    private setCoercedValue;
+    private getCoercedValue;
+    private formatLabelValue;
+    destroy(): void;
+    get min(): number;
+    get max(): number;
+    get lolo(): number | undefined;
+    get lo(): number | undefined;
+    get hi(): number | undefined;
+    get hihi(): number | undefined;
+    get markerTickLength(): number;
+    get markerTickLineWidth(): number;
+    get markerGap(): number;
+    get outlineWidth(): number;
+    get trackBreadth(): number;
+    get thumbLength(): number;
+    get thumbBreadth(): number;
+    get gapBtwThumbScale(): number;
+    get colorHi(): Color;
+    get colorHiHi(): Color;
+    get colorLo(): Color;
+    get colorLoLo(): Color;
+    get colorFillbackground(): Color;
+    get effect3d(): boolean;
+    get fillColor(): Color;
+    get font(): Font;
+    get horizontal(): boolean;
+    get levelHi(): number;
+    get levelHiHi(): number;
+    get levelLo(): number;
+    get levelLoLo(): number;
+    get limitsFromPv(): boolean;
+    get logScale(): boolean;
+    get majorTickStepHint(): number;
+    get maximum(): number;
+    get minimum(): number;
+    get pageIncrement(): number;
+    get scaleFont(): Font;
+    get scaleFormat(): string;
+    get showHi(): boolean;
+    get showHiHi(): boolean;
+    get showLo(): boolean;
+    get showLoLo(): boolean;
+    get showMarkers(): boolean;
+    get showMinorTicks(): boolean;
+    get showScale(): boolean;
+    get stepIncrement(): number;
+    get thumbColor(): Color;
+    get transparentBackground(): boolean;
+    get valueLabelFormat(): string;
+}

package/dist/types/widgets/controls/Spinner.d.ts

@@ -0,0 +1,49 @@
+import { Display } from "../../Display";
+import { Font } from "../../Font";
+import { Graphics } from "../../Graphics";
+import { Widget } from "../../Widget";
+import { AbstractContainerWidget } from "../others/AbstractContainerWidget";
+export declare class Spinner extends Widget {
+    private upRegion?;
+    private upPressed;
+    private downRegion?;
+    private downPressed;
+    private areaRegion?;
+    private repeatTimeout?;
+    private editing;
+    private inputEl?;
+    private scratchCanvas?;
+    private scratchCtx?;
+    constructor(display: Display, parent: AbstractContainerWidget);
+    init(): void;
+    private stopRepeating;
+    private stepRepeatedly;
+    private step;
+    private currentNumericValue;
+    private clamp;
+    private startEditing;
+    private commitEditing;
+    private cancelEditing;
+    draw(g: Graphics): void;
+    private computeLayout;
+    private drawLabel;
+    private formatSpinnerValue;
+    private drawUpButton;
+    private drawDownButton;
+    private drawSpinnerButtonBorder;
+    destroy(): void;
+    get minimum(): number;
+    get maximum(): number;
+    get stepIncrement(): number;
+    get pageIncrement(): number;
+    get limitsFromPV(): boolean;
+    get format(): number;
+    get precision(): number;
+    get precisionFromPV(): boolean;
+    get buttonsOnLeft(): boolean;
+    get horizontalButtonsLayout(): boolean;
+    get showText(): boolean;
+    get font(): Font;
+    get horizAlignment(): number;
+    get vertAlignment(): number;
+}

package/dist/types/widgets/controls/TextInput.d.ts

@@ -11,20 +11,35 @@ export declare class TextInput extends Widget {
     private scratchCtx?;
     constructor(display: Display, parent: AbstractContainerWidget);
     init(): void;
+    private clampToLimits;
+    private finishEditing;
     private cancelInput;
+    private computeDisplayText;
+    drawHolder(g: Graphics): void;
     draw(g: Graphics): void;
+    private drawNative;
     hide(): void;
     destroy(): void;
-    get value(): any;
-    set value(value: any);
+    get autoSize(): boolean;
     get confirmMessage(): string;
     get font(): Font;
     get formatType(): number;
     get horizAlignment(): number;
+    get limitsFromPV(): boolean;
+    get maximum(): number;
+    get minimum(): number;
     get multilineInput(): boolean;
     get passwordInput(): boolean;
     get precision(): number;
     get precisionFromPV(): boolean;
+    get readOnly(): boolean;
+    get rotationAngle(): number;
+    get showHScroll(): boolean;
+    get showLohi(): boolean;
+    get showNativeBorder(): boolean;
     get showUnits(): boolean;
+    get showVScroll(): boolean;
+    get style(): number;
     get vertAlignment(): number;
+    get wrapWords(): boolean;
 }

package/dist/types/widgets/controls/ThumbWheel.d.ts

@@ -0,0 +1,42 @@
+import { Color } from "../../Color";
+import { Display } from "../../Display";
+import { Font } from "../../Font";
+import { Graphics } from "../../Graphics";
+import { Widget } from "../../Widget";
+import { AbstractContainerWidget } from "../others/AbstractContainerWidget";
+export declare class ThumbWheel extends Widget {
+    private repeatTimeout?;
+    private integerPressed;
+    private decimalPressed;
+    constructor(display: Display, parent: AbstractContainerWidget);
+    private ensurePressedArrays;
+    draw(g: Graphics): void;
+    private computeLayout;
+    private computeDigits;
+    private computeWheelLimits;
+    private currentNumericValue;
+    private drawPlainCell;
+    private drawDigitCell;
+    private computeLabelBounds;
+    private drawCellBorder;
+    private drawCellText;
+    private drawUpButton;
+    private drawDownButton;
+    private drawButtonBorder;
+    private stopRepeating;
+    private clickRepeatedly;
+    private click;
+    private increment;
+    private decrement;
+    destroy(): void;
+    get minimum(): number;
+    get maximum(): number;
+    get integerDigits(): number;
+    get decimalDigits(): number;
+    get internalFrameColor(): Color;
+    get focusedFrameColor(): Color;
+    get internalFrameSize(): number;
+    get limitsFromPV(): boolean;
+    get showButtons(): boolean;
+    get font(): Font;
+}

package/dist/types/widgets/figures/Ramp.d.ts

@@ -27,7 +27,7 @@ export declare class Ramp {
     private lengthInDegrees;
     private radius;
     constructor(rampWidth: number, startAngle: number, endAngle: number);
-    draw(g: Graphics, scaleArea: Bounds, rampArea: Bounds): void;
+    draw(g: Graphics, scaleArea: Bounds, rampArea: Bounds, visible?: boolean): void;
     drawRamp(g: Graphics, area: Bounds): void;
     getRadius(): number;
     getValuePosition(v: number, limit?: boolean): number;

package/dist/types/widgets/figures/Scale.d.ts

@@ -0,0 +1,64 @@
+import { Color } from "../../Color";
+import { Font } from "../../Font";
+import { Graphics } from "../../Graphics";
+import { Bounds } from "../../positioning";
+/**
+ * Ports org.csstudio.swt.widgets.figureparts.RoundScale (+ RoundScaleTickMarks,
+ * RoundScaleTickLabels) from Yamcs Studio. Draws the major/minor tick marks and
+ * numeric scale around a round Gauge/Meter dial.
+ */
+export declare class Scale {
+    private startAngle;
+    private endAngle;
+    private direction;
+    minimum: number;
+    maximum: number;
+    logScale: boolean;
+    showMinorTicks: boolean;
+    visible: boolean;
+    majorTickStepHint: number;
+    majorTickLength: number;
+    minorTickLength: number;
+    majorLineWidth: number;
+    minorLineWidth: number;
+    format: string;
+    font: Font;
+    foregroundColor: Color;
+    private radius;
+    constructor(startAngle: number, // degrees
+    endAngle: number, // degrees
+    direction: "inward" | "outward");
+    getRadius(): number;
+    /** Formats a value the same way tick labels are formatted. */
+    formatText(value: number): string;
+    private layoutTicks?;
+    private layoutGeometry?;
+    /**
+     * Computes the radius and tick/label geometry without drawing anything.
+     * Callers that need the radius before other siblings are laid out (e.g.
+     * Knob, where the ramp/bulb bounds derive from the tick radius but must
+     * be *painted* before the ticks so the ticks end up on top) should call
+     * this first, then `paint()` once the rest has been drawn. Safe to call
+     * more than once; `draw()` is just `layout()` + `paint()` combined for
+     * callers that don't care about paint order (Gauge, Meter).
+     */
+    layout(g: Graphics, bounds: Bounds): void;
+    /** Draws ticks/labels using the geometry computed by the last layout() call. */
+    paint(g: Graphics, bounds: Bounds): void;
+    draw(g: Graphics, bounds: Bounds): void;
+    private computeGeometry;
+    private getTickLabelMaxOutLength;
+    private getRenderedRange;
+    private getAutoFormatPattern;
+    private formatValue;
+    private getGridStep;
+    private computeLinearTicks;
+    private computeLogTicks;
+    private computeLabelAreas;
+    private computeLabelVisibility;
+    private isMajorLogTick;
+    private drawTickLine;
+    private drawLinearTickMarks;
+    private drawLogTickMarks;
+    private drawTickLabels;
+}

package/dist/types/widgets/graphics/ImageWidget.d.ts

@@ -10,10 +10,66 @@ export declare class ImageWidget extends Widget {
     private imageLoaded;
     constructor(display: Display, parent: AbstractContainerWidget);
     init(): void;
+    private applyPermutationDelta;
+    /**
+     * Position always follows the auto-scale ratio (set unconditionally by
+     * the base autoScale, mirroring AbstractWidgetModel#doScale()'s
+     * unconditional setLocation()). Size only follows the ratio when
+     * stretch_to_fit is set; otherwise it's snapped back to the image's
+     * natural size, mirroring ImageEditPart#autoSizeWidget() overriding
+     * whatever setSize() the auto-scale pipeline computed.
+     */
+    autoScale(widthRatio: number, heightRatio: number): void;
+    private applyAutoSize;
+    /**
+     * The source rectangle to sample from the natural image, mirroring
+     * PNGSymbolImage#generatePNGData()'s crop handling: an inset that would
+     * consume the whole image on its own is dropped back to 0, and the
+     * opposite inset is dropped to 0 too if the pair would otherwise leave
+     * nothing (or a negative size) left over.
+     */
+    private getCropRegion;
     draw(g: Graphics): void;
+    /**
+     * Draws `source`'s crop region into the widget. Mirrors
+     * PNGSymbolImage#paintFigure(): the background fill (when not
+     * transparent) covers only the same rectangle the image itself is
+     * drawn into - never the full declared width/height if that's larger,
+     * e.g. when auto_size is off and the box exceeds the (unstretched)
+     * crop.
+     */
+    private drawSource;
+    private getUnstretchedSourceRect;
+    /**
+     * When stretching, PNGSymbolImage#generatePNGData() conceptually
+     * stretches the whole natural image up to (width+leftCrop+rightCrop) x
+     * (height+topCrop+bottomCrop) *before* cropping, so crop_top/bottom/
+     * left/right are authored in that stretched image's pixels, not the
+     * natural image's. Translate them back into natural-image source
+     * coordinates instead of pre-stretching a separate canvas - an
+     * equivalent result via a single drawImage call. Skipping this (using
+     * the crop amounts directly against the natural image, same as the
+     * unstretched case) crops away a larger fraction of the original image
+     * than Java does whenever the box is bigger than the natural size.
+     */
+    private getStretchedSourceRect;
     private triggerImageLoad;
     private snapshotImage;
+    /**
+     * Draws `source` (of natural size naturalWidth x naturalHeight) into a
+     * new canvas, oriented per this widget's permutation_matrix. Returns a
+     * plain 1:1 copy (no extra canvas) when the matrix is the identity -
+     * the overwhelming common case - to avoid the extra draw.
+     */
+    private renderOriented;
     get transparency(): boolean;
     get imageFile(): string;
     get noAnimation(): boolean;
+    get autoSize(): boolean;
+    get stretchToFit(): boolean;
+    get cropTop(): number;
+    get cropBottom(): number;
+    get cropLeft(): number;
+    get cropRight(): number;
+    get permutationMatrix(): number[][];
 }

package/dist/types/widgets/graphics/Label.d.ts

@@ -4,14 +4,50 @@ import { Graphics } from "../../Graphics";
 import { Widget } from "../../Widget";
 import { AbstractContainerWidget } from "../others/AbstractContainerWidget";
 export declare class Label extends Widget {
+    private scrollOffset;
+    private maxScroll;
+    private dragRange?;
+    private grabStartOffset?;
+    private actionTimeout?;
+    private upPressed;
+    private downPressed;
+    private thumbRegion?;
+    private upRegion?;
+    private downRegion?;
+    private trackAboveRegion?;
+    private trackBelowRegion?;
     constructor(display: Display, parent: AbstractContainerWidget);
+    init(): void;
+    destroy(): void;
+    private setScrollOffset;
+    private stepScrollRepeatedly;
+    private pageScrollRepeatedly;
+    private endScrollAction;
+    /**
+     * Auto Size ignores wrap_words and resizes the widget to fit the text on
+     * a single line, like LabelEditPart#getAutoSizeDimension() in Yamcs Studio
+     * (which is based on the unscaled TextFigure preferred size, not the
+     * wrapped WrappableTextFigure size).
+     */
+    drawHolder(g: Graphics): void;
     draw(g: Graphics): void;
     private drawText;
     private drawWrapped;
+    /**
+     * Vertical scrollbar for overflowing wrap_words content, matching
+     * draw2d's stock ScrollBar look (used by WrappableTextFigure's
+     * ScrollPane in Yamcs Studio): up/down bevel buttons plus a draggable
+     * thumb. Unlike Yamcs Studio, does not support mouse wheel, since neither
+     * does WrappableTextFigure/ScrollPane there.
+     */
+    private drawScrollbar;
+    private drawScrollButton;
     private wrapText;
     private wrapLine;
+    get autoSize(): boolean;
     get font(): Font;
     get horizAlignment(): number;
+    get showScrollbar(): boolean;
     get vertAlignment(): number;
     get wrapWords(): boolean;
 }

package/dist/types/widgets/graphics/Polygon.d.ts

@@ -5,8 +5,37 @@ import { Point } from "../../positioning";
 import { Widget } from "../../Widget";
 import { AbstractContainerWidget } from "../others/AbstractContainerWidget";
 export declare class Polygon extends Widget {
+    private zeroDegreePoints;
+    private originPoints?;
     constructor(display: Display, parent: AbstractContainerWidget);
     init(): void;
+    private updateZeroDegreePoints;
+    /**
+     * Mirrors AbstractPolyModel#doScale() in the Java reference, which is a
+     * two-step process, not a single uniform scale of each point:
+     *
+     * 1. The shape's bounding-box anchor (its own top-left corner) moves by
+     *    the FULL, unclamped widthRatio/heightRatio - same as any other
+     *    widget's x/y always does, regardless of its own ScaleOptions - so
+     *    the shape's position keeps up with the rest of the layout even when
+     *    the display auto-scales non-uniformly.
+     * 2. Only the points' offsets *relative to that already-repositioned
+     *    anchor* are then scaled by the ratio clamped against ScaleOptions
+     *    (e.g. keep_wh_ratio, which defaults to true for polygons) - so it's
+     *    just the shape's own internal proportions that stay locked, not its
+     *    position. Collapsing both steps into one clamped scale of the
+     *    absolute points (as an earlier version of this method did) makes a
+     *    keep_wh_ratio polygon barely move at all under non-uniform scaling,
+     *    clustering near its design position instead of tracking the layout.
+     *
+     * originPoints must be latched *before* the base autoScale call below:
+     * that call writes x/y, which synchronously fires the x/y listeners
+     * above and translates PROP_POINTS as a side effect. Capturing origin
+     * points afterwards would latch that already-shifted value forever
+     * (since this only runs once), corrupting every subsequent rescale
+     * including the revert back to the original size.
+     */
+    autoScale(widthRatio: number, heightRatio: number): void;
     draw(g: Graphics): void;
     private drawFill;
     get alpha(): number;
@@ -16,4 +45,5 @@ export declare class Polygon extends Widget {
     get lineColor(): Color;
     get lineStyle(): number;
     get points(): Point[];
+    get rotationAngle(): number;
 }