speechrecorderng 2.21.4 → 2.22.0

package/esm2020/lib/audio/ui/container.mjs

@@ -0,0 +1,431 @@
+import { HostListener, Input, Output, EventEmitter } from '@angular/core';
+import { AudioSignal } from './audiosignal';
+import { Sonagram } from './sonagram';
+import { Point } from './common';
+import { Component, ViewChild } from '@angular/core';
+import { Position, Dimension, Rectangle } from "../../math/2d/geometry";
+import { BasicAudioCanvasLayerComponent } from "./audio_canvas_layer_comp";
+import * as i0 from "@angular/core";
+import * as i1 from "./audiosignal";
+import * as i2 from "./sonagram";
+;
+;
+// // Declare Resizeobserver
+// declare class ResizeObserver{
+//   constructor(callback: ResizeObserverCallback);
+//   observe: (el:Element,opts: ResizeObserverBoxOptions | null)=>void;
+//   unobserve: (el:Element)=>void;
+//   disconnect: ()=>void;
+// }
+/*
+ * Container component for audio display.
+ * The display elements are children of a virtual canvas. The virtual canvas makes it possible to have high zoom factors with very wide virtual audio displays.
+ * Only the visible part of the virtual canvas is implemented as a browser canvas and therefore consuming memory.
+ * The visible part has the same width as the viewport of the scroll pane parent.
+ * The virtual canvas itself is implemented as a HTML div element.
+ * The layout of the component is updated on resize of the parent or changes of the zoom factor.
+ */
+export class AudioClipUIContainer extends BasicAudioCanvasLayerComponent {
+    constructor(ref) {
+        super();
+        this.ref = ref;
+        this._audioClip = null;
+        this.pointer = null;
+        this.selecting = null;
+        this.selection = null;
+        this.selectionEventEmitter = new EventEmitter();
+        this._playFramePosition = null;
+        this.dragStartMouseY = null;
+        this.dragStartY = null;
+        this.dividerPosition = 0.5;
+        this.userAction = false;
+        this._xZoom = null; // pixels per second
+        // if true the complete audio file is shown, the display fits to the visible panel, the x-zoom factor is variable, this is the default
+        this._fixFitToPanel = true;
+        this.parentE = this.ref.nativeElement;
+    }
+    get xZoom() {
+        return this._xZoom;
+    }
+    set xZoom(value) {
+        this.userAction = true;
+        this._xZoom = value;
+        this.layout();
+        this.userAction = false;
+    }
+    set fixFitToPanel(value) {
+        this._fixFitToPanel = value;
+        if (value) {
+            // we don't need  clip bounds
+            this.bounds = null;
+            this._xZoom = null;
+        }
+        else {
+            // hold current zoom value
+            //this._xZoom=this.ce.offsetWidth/this._audioData.duration;
+        }
+        this.layout();
+    }
+    ngOnInit() {
+        this.ce = this.ceRef.nativeElement;
+        this.dc = this.canvasRef.nativeElement;
+    }
+    ngAfterViewInit() {
+        this.layout();
+        let heightListener = new MutationObserver((mrs, mo) => {
+            let layout = false;
+            mrs.forEach((mr) => {
+                if (!this.userAction && 'attributes' === mr.type && ('class' === mr.attributeName || 'style' === mr.attributeName)) {
+                    layout = true;
+                }
+            });
+            if (layout) {
+                // re-layout required
+                this.layout(false);
+            }
+        });
+        heightListener.observe(this.ce, { attributes: true, childList: true, characterData: true });
+        heightListener.observe(this.dc, { attributes: true, childList: true, characterData: true });
+        let resizeObserver = new ResizeObserver((entries, obs) => {
+            //console.log("Resize observed:");
+            entries.forEach((e) => {
+                //console.log(e.contentRect.width+"x"+e.contentRect.height);
+                this.layout();
+            });
+        });
+        resizeObserver.observe(this.ce);
+    }
+    onResize(event) {
+        this.layout();
+    }
+    mouseover(me) {
+        this.dividerCursorPosition(me, true);
+    }
+    mouseleave(me) {
+        this.dividerCursorPosition(me, false);
+    }
+    mousedown(me) {
+        this.dragStartMouseY = me.clientY;
+        this.dragStartY = this.dc.offsetTop;
+        this.dragStartMouseY = me.clientY;
+    }
+    onMouseup(me) {
+        if (this.dragStartY != null) {
+            this.userAction = true;
+            this.dividerDrag(me);
+            this.layout(false);
+            this.dragStartY = null;
+            this.userAction = false;
+        }
+    }
+    onMousemove(me) {
+        if (this.dragStartY != null) {
+            this.userAction = true;
+            this.dividerDrag(me);
+            this.layoutScaled();
+            this.userAction = true;
+        }
+    }
+    pointerPositionChanged(pp) {
+        this.pointer = pp;
+    }
+    selectingChanged(s) {
+        this.selecting = s;
+    }
+    selectionChanged(s) {
+        this.selection = s;
+        if (this._audioClip) {
+            this._audioClip.selection = s;
+        }
+        this.selectionEventEmitter.emit(this.selection);
+    }
+    canvasMousePos(c, e) {
+        const cr = c.getBoundingClientRect();
+        const x = e.x - cr.left;
+        const y = e.y - cr.top;
+        return new Point(x, y);
+    }
+    dividerCursorPosition(e, show) {
+        if (this.dc) {
+            const w = this.dc.width;
+            const h = this.dc.height;
+            const g = this.dc.getContext('2d');
+            const pp = this.canvasMousePos(this.dc, e);
+            const offX = e.offsetX - this.dc.offsetLeft;
+            const offY = e.offsetY - this.dc.offsetTop;
+        }
+    }
+    dividerDrag(e) {
+        if (this.dc && this.dragStartMouseY && this.dragStartY) {
+            const dragOffset = e.clientY - this.dragStartMouseY;
+            const ceHeight = this.ce.offsetHeight;
+            let newTop = (this.dragStartY + dragOffset);
+            if (newTop < 0) {
+                newTop = 0;
+            }
+            if (newTop > ceHeight - AudioClipUIContainer.DIVIDER_PIXEL_SIZE) {
+                newTop = ceHeight - AudioClipUIContainer.DIVIDER_PIXEL_SIZE;
+            }
+            this.dc.style.top = newTop.toString() + 'px';
+            this.dividerPosition = (this.dc.offsetTop + AudioClipUIContainer.DIVIDER_PIXEL_SIZE / 2) / ceHeight;
+            if (this.dividerPosition > 1.0) {
+                this.dividerPosition = 1.0;
+            }
+            if (this.dividerPosition < 0.0) {
+                this.dividerPosition = 0.0;
+            }
+            this.drawDivider();
+        }
+    }
+    drawDivider() {
+        const w = this.dc.width;
+        const h = this.dc.height;
+        const g = this.dc.getContext('2d');
+        if (g && w > 10 && h >= 1) {
+            g.fillStyle = 'white';
+            g.fillRect(0, 0, w, h);
+            g.fillStyle = 'black';
+            g.fillRect(5, 5, w - 10, 1);
+        }
+    }
+    clipBounds(clipBounds) {
+        this.bounds = clipBounds;
+        this.layout();
+    }
+    currentXZoom() {
+        let xz = this._xZoom;
+        if (xz == null && this._audioData) {
+            let ow = this.ce.offsetWidth;
+            if (ow < 1) {
+                // at least one pixel width to avoid x-zoom zero values
+                ow = 1;
+            }
+            xz = ow / this._audioData.duration;
+        }
+        return xz;
+    }
+    _layout(clear, redraw) {
+        let ceBcr = this.ce.getBoundingClientRect();
+        const ceBcrIntW = Math.floor(ceBcr.width);
+        const ceBcrIntH = Math.floor(ceBcr.height);
+        // height available for plugins (audiosignal and sonagram)
+        let psH = ceBcrIntH - AudioClipUIContainer.DIVIDER_PIXEL_SIZE;
+        if (psH < 0) {
+            psH = 0;
+        }
+        // audio signal height
+        const asH = Math.round(psH * this.dividerPosition);
+        // sonagram height (rest: available height minus divider height minus audiosignal height)
+        let soH = ceBcrIntH - AudioClipUIContainer.DIVIDER_PIXEL_SIZE - asH;
+        if (soH < 0) {
+            soH = 0;
+        }
+        // sonagram top position
+        const soTop = asH + AudioClipUIContainer.DIVIDER_PIXEL_SIZE;
+        // Visible bounds
+        // left position
+        let vbLeft = 0;
+        // width
+        let vbWidth = ceBcrIntW;
+        if (!this._fixFitToPanel && this.bounds) {
+            vbLeft = Math.round(this.bounds.position.left);
+            vbWidth = Math.round(this.bounds.dimension.width);
+        }
+        // Divider
+        // left position
+        let vbLeftStyl = vbLeft + 'px';
+        if (this.dc.style.left != vbLeftStyl) {
+            this.dc.style.left = vbLeftStyl;
+        }
+        // top position
+        const dTop = asH;
+        const dTopStr = dTop + 'px';
+        if (this.dc.style.top != dTopStr) {
+            this.dc.style.top = dTopStr;
+        }
+        // width
+        let vbWidthStyle = vbWidth + 'px';
+        if (this.dc.style.width != vbWidthStyle) {
+            this.dc.style.width = vbWidthStyle;
+        }
+        if (this.dc.width != vbWidth) {
+            this.dc.width = vbWidth;
+        }
+        // height
+        if (this.dc.height != AudioClipUIContainer.DIVIDER_PIXEL_SIZE) {
+            this.dc.height = AudioClipUIContainer.DIVIDER_PIXEL_SIZE;
+        }
+        let divPixelSizeStyle = AudioClipUIContainer.DIVIDER_PIXEL_SIZE.toString() + 'px';
+        if (this.dc.style.height != divPixelSizeStyle) {
+            this.dc.style.height = divPixelSizeStyle;
+        }
+        this.drawDivider();
+        // Virtual dimension, only width is used
+        let virtualDim = new Dimension(ceBcrIntW, 0);
+        // Visible bounds of container
+        let br = new Rectangle(new Position(vbLeft, 0), new Dimension(vbWidth, ceBcrIntH));
+        // Set container bounds
+        this.layoutBounds(br, virtualDim, false);
+        // Visible bounds of audiosignal
+        let asR = new Rectangle(new Position(vbLeft, 0), new Dimension(vbWidth, asH));
+        // Set audiosignal bounds
+        this.as.layoutBounds(asR, virtualDim, redraw, clear);
+        // Visible bounds of sonagram
+        let soR = new Rectangle(new Position(vbLeft, soTop), new Dimension(vbWidth, soH));
+        // Set sonagram bounds
+        this.so.layoutBounds(soR, virtualDim, redraw, clear);
+    }
+    layoutScaled() {
+        this._layout(false, false);
+    }
+    layout(clear = true) {
+        if (this.ce && this.dc) {
+            const clientW = this.ce.clientWidth;
+            if (this._audioData) {
+                if (this._fixFitToPanel) {
+                    // Set the virtual canvas width to the visible width
+                    if (this.ce.style.width != '100%') {
+                        //console.log("set width to 100%");
+                        this.ce.style.width = '100%';
+                    }
+                }
+                else {
+                    if (this._xZoom) {
+                        // Set the virtual canvas width according to the value of the user selected xZoom value
+                        const newClW = Math.round(this._xZoom * this._audioData.duration);
+                        this.ce.style.width = newClW + 'px';
+                    }
+                    else {
+                        // Set the virtual canvas width to the visible width only
+                        this.ce.style.width = clientW + 'px';
+                    }
+                }
+            }
+            this._layout(clear, true);
+        }
+    }
+    set audioData(audioData) {
+        this._audioClip = null;
+        this._audioData = audioData;
+        this.as.setData(audioData);
+        this.so.setData(audioData);
+        this.layout();
+    }
+    get audioData() {
+        return this._audioData;
+    }
+    set audioClip(audioClip) {
+        this._audioClip = audioClip;
+        let audioData = null;
+        let sel = null;
+        if (audioClip) {
+            audioData = audioClip.buffer;
+            if (this._audioClip) {
+                this._audioClip.addSelectionObserver((clip) => {
+                    this.selection = clip.selection;
+                });
+            }
+            sel = audioClip.selection;
+        }
+        this._audioData = audioData;
+        this.as.setData(this._audioData);
+        this.so.setData(this._audioData);
+        this.selecting = null;
+        this.selection = sel;
+        this.layout();
+    }
+    get playFramePosition() {
+        return this._playFramePosition;
+    }
+    set playFramePosition(playFramePosition) {
+        this._playFramePosition = playFramePosition;
+        this.as.playFramePosition = playFramePosition;
+        this.so.playFramePosition = playFramePosition;
+    }
+}
+AudioClipUIContainer.DIVIDER_PIXEL_SIZE = 10;
+AudioClipUIContainer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: AudioClipUIContainer, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+AudioClipUIContainer.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.1", type: AudioClipUIContainer, selector: "app-audio", inputs: { audioData: "audioData", audioClip: "audioClip" }, outputs: { selectionEventEmitter: "selectionEventEmitter" }, host: { listeners: { "window:resize": "onResize($event)", "document:mouseup": "onMouseup($event)", "document:mousemove": "onMousemove($event)" } }, viewQueries: [{ propertyName: "canvasRef", first: true, predicate: ["divider"], descendants: true, static: true }, { propertyName: "ceRef", first: true, predicate: ["virtualCanvas"], descendants: true, static: true }, { propertyName: "as", first: true, predicate: AudioSignal, descendants: true, static: true }, { propertyName: "so", first: true, predicate: Sonagram, descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: `
+    <div #virtualCanvas>
+    <canvas #divider (mousedown)="mousedown($event)" (mouseover)="mouseover($event)"
+            (mouseleave)="mouseleave($event)" height="10"></canvas>
+    <audio-signal [pointerPosition]="pointer" [selecting]="selecting" [selection]="selection" (pointerPositionEventEmitter)="pointerPositionChanged($event)" (selectingEventEmitter)="selectingChanged($event)" (selectedEventEmitter)="selectionChanged($event)"></audio-signal>
+    <audio-sonagram [pointerPosition]="pointer" [selecting]="selecting" [selection]="selection" (pointerPositionEventEmitter)="pointerPositionChanged($event)" (selectingEventEmitter)="selectingChanged($event)" (selectedEventEmitter)="selectionChanged($event)"></audio-sonagram>
+    </div>
+  `, isInline: true, styles: ["div{margin:0;padding:0;top:0;left:0;width:100%;height:100%;position:relative;box-sizing:border-box;transform:none;overflow:hidden}\n", "canvas{top:0;left:0;width:0;height:0;cursor:ns-resize;position:absolute;zIndex:1;transform:none}\n", "audio-signal{top:0;left:0;position:absolute;zIndex:1;transform:none}\n", "audio-sonagram{top:0;left:0;position:absolute;zIndex:1;transform:none}\n"], components: [{ type: i1.AudioSignal, selector: "audio-signal" }, { type: i2.Sonagram, selector: "audio-sonagram" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: AudioClipUIContainer, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-audio',
+                    template: `
+    <div #virtualCanvas>
+    <canvas #divider (mousedown)="mousedown($event)" (mouseover)="mouseover($event)"
+            (mouseleave)="mouseleave($event)" height="10"></canvas>
+    <audio-signal [pointerPosition]="pointer" [selecting]="selecting" [selection]="selection" (pointerPositionEventEmitter)="pointerPositionChanged($event)" (selectingEventEmitter)="selectingChanged($event)" (selectedEventEmitter)="selectionChanged($event)"></audio-signal>
+    <audio-sonagram [pointerPosition]="pointer" [selecting]="selecting" [selection]="selection" (pointerPositionEventEmitter)="pointerPositionChanged($event)" (selectingEventEmitter)="selectingChanged($event)" (selectedEventEmitter)="selectionChanged($event)"></audio-sonagram>
+    </div>
+  `,
+                    styles: [`div {
+
+    margin: 0;
+    padding: 0;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    position: relative; /* TODO container div position must not be 'static' (default) to act as reference for the canvases */
+    box-sizing: border-box;
+    transform: none;
+    overflow: hidden;
+  }`, `canvas{
+    top: 0;
+    left: 0;
+    width: 0;
+    height: 0;
+    cursor: ns-resize;
+    position: absolute;
+    zIndex: 1;
+    transform: none;
+  }`, `audio-signal {
+    top: 0;
+    left: 0;
+    position: absolute;
+    zIndex: 1;
+    transform: none;
+  }`, `audio-sonagram {
+    top: 0;
+    left: 0;
+    position: absolute;
+    zIndex: 1;
+    transform: none;
+  }`]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { canvasRef: [{
+                type: ViewChild,
+                args: ['divider', { static: true }]
+            }], ceRef: [{
+                type: ViewChild,
+                args: ['virtualCanvas', { static: true }]
+            }], as: [{
+                type: ViewChild,
+                args: [AudioSignal, { static: true }]
+            }], so: [{
+                type: ViewChild,
+                args: [Sonagram, { static: true }]
+            }], selectionEventEmitter: [{
+                type: Output
+            }], onResize: [{
+                type: HostListener,
+                args: ['window:resize', ['$event']]
+            }], onMouseup: [{
+                type: HostListener,
+                args: ['document:mouseup', ['$event']]
+            }], onMousemove: [{
+                type: HostListener,
+                args: ['document:mousemove', ['$event']]
+            }], audioData: [{
+                type: Input
+            }], audioClip: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"container.js","sourceRoot":"","sources":["../../../../../../projects/speechrecorderng/src/lib/audio/ui/container.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ElementRef, AfterViewInit, HostListener, Input, OnInit, Output, EventEmitter\r\n} from '@angular/core'\r\nimport {AudioSignal} from './audiosignal'\r\nimport {Sonagram} from './sonagram'\r\nimport {Marker, Point} from './common'\r\n\r\nimport {Component, ViewChild} from '@angular/core';\r\nimport {Position,Dimension, Rectangle} from \"../../math/2d/geometry\";\r\nimport {AudioClip,Selection} from \"../persistor\";\r\nimport {BasicAudioCanvasLayerComponent} from \"./audio_canvas_layer_comp\";\r\nimport {Element} from \"@angular/compiler\";\r\n\r\n/*\r\n  ResizeObserver not yet available in official Typescript declaration\r\n  Crreated declaration from IDL until its available.\r\n  See specs:\r\n  https://www.w3.org/TR/resize-observer\r\n\r\n */\r\n\r\ninterface ResizeObserverSize {\r\n  readonly inlineSize:number;\r\n  readonly blockSize:number;\r\n};\r\n\r\ndeclare interface ResizeObserverEntry{\r\n  readonly target: Element;\r\n  readonly contentRect: DOMRectReadOnly ;\r\n  readonly borderBoxSize: Array<ResizeObserverSize> ;\r\n  readonly contentBoxSize: Array<ResizeObserverSize> ;\r\n  readonly devicePixelContentBoxSize: Array<ResizeObserverSize> ;\r\n}\r\n\r\ndeclare interface ResizeObserverCallback {\r\n  (entries: Array<ResizeObserverEntry>, observer: ResizeObserver):void;\r\n}\r\n\r\ndeclare enum ResizeObserverBoxOptions {\r\n  \"border-box\", \"content-box\", \"device-pixel-content-box\"\r\n};\r\n\r\n// // Declare Resizeobserver\r\n// declare class ResizeObserver{\r\n//   constructor(callback: ResizeObserverCallback);\r\n//   observe: (el:Element,opts: ResizeObserverBoxOptions | null)=>void;\r\n//   unobserve: (el:Element)=>void;\r\n//   disconnect: ()=>void;\r\n// }\r\n\r\n/*\r\n * Container component for audio display.\r\n * The display elements are children of a virtual canvas. The virtual canvas makes it possible to have high zoom factors with very wide virtual audio displays.\r\n * Only the visible part of the virtual canvas is implemented as a browser canvas and therefore consuming memory.\r\n * The visible part has the same width as the viewport of the scroll pane parent.\r\n * The virtual canvas itself is implemented as a HTML div element.\r\n * The layout of the component is updated on resize of the parent or changes of the zoom factor.\r\n */\r\n@Component({\r\n\r\n  selector: 'app-audio',\r\n  template: `\r\n    <div #virtualCanvas>\r\n    <canvas #divider (mousedown)=\"mousedown($event)\" (mouseover)=\"mouseover($event)\"\r\n            (mouseleave)=\"mouseleave($event)\" height=\"10\"></canvas>\r\n    <audio-signal [pointerPosition]=\"pointer\" [selecting]=\"selecting\" [selection]=\"selection\" (pointerPositionEventEmitter)=\"pointerPositionChanged($event)\" (selectingEventEmitter)=\"selectingChanged($event)\" (selectedEventEmitter)=\"selectionChanged($event)\"></audio-signal>\r\n    <audio-sonagram [pointerPosition]=\"pointer\" [selecting]=\"selecting\" [selection]=\"selection\" (pointerPositionEventEmitter)=\"pointerPositionChanged($event)\" (selectingEventEmitter)=\"selectingChanged($event)\" (selectedEventEmitter)=\"selectionChanged($event)\"></audio-sonagram>\r\n    </div>\r\n  `,\r\n  styles: [`div {\r\n\r\n    margin: 0;\r\n    padding: 0;\r\n    top: 0;\r\n    left: 0;\r\n    width: 100%;\r\n    height: 100%;\r\n    position: relative; /* TODO container div position must not be 'static' (default) to act as reference for the canvases */\r\n    box-sizing: border-box;\r\n    transform: none;\r\n    overflow: hidden;\r\n  }`, `canvas{\r\n    top: 0;\r\n    left: 0;\r\n    width: 0;\r\n    height: 0;\r\n    cursor: ns-resize;\r\n    position: absolute;\r\n    zIndex: 1;\r\n    transform: none;\r\n  }`, `audio-signal {\r\n    top: 0;\r\n    left: 0;\r\n    position: absolute;\r\n    zIndex: 1;\r\n    transform: none;\r\n  }`, `audio-sonagram {\r\n    top: 0;\r\n    left: 0;\r\n    position: absolute;\r\n    zIndex: 1;\r\n    transform: none;\r\n  }`]\r\n\r\n})\r\nexport class AudioClipUIContainer extends BasicAudioCanvasLayerComponent implements OnInit,AfterViewInit{\r\n\r\n  private static DIVIDER_PIXEL_SIZE = 10;\r\n\r\n  parentE: HTMLElement;\r\n\r\n  // Divider canvas\r\n  @ViewChild('divider', { static: true }) canvasRef!: ElementRef;\r\n  dc!: HTMLCanvasElement;\r\n\r\n  // Virtual container\r\n  @ViewChild('virtualCanvas', { static: true }) ceRef!: ElementRef;\r\n  ce!: HTMLDivElement;\r\n\r\n  @ViewChild(AudioSignal, { static: true }) as!: AudioSignal;\r\n  @ViewChild(Sonagram, { static: true }) so!: Sonagram;\r\n\r\n  private _audioClip:AudioClip | null=null;\r\n  pointer: Marker|null=null;\r\n  selecting: Selection|null=null;\r\n  selection: Selection|null=null;\r\n  @Output() selectionEventEmitter = new EventEmitter<Selection>();\r\n  private _playFramePosition: number|null=null;\r\n  private dragStartMouseY: number | null = null;\r\n  private dragStartY: number | null = null;\r\n  private dividerPosition = 0.5;\r\n\r\n  userAction=false;\r\n\r\n  private _xZoom: number | null = null; // pixels per second\r\n\r\n  get xZoom(): number | null {\r\n    return this._xZoom;\r\n  }\r\n\r\n  set xZoom(value: number | null) {\r\n    this.userAction=true;\r\n    this._xZoom = value;\r\n    this.layout()\r\n    this.userAction=false;\r\n  }\r\n\r\n  // if true the complete audio file is shown, the display fits to the visible panel, the x-zoom factor is variable, this is the default\r\n  private _fixFitToPanel = true;\r\n\r\n  set fixFitToPanel(value: boolean) {\r\n    this._fixFitToPanel = value;\r\n    if (value) {\r\n      // we don't need  clip bounds\r\n      this.bounds=null;\r\n      this._xZoom = null;\r\n    } else {\r\n      // hold current zoom value\r\n      //this._xZoom=this.ce.offsetWidth/this._audioData.duration;\r\n    }\r\n    this.layout()\r\n  }\r\n\r\n  constructor(private ref: ElementRef) {\r\n    super()\r\n    this.parentE = this.ref.nativeElement;\r\n  }\r\n\r\n  ngOnInit() {\r\n    this.ce = this.ceRef.nativeElement;\r\n    this.dc = this.canvasRef.nativeElement;\r\n  }\r\n\r\n  ngAfterViewInit() {\r\n    this.layout();\r\n    let heightListener = new MutationObserver((mrs: Array<MutationRecord>, mo: MutationObserver) => {\r\n\r\n      let layout=false;\r\n      mrs.forEach((mr: MutationRecord) => {\r\n        if (!this.userAction && 'attributes' === mr.type && ('class' === mr.attributeName || 'style' === mr.attributeName)) {\r\n          layout=true;\r\n        }\r\n      });\r\n      if(layout){\r\n        // re-layout required\r\n        this.layout(false);\r\n      }\r\n    });\r\n\r\n    heightListener.observe(this.ce, {attributes: true, childList: true, characterData: true});\r\n    heightListener.observe(this.dc, {attributes: true, childList: true, characterData: true});\r\n\r\n    let resizeObserver = new ResizeObserver((entries,obs) => {\r\n      //console.log(\"Resize observed:\");\r\n      entries.forEach((e)=>{\r\n        //console.log(e.contentRect.width+\"x\"+e.contentRect.height);\r\n        this.layout();\r\n      })\r\n    });\r\n\r\n    resizeObserver.observe(this.ce);\r\n\r\n  }\r\n\r\n  @HostListener('window:resize', ['$event'])\r\n  onResize(event: Event): void {\r\n    this.layout();\r\n  }\r\n\r\n  mouseover(me: MouseEvent) {\r\n    this.dividerCursorPosition(me, true);\r\n  }\r\n\r\n  mouseleave(me: MouseEvent) {\r\n    this.dividerCursorPosition(me, false);\r\n  }\r\n\r\n  mousedown(me: MouseEvent) {\r\n    this.dragStartMouseY = me.clientY;\r\n    this.dragStartY = this.dc.offsetTop;\r\n    this.dragStartMouseY = me.clientY;\r\n  }\r\n\r\n  @HostListener('document:mouseup', ['$event'])\r\n  onMouseup(me: MouseEvent) {\r\n    if (this.dragStartY != null) {\r\n      this.userAction=true;\r\n      this.dividerDrag(me);\r\n      this.layout(false);\r\n      this.dragStartY = null;\r\n      this.userAction=false;\r\n    }\r\n  }\r\n\r\n  @HostListener('document:mousemove', ['$event'])\r\n  onMousemove(me: MouseEvent) {\r\n    if (this.dragStartY != null) {\r\n      this.userAction=true;\r\n      this.dividerDrag(me);\r\n      this.layoutScaled();\r\n      this.userAction=true;\r\n    }\r\n  }\r\n\r\n  pointerPositionChanged(pp:Marker){\r\n    this.pointer=pp\r\n  }\r\n\r\n  selectingChanged(s:Selection| null){\r\n    this.selecting=s\r\n  }\r\n\r\n  selectionChanged(s:Selection){\r\n    this.selection=s\r\n    if(this._audioClip){\r\n      this._audioClip.selection=s\r\n    }\r\n    this.selectionEventEmitter.emit(this.selection)\r\n  }\r\n\r\n  private canvasMousePos(c: HTMLCanvasElement, e: MouseEvent): Point {\r\n    const cr = c.getBoundingClientRect();\r\n    const x = e.x - cr.left;\r\n    const y = e.y - cr.top;\r\n    return new Point(x,y);\r\n  }\r\n\r\n  dividerCursorPosition(e: MouseEvent, show: boolean) {\r\n    if (this.dc) {\r\n\r\n      const w = this.dc.width;\r\n      const h = this.dc.height;\r\n      const g = this.dc.getContext('2d');\r\n\r\n      const pp = this.canvasMousePos(this.dc, e);\r\n      const offX = e.offsetX - this.dc.offsetLeft;\r\n      const offY = e.offsetY - this.dc.offsetTop;\r\n\r\n    }\r\n  }\r\n\r\n  dividerDrag(e: MouseEvent) {\r\n    if (this.dc && this.dragStartMouseY && this.dragStartY) {\r\n\r\n      const dragOffset = e.clientY - this.dragStartMouseY;\r\n      const ceHeight = this.ce.offsetHeight;\r\n\r\n      let newTop = (this.dragStartY + dragOffset);\r\n      if (newTop < 0) {\r\n        newTop = 0;\r\n      }\r\n      if (newTop > ceHeight - AudioClipUIContainer.DIVIDER_PIXEL_SIZE) {\r\n        newTop = ceHeight - AudioClipUIContainer.DIVIDER_PIXEL_SIZE;\r\n      }\r\n      this.dc.style.top = newTop.toString() + 'px';\r\n      this.dividerPosition = (this.dc.offsetTop + AudioClipUIContainer.DIVIDER_PIXEL_SIZE / 2) / ceHeight;\r\n      if (this.dividerPosition > 1.0) {\r\n        this.dividerPosition = 1.0;\r\n      }\r\n      if (this.dividerPosition < 0.0) {\r\n        this.dividerPosition = 0.0;\r\n      }\r\n      this.drawDivider();\r\n    }\r\n  }\r\n\r\n\r\n  drawDivider() {\r\n    const w = this.dc.width;\r\n    const h = this.dc.height;\r\n    const g = this.dc.getContext('2d');\r\n    if (g && w>10 && h>=1) {\r\n      g.fillStyle = 'white';\r\n      g.fillRect(0, 0, w, h);\r\n      g.fillStyle = 'black';\r\n      g.fillRect(5, 5, w - 10, 1);\r\n    }\r\n  }\r\n\r\n  clipBounds(clipBounds: Rectangle) {\r\n    this.bounds = clipBounds;\r\n    this.layout();\r\n  }\r\n\r\n  currentXZoom(): number | null {\r\n    let xz = this._xZoom;\r\n    if (xz==null && this._audioData) {\r\n      let ow = this.ce.offsetWidth;\r\n      if (ow < 1) {\r\n        // at least one pixel width to avoid x-zoom zero values\r\n        ow = 1;\r\n      }\r\n      xz = ow / this._audioData.duration;\r\n    }\r\n    return xz;\r\n  }\r\n\r\n  private _layout(clear: boolean, redraw: boolean) {\r\n    let ceBcr = this.ce.getBoundingClientRect();\r\n\r\n    const ceBcrIntW = Math.floor(ceBcr.width);\r\n    const ceBcrIntH = Math.floor(ceBcr.height);\r\n\r\n    // height available for plugins (audiosignal and sonagram)\r\n    let psH = ceBcrIntH - AudioClipUIContainer.DIVIDER_PIXEL_SIZE;\r\n    if (psH < 0) {\r\n      psH = 0;\r\n    }\r\n    // audio signal height\r\n    const asH = Math.round(psH * this.dividerPosition);\r\n\r\n    // sonagram height (rest: available height minus divider height minus audiosignal height)\r\n    let soH = ceBcrIntH - AudioClipUIContainer.DIVIDER_PIXEL_SIZE - asH;\r\n    if (soH < 0) {\r\n      soH = 0;\r\n    }\r\n\r\n  // sonagram top position\r\n    const soTop = asH + AudioClipUIContainer.DIVIDER_PIXEL_SIZE;\r\n\r\n    // Visible bounds\r\n    // left position\r\n    let vbLeft = 0;\r\n    // width\r\n    let vbWidth = ceBcrIntW;\r\n    if (!this._fixFitToPanel && this.bounds) {\r\n      vbLeft = Math.round(this.bounds.position.left);\r\n      vbWidth = Math.round(this.bounds.dimension.width);\r\n    }\r\n\r\n    // Divider\r\n    // left position\r\n    let vbLeftStyl = vbLeft + 'px';\r\n    if (this.dc.style.left != vbLeftStyl) {\r\n      this.dc.style.left = vbLeftStyl;\r\n    }\r\n    // top position\r\n    const dTop = asH;\r\n    const dTopStr = dTop + 'px';\r\n    if (this.dc.style.top != dTopStr) {\r\n      this.dc.style.top = dTopStr;\r\n    }\r\n    // width\r\n    let vbWidthStyle = vbWidth + 'px';\r\n    if (this.dc.style.width != vbWidthStyle) {\r\n      this.dc.style.width = vbWidthStyle;\r\n    }\r\n    if (this.dc.width != vbWidth) {\r\n      this.dc.width = vbWidth;\r\n    }\r\n    // height\r\n    if(this.dc.height!=AudioClipUIContainer.DIVIDER_PIXEL_SIZE) {\r\n      this.dc.height = AudioClipUIContainer.DIVIDER_PIXEL_SIZE;\r\n\r\n    }\r\n    let divPixelSizeStyle=AudioClipUIContainer.DIVIDER_PIXEL_SIZE.toString() + 'px';\r\n    if(this.dc.style.height!=divPixelSizeStyle) {\r\n      this.dc.style.height = divPixelSizeStyle;\r\n    }\r\n\r\n    this.drawDivider();\r\n\r\n\r\n    // Virtual dimension, only width is used\r\n    let virtualDim = new Dimension(ceBcrIntW, 0)\r\n\r\n    // Visible bounds of container\r\n    let br = new Rectangle(new Position(vbLeft, 0), new Dimension(vbWidth, ceBcrIntH));\r\n\r\n    // Set container bounds\r\n    this.layoutBounds(br, virtualDim, false);\r\n\r\n    // Visible bounds of audiosignal\r\n    let asR = new Rectangle(new Position(vbLeft, 0), new Dimension(vbWidth, asH));\r\n\r\n    // Set audiosignal bounds\r\n    this.as.layoutBounds(asR, virtualDim, redraw, clear);\r\n\r\n    // Visible bounds of sonagram\r\n    let soR = new Rectangle(new Position(vbLeft, soTop), new Dimension(vbWidth, soH));\r\n\r\n    // Set sonagram bounds\r\n    this.so.layoutBounds(soR, virtualDim, redraw, clear);\r\n  }\r\n\r\n  layoutScaled() {\r\n    this._layout(false, false);\r\n  }\r\n\r\n  layout(clear=true) {\r\n\r\n    if(this.ce && this.dc) {\r\n      const clientW=this.ce.clientWidth;\r\n      if(this._audioData){\r\n        if(this._fixFitToPanel) {\r\n          // Set the virtual canvas width to the visible width\r\n          if(this.ce.style.width!='100%') {\r\n            //console.log(\"set width to 100%\");\r\n            this.ce.style.width = '100%';\r\n          }\r\n        }else{\r\n          if (this._xZoom) {\r\n            // Set the virtual canvas width according to the value of the user selected xZoom value\r\n            const newClW = Math.round( this._xZoom*this._audioData.duration );\r\n            this.ce.style.width = newClW + 'px';\r\n          } else {\r\n            // Set the virtual canvas width to the visible width only\r\n            this.ce.style.width = clientW + 'px';\r\n          }\r\n        }\r\n      }\r\n      this._layout(clear,true);\r\n    }\r\n  }\r\n\r\n  @Input()\r\n  set audioData(audioData: AudioBuffer | null) {\r\n    this._audioClip=null\r\n    this._audioData=audioData;\r\n    this.as.setData(audioData);\r\n    this.so.setData(audioData);\r\n    this.layout();\r\n  }\r\n\r\n  get audioData():AudioBuffer|null{\r\n    return this._audioData\r\n  }\r\n\r\n  @Input()\r\n  set audioClip(audioClip: AudioClip | null) {\r\n    this._audioClip=audioClip\r\n      let audioData:AudioBuffer|null=null;\r\n    let sel:Selection|null=null;\r\n      if(audioClip) {\r\n        audioData = audioClip.buffer;\r\n        if (this._audioClip) {\r\n          this._audioClip.addSelectionObserver((clip) => {\r\n            this.selection = clip.selection\r\n          });\r\n        }\r\n        sel=audioClip.selection;\r\n      }\r\n      this._audioData = audioData;\r\n      this.as.setData(this._audioData);\r\n      this.so.setData(this._audioData);\r\n      this.selecting=null\r\n      this.selection=sel\r\n    this.layout();\r\n  }\r\n\r\n  get playFramePosition(): number |null {\r\n    return this._playFramePosition;\r\n  }\r\n\r\n  set playFramePosition(playFramePosition: number|null) {\r\n    this._playFramePosition = playFramePosition;\r\n    this.as.playFramePosition = playFramePosition;\r\n    this.so.playFramePosition = playFramePosition;\r\n  }\r\n}\r\n\r\n"]}