@rocketshow/designer 1.32.0 → 1.35.0

package/esm2022/lib/services/timeline.service.mjs

@@ -0,0 +1,726 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Subject, timer } from 'rxjs';
+import { map } from 'rxjs/operators';
+import WaveSurfer from 'wavesurfer.js';
+import CursorPlugin from 'wavesurfer.js/dist/plugin/wavesurfer.cursor.min.js';
+import RegionsPlugin from 'wavesurfer.js/dist/plugin/wavesurfer.regions.min.js';
+import TimeLinePlugin from 'wavesurfer.js/dist/plugin/wavesurfer.timeline.min.js';
+import { guess } from 'web-audio-beat-detector';
+import { PresetRegionScene } from '../models/preset-region-scene';
+import { ScenePlaybackRegion } from '../models/scene-playback-region';
+import { ConfigService } from './config.service';
+import { PresetService } from './preset.service';
+import { ProjectService } from './project.service';
+import { SceneService } from './scene.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./scene.service";
+import * as i2 from "./preset.service";
+import * as i3 from "./project.service";
+import * as i4 from "@angular/common/http";
+import * as i5 from "./config.service";
+export class TimelineService {
+    constructor(sceneService, presetService, projectService, http, configService) {
+        this.sceneService = sceneService;
+        this.presetService = presetService;
+        this.projectService = projectService;
+        this.http = http;
+        this.configService = configService;
+        this.playState = 'paused';
+        this.zoom = 0;
+        this.timelineClicking = false;
+        this.intensity = 0.2;
+        this.intensitySelectedScene = 0.4;
+        this.intensityHighlighted = 0.8;
+        this.waveSurferReady = new Subject();
+        this.detectChanges = new Subject();
+        // can we add new compositions based on an external pool and
+        // should new compositions not available in this pool be added there?
+        this.externalCompositionsAvailable = false;
+        this.loadingAudioFile = false;
+        this.presetService.previewSelectionChanged.subscribe(() => {
+            this.selectedPlaybackRegion = undefined;
+            this.updateRegionSelection();
+        });
+        this.sceneService.sceneDeleted.subscribe(() => {
+            this.redrawAllRegions();
+        });
+        this.sceneService.sceneSelected.subscribe(() => {
+            this.redrawAllRegions();
+        });
+    }
+    redrawAllRegions() {
+        // remove all regions from wavesurver
+        if (this.waveSurfer) {
+            for (const key of Object.keys(this.waveSurfer.regions.list)) {
+                const region = this.waveSurfer.regions.list[key];
+                region.remove();
+            }
+        }
+        // draw all regions
+        this.drawAllRegions();
+    }
+    pad(num, size) {
+        if (!num) {
+            num = 0;
+        }
+        let padded = num.toString();
+        while (padded.length < size) {
+            padded = '0' + padded;
+        }
+        return padded;
+    }
+    msToTime(millis, includeMillis = true) {
+        const ms = Math.round(millis % 1000);
+        const seconds = Math.floor(((millis % 360000) % 60000) / 1000);
+        const minutes = Math.floor((millis % 3600000) / 60000);
+        if (includeMillis) {
+            return this.pad(minutes, 2) + ':' + this.pad(seconds, 2) + '.' + this.pad(ms, 3);
+        }
+        else {
+            return this.pad(minutes, 2) + ':' + this.pad(seconds, 2);
+        }
+    }
+    updateCurrentTime() {
+        if (!this.waveSurfer) {
+            return;
+        }
+        // display the current time
+        this.currentTime = this.msToTime(this.waveSurfer.getCurrentTime() * 1000);
+        if (!this.waveSurfer.timeline.drawer) {
+            return;
+        }
+        // draw the current cursor on the timeline
+        // TODO redrawing the timeline each update is way to expensive.
+        // maybe as a better solution use an element, like the cursor inside Wavesurfer to
+        // display the progress?
+        let x = 0;
+        const duration = this.waveSurfer.backend.getDuration();
+        const width = this.waveSurfer.params.fillParent && !this.waveSurfer.params.scrollParent
+            ? this.waveSurfer.timeline.drawer.getWidth()
+            : this.waveSurfer.timeline.drawer.wrapper.scrollWidth * this.waveSurfer.params.pixelRatio;
+        x = (width / duration) * this.waveSurfer.getCurrentTime() - 2;
+        // update the timeline canvas
+        this.waveSurfer.timeline.render();
+        // draw the cursor on the timeline
+        this.waveSurfer.timeline.canvases.forEach((canvas, i) => {
+            const leftOffset = i * this.waveSurfer.timeline.maxCanvasWidth;
+            const ctx = canvas.getContext('2d');
+            ctx.fillStyle = '#fd7e14';
+            ctx.beginPath();
+            ctx.moveTo(x - 12 - leftOffset, 20);
+            ctx.lineTo(x + 12 - leftOffset, 20);
+            ctx.lineTo(x - leftOffset, 45);
+            ctx.fill();
+        });
+    }
+    startTimeUpdater() {
+        this.stopTimeUpdater();
+        const timeUpdater = timer(0, 40);
+        this.timeUpdateSubscription = timeUpdater.subscribe(() => {
+            this.updateCurrentTime();
+        });
+    }
+    stopTimeUpdater() {
+        if (this.timeUpdateSubscription) {
+            this.timeUpdateSubscription.unsubscribe();
+        }
+    }
+    formatTimeCallback(seconds, pxPerSec) {
+        if (this.selectedComposition.gridType === 'musical') {
+            return Math.round(seconds / this.selectedComposition.timeSignatureUpper / (60 / this.selectedComposition.beatsPerMinute));
+        }
+        else {
+            // calculate minutes and seconds from seconds count
+            const minutes = parseInt((seconds / 60), 10);
+            seconds = parseInt((seconds % 60), 10);
+            // fill up seconds with zeroes
+            const secondsStr = seconds < 10 ? '0' + seconds : seconds;
+            return `${minutes}:${secondsStr}`;
+        }
+    }
+    timeInterval(pxPerSec) {
+        if (this.selectedComposition.gridType === 'musical') {
+            const interval = 60 / this.selectedComposition.beatsPerMinute / this.selectedComposition.gridResolution;
+            if (pxPerSec < 40) {
+                return interval * 4;
+            }
+            else if (pxPerSec < 80) {
+                return interval * 2;
+            }
+            return interval;
+        }
+        else {
+            if (pxPerSec >= 25) {
+                return 1;
+            }
+            else if (pxPerSec * 5 >= 25) {
+                return 5;
+            }
+            else if (pxPerSec * 15 >= 25) {
+                return 15;
+            }
+            return Math.ceil(0.5 / pxPerSec) * 60;
+        }
+    }
+    primaryLabelInterval(pxPerSec) {
+        if (this.selectedComposition.gridType === 'musical') {
+            const interval = this.selectedComposition.timeSignatureUpper * this.selectedComposition.gridResolution;
+            return interval;
+        }
+        else {
+            if (pxPerSec >= 25) {
+                return 10;
+            }
+            else if (pxPerSec * 5 >= 25) {
+                return 6;
+            }
+            else if (pxPerSec * 15 >= 25) {
+                return 4;
+            }
+            return 4;
+        }
+    }
+    secondaryLabelInterval(pxPerSec) {
+        if (this.selectedComposition.gridType === 'musical') {
+            return 0;
+        }
+        else {
+            if (pxPerSec >= 25) {
+                return 5;
+            }
+            else if (pxPerSec * 5 >= 25) {
+                return 2;
+            }
+            else if (pxPerSec * 15 >= 25) {
+                return 2;
+            }
+            return 2;
+        }
+    }
+    seeekWithTimeline(e) {
+        // taken from wavesurfer -> drawer -> handleEvent
+        const clientX = e.targetTouches ? e.targetTouches[0].clientX : e.clientX;
+        const bbox = this.waveSurfer.timeline.wrapper.getBoundingClientRect();
+        const nominalWidth = this.waveSurfer.timeline.drawer.width;
+        const parentWidth = this.waveSurfer.timeline.drawer.getWidth();
+        let progress;
+        if (!this.waveSurfer.timeline.drawer.params.fillParent && nominalWidth < parentWidth) {
+            progress =
+                (this.waveSurfer.timeline.drawer.params.rtl ? bbox.right - clientX : clientX - bbox.left) *
+                    (this.waveSurfer.timeline.drawer.params.pixelRatio / nominalWidth) || 0;
+            if (progress > 1) {
+                progress = 1;
+            }
+        }
+        else {
+            progress =
+                ((this.waveSurfer.timeline.drawer.params.rtl ? bbox.right - clientX : clientX - bbox.left) +
+                    this.waveSurfer.timeline.wrapper.scrollLeft) /
+                    this.waveSurfer.timeline.wrapper.scrollWidth || 0;
+        }
+        progress = Math.max(progress, 0);
+        setTimeout(() => {
+            this.waveSurfer.seekTo(progress);
+            this.detectChanges.next();
+            this.presetService.previewLive(this.selectedComposition.name, Math.round(this.waveSurfer.getCurrentTime() * 1000));
+        }, 0);
+    }
+    applyZoom(zoom) {
+        if (zoom < 0 || zoom > 200) {
+            return;
+        }
+        this.zoom = zoom;
+        if (this.waveSurfer) {
+            setTimeout(() => {
+                this.waveSurfer.zoom(this.zoom);
+                this.updateCurrentTime();
+            }, 0);
+        }
+    }
+    isWaveSurferReady() {
+        if (!this.waveSurfer) {
+            return false;
+        }
+        if (!this.waveSurfer.isReady) {
+            return false;
+        }
+        return true;
+    }
+    addRegion(waveSurferRegion) {
+        if (!this.isWaveSurferReady()) {
+            return;
+        }
+        if (!this.sceneService.selectedScenes || this.sceneService.selectedScenes.length !== 1) {
+            return;
+        }
+        if (!this.selectedComposition) {
+            return;
+        }
+        const scenePlaybackRegion = new ScenePlaybackRegion();
+        scenePlaybackRegion.sceneUuid = this.sceneService.selectedScenes[0].uuid;
+        if (waveSurferRegion) {
+            scenePlaybackRegion.startMillis = waveSurferRegion.start * 1000;
+            scenePlaybackRegion.endMillis = waveSurferRegion.end * 1000;
+        }
+        else {
+            scenePlaybackRegion.startMillis = (this.waveSurfer.getDuration() * 1000) / 3;
+            scenePlaybackRegion.endMillis = ((this.waveSurfer.getDuration() * 1000) / 3) * 2;
+        }
+        this.selectedComposition.scenePlaybackRegions.push(scenePlaybackRegion);
+        this.selectedPlaybackRegion = scenePlaybackRegion;
+        if (waveSurferRegion) {
+            waveSurferRegion.color =
+                'rgba(' +
+                    this.hexToRgb(this.sceneService.selectedScenes[0].color).r +
+                    ', ' +
+                    this.hexToRgb(this.sceneService.selectedScenes[0].color).g +
+                    ', ' +
+                    this.hexToRgb(this.sceneService.selectedScenes[0].color).b +
+                    ', ' +
+                    this.intensityHighlighted +
+                    ')';
+            waveSurferRegion.attributes.selectable = true;
+            this.connectRegion(waveSurferRegion, this.sceneService.selectedScenes[0], scenePlaybackRegion);
+            this.updateRegionSelection();
+        }
+        else {
+            this.drawRegion(scenePlaybackRegion, this.sceneService.selectedScenes[0]);
+        }
+        this.presetService.previewLive();
+    }
+    getSnapToGridInterval() {
+        if (this.selectedComposition.snapToGrid) {
+            return 60 / this.selectedComposition.beatsPerMinute / this.selectedComposition.gridResolution;
+        }
+        return undefined;
+    }
+    getSnapToGridOffset() {
+        return this.selectedComposition.gridOffsetMillis / 1000;
+    }
+    deleteSelectedComposition() {
+        this.projectService.project.compositions.splice(this.selectedCompositionIndex, 1);
+        this.selectedComposition = undefined;
+        this.selectedCompositionIndex = undefined;
+        this.destroyWaveSurfer();
+        if (this.projectService.project.compositions.length > 0) {
+            this.selectCompositionIndex(0);
+        }
+    }
+    destroyWaveSurfer() {
+        this.duration = undefined;
+        this.loadingAudioFile = false;
+        if (this.waveSurfer) {
+            this.waveSurfer.destroy();
+            this.waveSurfer = undefined;
+        }
+    }
+    createWaveSurfer() {
+        this.destroyWaveSurfer();
+        if (!this.selectedComposition.audioFileName) {
+            return;
+        }
+        this.loadingAudioFile = true;
+        setTimeout(() => {
+            this.waveSurfer = WaveSurfer.create({
+                container: '#waveform',
+                waveColor: 'white',
+                progressColor: 'white',
+                // barWidth: 2,
+                height: 1,
+                interact: false,
+                // Use for timelines without sound. Wave will be displayed
+                // wrong, but should work for a dummy audio without any waves.
+                // duration: 400,
+                plugins: [
+                    CursorPlugin.create({
+                        // showTime: true,
+                        opacity: 1,
+                        color: '#fd7e14',
+                        hideOnBlur: false /* don't show/hide the cursor on the wave (only on the timeline) */,
+                    }),
+                    RegionsPlugin.create({
+                        dragSelection: {
+                            slop: 5,
+                        },
+                        color: '#fff',
+                        snapToGridInterval: this.getSnapToGridInterval(),
+                        snapToGridOffset: this.getSnapToGridOffset(),
+                    }),
+                    TimeLinePlugin.create({
+                        container: '#waveform-timeline',
+                        primaryFontColor: '#fff',
+                        secondaryFontColor: '#fff',
+                        offset: this.getSnapToGridOffset(),
+                        formatTimeCallback: this.formatTimeCallback.bind(this),
+                        timeInterval: this.timeInterval.bind(this),
+                        primaryLabelInterval: this.primaryLabelInterval.bind(this),
+                        secondaryLabelInterval: this.secondaryLabelInterval.bind(this),
+                    }),
+                ],
+            });
+            let audioFileName;
+            if (this.configService.enableMediaLibrary) {
+                // the file name is also used for the real file name
+                audioFileName = 'file/get?name=' + this.selectedComposition.audioFileName + '&type=AUDIO';
+            }
+            else {
+                // the composition uuid and extension is used as the file name
+                audioFileName =
+                    'composition-files/?file=' +
+                        this.selectedComposition.uuid +
+                        '.' +
+                        this.selectedComposition.audioFileName.substr(this.selectedComposition.audioFileName.lastIndexOf('.') + 1);
+            }
+            this.waveSurfer.load(this.configService.restUrl + audioFileName);
+            this.waveSurfer.on('ready', () => {
+                setTimeout(() => {
+                    // try guessing the bpm and offset from the file, if necessary
+                    if (this.selectedComposition.tempoGuessed) {
+                        // we already guessed the BPM of this file --> don't do it again
+                        this.loadingAudioFile = false;
+                    }
+                    else {
+                        // we have not yet guessed the BPM --> do it now
+                        this.selectedComposition.tempoGuessed = true;
+                        guess(this.waveSurfer.backend.buffer)
+                            .then(({ bpm, offset }) => {
+                            // the bpm and offset could be guessed
+                            this.selectedComposition.beatsPerMinute = bpm;
+                            this.selectedComposition.gridOffsetMillis = offset * 1000;
+                            this.loadingAudioFile = false;
+                        })
+                            .catch((err) => {
+                            // something went wrong
+                            console.error('Could not detect the BPM from the audio file', err);
+                            this.loadingAudioFile = false;
+                        });
+                    }
+                    this.duration = this.msToTime(this.waveSurfer.getDuration() * 1000);
+                    this.drawAllRegions();
+                    // scroll wavesurfer in sync with the timeline
+                    this.waveSurfer.timeline.wrapper.addEventListener('scroll', () => {
+                        this.waveSurfer.drawer.wrapper.scrollLeft = this.waveSurfer.timeline.wrapper.scrollLeft;
+                        // Set the scroll position of the timeline to the same position as the wavesurfer,
+                        // because the timeline is larger than wavesurfer and might get out of sync.
+                        // This way, if wavesurfer cannot scroll any further, we reset the position
+                        // of the timeline as well.
+                        this.waveSurfer.timeline.wrapper.scrollLeft = this.waveSurfer.drawer.wrapper.scrollLeft;
+                    });
+                    // display the cursor also on the timeline
+                    this.waveSurfer.timeline.wrapper.addEventListener('mouseenter', () => {
+                        this.waveSurfer.cursor.showCursor();
+                    });
+                    this.waveSurfer.timeline.wrapper.addEventListener('mouseleave', () => {
+                        this.waveSurfer.cursor.hideCursor();
+                    });
+                    this.waveSurfer.timeline.wrapper.addEventListener('mousemove', (e) => {
+                        const bbox = this.waveSurfer.container.getBoundingClientRect();
+                        const x = e.clientX - bbox.left;
+                        this.waveSurfer.cursor.updateCursorPosition(x, 0);
+                    });
+                    // hide the cursor on the wave initially. in combination with the param hideOnBlur = false,
+                    // it will never be displayed on the wave now. we handle it on the timeline only.
+                    this.waveSurfer.cursor.hideCursor();
+                    // seek on timeline-click
+                    this.waveSurfer.timeline.wrapper.addEventListener('mousedown', (e) => {
+                        this.timelineClicking = true;
+                        this.seeekWithTimeline(e);
+                    });
+                    this.waveSurfer.timeline.wrapper.addEventListener('mousemove', (e) => {
+                        if (this.timelineClicking) {
+                            this.seeekWithTimeline(e);
+                        }
+                    });
+                    this.waveSurfer.timeline.wrapper.addEventListener('mouseup', (e) => {
+                        this.timelineClicking = false;
+                    });
+                    this.updateCurrentTime();
+                    this.detectChanges.next();
+                    this.waveSurferReady.next();
+                }, 0);
+            });
+            this.waveSurfer.on('error', (error) => {
+                // could not load the composition --> delete it
+                // (this may occur, when the composition has been deleted but the project is not saved afterwards)
+                this.deleteSelectedComposition();
+            });
+            this.waveSurfer.on('seek', () => {
+                this.updateCurrentTime();
+            });
+            this.waveSurfer.on('play', () => {
+                this.startTimeUpdater();
+            });
+            this.waveSurfer.on('pause', () => {
+                this.stopTimeUpdater();
+            });
+            this.waveSurfer.on('region-created', (region) => {
+                // region created by selection or programmatically
+                if (this.sceneService.selectedScenes && this.sceneService.selectedScenes.length === 1) {
+                    if (!region.data.handled) {
+                        this.addRegion(region);
+                    }
+                }
+                else {
+                    if (!region.data.handled) {
+                        region.remove();
+                    }
+                }
+            });
+            this.waveSurfer.on('region-updated', (region) => {
+                this.detectChanges.next();
+                this.presetService.previewLive();
+            });
+        }, 0);
+    }
+    hexToRgb(hex) {
+        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+        return result
+            ? {
+                r: parseInt(result[1], 16),
+                g: parseInt(result[2], 16),
+                b: parseInt(result[3], 16),
+            }
+            : null;
+    }
+    updateRegionSelection() {
+        if (!this.waveSurfer) {
+            return;
+        }
+        for (const key of Object.keys(this.waveSurfer.regions.list)) {
+            const region = this.waveSurfer.regions.list[key];
+            // if no scene is set, the region is not valid (e.g. has been created, while
+            // no scene has been selected and remove did not work properly)
+            if (region.scene) {
+                let intensity = this.intensity;
+                region.drag = false;
+                region.resize = false;
+                region.attributes.selectable = false;
+                if (this.sceneService.sceneIsSelected(region.scene)) {
+                    intensity = this.intensitySelectedScene;
+                    region.drag = true;
+                    region.resize = true;
+                    region.attributes.selectable = true;
+                }
+                region.attributes.selected = false;
+                if (this.selectedPlaybackRegion && this.selectedPlaybackRegion === region.scenePlaybackRegion) {
+                    intensity = this.intensityHighlighted;
+                    region.attributes.selected = true;
+                }
+                region.color =
+                    'rgba(' +
+                        this.hexToRgb(region.scene.color).r +
+                        ', ' +
+                        this.hexToRgb(region.scene.color).g +
+                        ', ' +
+                        this.hexToRgb(region.scene.color).b +
+                        ', ' +
+                        intensity +
+                        ')';
+                region.updateRender();
+            }
+        }
+    }
+    updateSelectedRegion() {
+        if (!this.waveSurfer) {
+            return;
+        }
+        if (!this.selectedPlaybackRegion) {
+            return;
+        }
+        for (const key of Object.keys(this.waveSurfer.regions.list)) {
+            const region = this.waveSurfer.regions.list[key];
+            if (this.selectedPlaybackRegion === region.scenePlaybackRegion) {
+                region.start = this.selectedPlaybackRegion.startMillis / 1000;
+                region.end = this.selectedPlaybackRegion.endMillis / 1000;
+                region.updateRender();
+                break;
+            }
+        }
+    }
+    setSelectedRegion(scenePlaybackRegion) {
+        if (this.selectedPlaybackRegion && this.selectedPlaybackRegion === scenePlaybackRegion) {
+            // No update required
+            return;
+        }
+        if (scenePlaybackRegion) {
+            this.selectedPlaybackRegion = scenePlaybackRegion;
+        }
+        this.updateRegionSelection();
+    }
+    getRegionSnapToGridValue(value) {
+        // the regions should snap to a grid
+        const offset = this.getSnapToGridOffset() || 0;
+        const interval = this.getSnapToGridInterval() || 0;
+        return Math.round((value - offset) / interval) * interval + offset;
+    }
+    connectRegion(waveSurferRegion, scene, scenePlaybackRegion, preset) {
+        waveSurferRegion.scenePlaybackRegion = scenePlaybackRegion;
+        waveSurferRegion.scene = scene;
+        waveSurferRegion.preset = preset;
+        waveSurferRegion.on('click', (event) => {
+            if (this.sceneService.sceneIsSelected(scene)) {
+                this.setSelectedRegion(scenePlaybackRegion);
+            }
+        });
+        waveSurferRegion.on('update', () => {
+            this.setSelectedRegion(scenePlaybackRegion);
+            if (this.selectedComposition.snapToGrid) {
+                // update the regions boundaries. they may not snap to grid, if it has been
+                // disabled during creation of the region but activated afterwards.
+                waveSurferRegion.start = this.getRegionSnapToGridValue(waveSurferRegion.start);
+                waveSurferRegion.end = this.getRegionSnapToGridValue(waveSurferRegion.end);
+            }
+            scenePlaybackRegion.startMillis = waveSurferRegion.start * 1000;
+            scenePlaybackRegion.endMillis = waveSurferRegion.end * 1000;
+        });
+    }
+    drawRegion(scenePlaybackRegion, scene) {
+        // draw the regions of the currently selected scene
+        if (!this.isWaveSurferReady()) {
+            return;
+        }
+        // add the playback region
+        const waveSurferRegion = this.waveSurfer.addRegion({
+            start: scenePlaybackRegion.startMillis / 1000,
+            end: scenePlaybackRegion.endMillis / 1000,
+            color: '#fff',
+            data: { handled: true },
+        });
+        this.connectRegion(waveSurferRegion, scene, scenePlaybackRegion);
+        // TODO show the all presets
+        // for (let presetUuid of scene.presetUuids) {
+        //   const preset = this.presetService.getPresetByUuid(presetUuid);
+        //   let waveSurferRegion = this.timelineService.waveSurfer.addRegion({
+        //     start: (scenePlaybackRegion.startMillis + (preset.startMillis ? preset.startMillis : 0)) / 1000,
+        //     end: (scenePlaybackRegion.startMillis
+        //       + (preset.endMillis ? preset.endMillis : scenePlaybackRegion.endMillis - scenePlaybackRegion.startMillis)) / 1000,
+        //     color: '#fff',
+        //     data: { handled: true },
+        //     // TODO
+        //     attributes: {
+        //       preset: true,
+        //       name: 'Preset 1'
+        //     }
+        //   });
+        //   this.connectRegion(waveSurferRegion, scene, scenePlaybackRegion, preset);
+        // }
+        this.updateRegionSelection();
+    }
+    removeRegion() {
+        if (!this.selectedPlaybackRegion) {
+            return;
+        }
+        if (this.sceneService.selectedScenes.length !== 1) {
+            return;
+        }
+        for (let i = 0; i < this.selectedComposition.scenePlaybackRegions.length; i++) {
+            if (this.selectedComposition.scenePlaybackRegions[i] === this.selectedPlaybackRegion) {
+                // remove the region from wavesurfer
+                for (const key of Object.keys(this.waveSurfer.regions.list)) {
+                    const region = this.waveSurfer.regions.list[key];
+                    if (region.scenePlaybackRegion === this.selectedPlaybackRegion) {
+                        region.remove();
+                    }
+                }
+                this.selectedPlaybackRegion = undefined;
+                this.selectedComposition.scenePlaybackRegions.splice(i, 1);
+                return;
+            }
+        }
+        this.presetService.previewLive();
+    }
+    getPresetsInTime(timeMillis) {
+        // Return all presets which should be active during the specified time
+        const activePresets = [];
+        for (let sceneIndex = this.projectService.project.scenes.length - 1; sceneIndex >= 0; sceneIndex--) {
+            const scene = this.projectService.project.scenes[sceneIndex];
+            for (const region of this.selectedComposition.scenePlaybackRegions) {
+                if (region.sceneUuid === scene.uuid) {
+                    for (let presetIndex = this.projectService.project.presets.length - 1; presetIndex >= 0; presetIndex--) {
+                        for (const presetUuid of scene.presetUuids) {
+                            if (presetUuid === this.projectService.project.presets[presetIndex].uuid) {
+                                const preset = this.presetService.getPresetByUuid(presetUuid);
+                                if (preset) {
+                                    let presetStartMillis = preset.startMillis === undefined ? region.startMillis : region.startMillis + preset.startMillis;
+                                    let presetEndMillis = preset.endMillis === undefined ? region.endMillis : region.startMillis + preset.endMillis;
+                                    // extend the running time, if fading is done outside the boundaries
+                                    presetStartMillis -= preset.fadeInPre ? preset.fadeInMillis : 0;
+                                    presetEndMillis += preset.fadeOutPost ? preset.fadeOutMillis : 0;
+                                    if (presetStartMillis <= timeMillis && presetEndMillis >= timeMillis) {
+                                        activePresets.push(new PresetRegionScene(preset, region, scene));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return activePresets;
+    }
+    drawAllRegions() {
+        if (!this.selectedComposition) {
+            return;
+        }
+        // draw the regions in the same order as their corresponding scenes, but draw
+        // the selected ones last, to make sure they're always clickable.
+        for (let sceneIndex = this.projectService.project.scenes.length - 1; sceneIndex >= 0; sceneIndex--) {
+            const scene = this.projectService.project.scenes[sceneIndex];
+            if (!this.sceneService.sceneIsSelected(scene)) {
+                for (const scenePlaybackRegion of this.selectedComposition.scenePlaybackRegions) {
+                    if (scenePlaybackRegion.sceneUuid === scene.uuid) {
+                        this.drawRegion(scenePlaybackRegion, scene);
+                    }
+                }
+            }
+        }
+        // draw all selected scenes afterwards
+        for (let sceneIndex = this.projectService.project.scenes.length - 1; sceneIndex >= 0; sceneIndex--) {
+            const scene = this.projectService.project.scenes[sceneIndex];
+            if (this.sceneService.sceneIsSelected(scene)) {
+                for (const scenePlaybackRegion of this.selectedComposition.scenePlaybackRegions) {
+                    if (scenePlaybackRegion.sceneUuid === scene.uuid) {
+                        this.drawRegion(scenePlaybackRegion, scene);
+                    }
+                }
+            }
+        }
+    }
+    updateGrid() {
+        if (this.waveSurferReady) {
+            this.waveSurfer.timeline.params.offset = this.getSnapToGridOffset();
+            this.waveSurfer.regions.params.snapToGridInterval = this.getSnapToGridInterval();
+            this.waveSurfer.regions.params.snapToGridOffset = this.getSnapToGridOffset();
+        }
+        this.updateCurrentTime();
+    }
+    getExternalCompositionNames() {
+        // get available compositions from an external pool (e.g. Rocket Show)
+        return this.http.get('composition/list').pipe(map((response) => {
+            const compositionNames = [];
+            for (const responseComposition of response) {
+                compositionNames.push(responseComposition.name);
+            }
+            return compositionNames;
+        }));
+    }
+    selectCompositionIndex(index) {
+        this.selectedComposition = this.projectService.project.compositions[index];
+        this.selectedCompositionIndex = index;
+        this.projectService.project.selectedCompositionUuid = this.selectedComposition.uuid;
+        this.createWaveSurfer();
+        // required to trigger timeline.component.resize()
+        this.waveSurferReady.next();
+        this.applyZoom(0);
+    }
+    static { this.ɵfac = function TimelineService_Factory(t) { return new (t || TimelineService)(i0.ɵɵinject(i1.SceneService), i0.ɵɵinject(i2.PresetService), i0.ɵɵinject(i3.ProjectService), i0.ɵɵinject(i4.HttpClient), i0.ɵɵinject(i5.ConfigService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: TimelineService, factory: TimelineService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TimelineService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], () => [{ type: i1.SceneService }, { type: i2.PresetService }, { type: i3.ProjectService }, { type: i4.HttpClient }, { type: i5.ConfigService }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"timeline.service.js","sourceRoot":"","sources":["../../../../../projects/designer/src/lib/services/timeline.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { Observable, Subject, Subscription, timer } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport WaveSurfer from 'wavesurfer.js';\nimport CursorPlugin from 'wavesurfer.js/dist/plugin/wavesurfer.cursor.min.js';\nimport RegionsPlugin from 'wavesurfer.js/dist/plugin/wavesurfer.regions.min.js';\nimport TimeLinePlugin from 'wavesurfer.js/dist/plugin/wavesurfer.timeline.min.js';\nimport { guess } from 'web-audio-beat-detector';\nimport { Composition } from '../models/composition';\nimport { Preset } from '../models/preset';\nimport { PresetRegionScene } from '../models/preset-region-scene';\nimport { Scene } from '../models/scene';\nimport { ScenePlaybackRegion } from '../models/scene-playback-region';\nimport { ConfigService } from './config.service';\nimport { PresetService } from './preset.service';\nimport { ProjectService } from './project.service';\nimport { SceneService } from './scene.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class TimelineService {\n  public waveSurfer: WaveSurfer;\n  public playState = 'paused';\n\n  public zoom = 0;\n  private timeUpdateSubscription: Subscription;\n  public currentTime: string;\n  private timelineClicking = false;\n  public selectedPlaybackRegion: ScenePlaybackRegion;\n  private intensity = 0.2;\n  private intensitySelectedScene = 0.4;\n  private intensityHighlighted = 0.8;\n  public duration: string;\n  public waveSurferReady: Subject<void> = new Subject();\n  public detectChanges: Subject<void> = new Subject();\n\n  // the current composition\n  public selectedComposition: Composition;\n  public selectedCompositionIndex: number;\n\n  // can we add new compositions based on an external pool and\n  // should new compositions not available in this pool be added there?\n  public externalCompositionsAvailable = false;\n\n  public loadingAudioFile = false;\n\n  constructor(\n    private sceneService: SceneService,\n    private presetService: PresetService,\n    private projectService: ProjectService,\n    private http: HttpClient,\n    private configService: ConfigService\n  ) {\n    this.presetService.previewSelectionChanged.subscribe(() => {\n      this.selectedPlaybackRegion = undefined;\n      this.updateRegionSelection();\n    });\n    this.sceneService.sceneDeleted.subscribe(() => {\n      this.redrawAllRegions();\n    });\n    this.sceneService.sceneSelected.subscribe(() => {\n      this.redrawAllRegions();\n    });\n  }\n\n  private redrawAllRegions() {\n    // remove all regions from wavesurver\n    if (this.waveSurfer) {\n      for (const key of Object.keys(this.waveSurfer.regions.list)) {\n        const region: any = this.waveSurfer.regions.list[key];\n        region.remove();\n      }\n    }\n\n    // draw all regions\n    this.drawAllRegions();\n  }\n\n  private pad(num: number, size: number): string {\n    if (!num) {\n      num = 0;\n    }\n\n    let padded: string = num.toString();\n    while (padded.length < size) {\n      padded = '0' + padded;\n    }\n\n    return padded;\n  }\n\n  private msToTime(millis: number, includeMillis: boolean = true): string {\n    const ms: number = Math.round(millis % 1000);\n    const seconds: number = Math.floor(((millis % 360000) % 60000) / 1000);\n    const minutes: number = Math.floor((millis % 3600000) / 60000);\n\n    if (includeMillis) {\n      return this.pad(minutes, 2) + ':' + this.pad(seconds, 2) + '.' + this.pad(ms, 3);\n    } else {\n      return this.pad(minutes, 2) + ':' + this.pad(seconds, 2);\n    }\n  }\n\n  private updateCurrentTime() {\n    if (!this.waveSurfer) {\n      return;\n    }\n\n    // display the current time\n    this.currentTime = this.msToTime(this.waveSurfer.getCurrentTime() * 1000);\n\n    if (!this.waveSurfer.timeline.drawer) {\n      return;\n    }\n\n    // draw the current cursor on the timeline\n    // TODO redrawing the timeline each update is way to expensive.\n    // maybe as a better solution use an element, like the cursor inside Wavesurfer to\n    // display the progress?\n    let x = 0;\n    const duration: number = this.waveSurfer.backend.getDuration();\n    const width: number =\n      this.waveSurfer.params.fillParent && !this.waveSurfer.params.scrollParent\n        ? this.waveSurfer.timeline.drawer.getWidth()\n        : this.waveSurfer.timeline.drawer.wrapper.scrollWidth * this.waveSurfer.params.pixelRatio;\n\n    x = (width / duration) * this.waveSurfer.getCurrentTime() - 2;\n\n    // update the timeline canvas\n    this.waveSurfer.timeline.render();\n\n    // draw the cursor on the timeline\n    this.waveSurfer.timeline.canvases.forEach((canvas, i) => {\n      const leftOffset = i * this.waveSurfer.timeline.maxCanvasWidth;\n\n      const ctx = canvas.getContext('2d');\n\n      ctx.fillStyle = '#fd7e14';\n      ctx.beginPath();\n      ctx.moveTo(x - 12 - leftOffset, 20);\n      ctx.lineTo(x + 12 - leftOffset, 20);\n      ctx.lineTo(x - leftOffset, 45);\n      ctx.fill();\n    });\n  }\n\n  private startTimeUpdater() {\n    this.stopTimeUpdater();\n\n    const timeUpdater = timer(0, 40);\n    this.timeUpdateSubscription = timeUpdater.subscribe(() => {\n      this.updateCurrentTime();\n    });\n  }\n\n  private stopTimeUpdater() {\n    if (this.timeUpdateSubscription) {\n      this.timeUpdateSubscription.unsubscribe();\n    }\n  }\n\n  formatTimeCallback(seconds: number, pxPerSec: number) {\n    if (this.selectedComposition.gridType === 'musical') {\n      return Math.round(seconds / this.selectedComposition.timeSignatureUpper / (60 / this.selectedComposition.beatsPerMinute));\n    } else {\n      // calculate minutes and seconds from seconds count\n      const minutes = parseInt((seconds / 60) as any, 10);\n      seconds = parseInt((seconds % 60) as any, 10);\n\n      // fill up seconds with zeroes\n      const secondsStr = seconds < 10 ? '0' + seconds : seconds;\n      return `${minutes}:${secondsStr}`;\n    }\n  }\n\n  timeInterval(pxPerSec: number) {\n    if (this.selectedComposition.gridType === 'musical') {\n      const interval = 60 / this.selectedComposition.beatsPerMinute / this.selectedComposition.gridResolution;\n\n      if (pxPerSec < 40) {\n        return interval * 4;\n      } else if (pxPerSec < 80) {\n        return interval * 2;\n      }\n\n      return interval;\n    } else {\n      if (pxPerSec >= 25) {\n        return 1;\n      } else if (pxPerSec * 5 >= 25) {\n        return 5;\n      } else if (pxPerSec * 15 >= 25) {\n        return 15;\n      }\n\n      return Math.ceil(0.5 / pxPerSec) * 60;\n    }\n  }\n\n  primaryLabelInterval(pxPerSec: number) {\n    if (this.selectedComposition.gridType === 'musical') {\n      const interval = this.selectedComposition.timeSignatureUpper * this.selectedComposition.gridResolution;\n\n      return interval;\n    } else {\n      if (pxPerSec >= 25) {\n        return 10;\n      } else if (pxPerSec * 5 >= 25) {\n        return 6;\n      } else if (pxPerSec * 15 >= 25) {\n        return 4;\n      }\n\n      return 4;\n    }\n  }\n\n  secondaryLabelInterval(pxPerSec: number) {\n    if (this.selectedComposition.gridType === 'musical') {\n      return 0;\n    } else {\n      if (pxPerSec >= 25) {\n        return 5;\n      } else if (pxPerSec * 5 >= 25) {\n        return 2;\n      } else if (pxPerSec * 15 >= 25) {\n        return 2;\n      }\n      return 2;\n    }\n  }\n\n  private seeekWithTimeline(e: any) {\n    // taken from wavesurfer -> drawer -> handleEvent\n    const clientX = e.targetTouches ? e.targetTouches[0].clientX : e.clientX;\n    const bbox = this.waveSurfer.timeline.wrapper.getBoundingClientRect();\n\n    const nominalWidth = this.waveSurfer.timeline.drawer.width;\n    const parentWidth = this.waveSurfer.timeline.drawer.getWidth();\n\n    let progress: number;\n\n    if (!this.waveSurfer.timeline.drawer.params.fillParent && nominalWidth < parentWidth) {\n      progress =\n        (this.waveSurfer.timeline.drawer.params.rtl ? bbox.right - clientX : clientX - bbox.left) *\n          (this.waveSurfer.timeline.drawer.params.pixelRatio / nominalWidth) || 0;\n\n      if (progress > 1) {\n        progress = 1;\n      }\n    } else {\n      progress =\n        ((this.waveSurfer.timeline.drawer.params.rtl ? bbox.right - clientX : clientX - bbox.left) +\n          this.waveSurfer.timeline.wrapper.scrollLeft) /\n          this.waveSurfer.timeline.wrapper.scrollWidth || 0;\n    }\n\n    progress = Math.max(progress, 0);\n\n    setTimeout(() => {\n      this.waveSurfer.seekTo(progress);\n      this.detectChanges.next();\n      this.presetService.previewLive(this.selectedComposition.name, Math.round(this.waveSurfer.getCurrentTime() * 1000));\n    }, 0);\n  }\n\n  applyZoom(zoom: any) {\n    if (zoom < 0 || zoom > 200) {\n      return;\n    }\n\n    this.zoom = zoom;\n    if (this.waveSurfer) {\n      setTimeout(() => {\n        this.waveSurfer.zoom(this.zoom);\n        this.updateCurrentTime();\n      }, 0);\n    }\n  }\n\n  private isWaveSurferReady(): boolean {\n    if (!this.waveSurfer) {\n      return false;\n    }\n\n    if (!this.waveSurfer.isReady) {\n      return false;\n    }\n\n    return true;\n  }\n\n  addRegion(waveSurferRegion?: any) {\n    if (!this.isWaveSurferReady()) {\n      return;\n    }\n\n    if (!this.sceneService.selectedScenes || this.sceneService.selectedScenes.length !== 1) {\n      return;\n    }\n\n    if (!this.selectedComposition) {\n      return;\n    }\n\n    const scenePlaybackRegion: ScenePlaybackRegion = new ScenePlaybackRegion();\n    scenePlaybackRegion.sceneUuid = this.sceneService.selectedScenes[0].uuid;\n\n    if (waveSurferRegion) {\n      scenePlaybackRegion.startMillis = waveSurferRegion.start * 1000;\n      scenePlaybackRegion.endMillis = waveSurferRegion.end * 1000;\n    } else {\n      scenePlaybackRegion.startMillis = (this.waveSurfer.getDuration() * 1000) / 3;\n      scenePlaybackRegion.endMillis = ((this.waveSurfer.getDuration() * 1000) / 3) * 2;\n    }\n\n    this.selectedComposition.scenePlaybackRegions.push(scenePlaybackRegion);\n\n    this.selectedPlaybackRegion = scenePlaybackRegion;\n\n    if (waveSurferRegion) {\n      waveSurferRegion.color =\n        'rgba(' +\n        this.hexToRgb(this.sceneService.selectedScenes[0].color).r +\n        ', ' +\n        this.hexToRgb(this.sceneService.selectedScenes[0].color).g +\n        ', ' +\n        this.hexToRgb(this.sceneService.selectedScenes[0].color).b +\n        ', ' +\n        this.intensityHighlighted +\n        ')';\n      waveSurferRegion.attributes.selectable = true;\n      this.connectRegion(waveSurferRegion, this.sceneService.selectedScenes[0], scenePlaybackRegion);\n      this.updateRegionSelection();\n    } else {\n      this.drawRegion(scenePlaybackRegion, this.sceneService.selectedScenes[0]);\n    }\n\n    this.presetService.previewLive();\n  }\n\n  private getSnapToGridInterval(): number {\n    if (this.selectedComposition.snapToGrid) {\n      return 60 / this.selectedComposition.beatsPerMinute / this.selectedComposition.gridResolution;\n    }\n\n    return undefined;\n  }\n\n  private getSnapToGridOffset(): number {\n    return this.selectedComposition.gridOffsetMillis / 1000;\n  }\n\n  deleteSelectedComposition() {\n    this.projectService.project.compositions.splice(this.selectedCompositionIndex, 1);\n    this.selectedComposition = undefined;\n    this.selectedCompositionIndex = undefined;\n    this.destroyWaveSurfer();\n    if (this.projectService.project.compositions.length > 0) {\n      this.selectCompositionIndex(0);\n    }\n  }\n\n  destroyWaveSurfer() {\n    this.duration = undefined;\n    this.loadingAudioFile = false;\n\n    if (this.waveSurfer) {\n      this.waveSurfer.destroy();\n      this.waveSurfer = undefined;\n    }\n  }\n\n  createWaveSurfer() {\n    this.destroyWaveSurfer();\n\n    if (!this.selectedComposition.audioFileName) {\n      return;\n    }\n\n    this.loadingAudioFile = true;\n\n    setTimeout(() => {\n      this.waveSurfer = WaveSurfer.create({\n        container: '#waveform',\n        waveColor: 'white',\n        progressColor: 'white',\n        // barWidth: 2,\n        height: 1,\n        interact: false,\n        // Use for timelines without sound. Wave will be displayed\n        // wrong, but should work for a dummy audio without any waves.\n        // duration: 400,\n        plugins: [\n          CursorPlugin.create({\n            // showTime: true,\n            opacity: 1,\n            color: '#fd7e14',\n            hideOnBlur: false /* don't show/hide the cursor on the wave (only on the timeline) */,\n          }),\n          RegionsPlugin.create({\n            dragSelection: {\n              slop: 5,\n            },\n            color: '#fff',\n            snapToGridInterval: this.getSnapToGridInterval(),\n            snapToGridOffset: this.getSnapToGridOffset(),\n          }),\n          TimeLinePlugin.create({\n            container: '#waveform-timeline',\n            primaryFontColor: '#fff',\n            secondaryFontColor: '#fff',\n            offset: this.getSnapToGridOffset(),\n            formatTimeCallback: this.formatTimeCallback.bind(this),\n            timeInterval: this.timeInterval.bind(this),\n            primaryLabelInterval: this.primaryLabelInterval.bind(this),\n            secondaryLabelInterval: this.secondaryLabelInterval.bind(this),\n          }),\n        ],\n      });\n\n      let audioFileName: string;\n\n      if (this.configService.enableMediaLibrary) {\n        // the file name is also used for the real file name\n        audioFileName = 'file/get?name=' + this.selectedComposition.audioFileName + '&type=AUDIO';\n      } else {\n        // the composition uuid and extension is used as the file name\n        audioFileName =\n          'composition-files/?file=' +\n          this.selectedComposition.uuid +\n          '.' +\n          this.selectedComposition.audioFileName.substr(this.selectedComposition.audioFileName.lastIndexOf('.') + 1);\n      }\n\n      this.waveSurfer.load(this.configService.restUrl + audioFileName);\n\n      this.waveSurfer.on('ready', () => {\n        setTimeout(() => {\n          // try guessing the bpm and offset from the file, if necessary\n          if (this.selectedComposition.tempoGuessed) {\n            // we already guessed the BPM of this file --> don't do it again\n            this.loadingAudioFile = false;\n          } else {\n            // we have not yet guessed the BPM --> do it now\n            this.selectedComposition.tempoGuessed = true;\n            guess(this.waveSurfer.backend.buffer)\n              .then(({ bpm, offset }) => {\n                // the bpm and offset could be guessed\n                this.selectedComposition.beatsPerMinute = bpm;\n                this.selectedComposition.gridOffsetMillis = offset * 1000;\n                this.loadingAudioFile = false;\n              })\n              .catch((err) => {\n                // something went wrong\n                console.error('Could not detect the BPM from the audio file', err);\n                this.loadingAudioFile = false;\n              });\n          }\n\n          this.duration = this.msToTime(this.waveSurfer.getDuration() * 1000);\n          this.drawAllRegions();\n\n          // scroll wavesurfer in sync with the timeline\n          this.waveSurfer.timeline.wrapper.addEventListener('scroll', () => {\n            this.waveSurfer.drawer.wrapper.scrollLeft = this.waveSurfer.timeline.wrapper.scrollLeft;\n\n            // Set the scroll position of the timeline to the same position as the wavesurfer,\n            // because the timeline is larger than wavesurfer and might get out of sync.\n            // This way, if wavesurfer cannot scroll any further, we reset the position\n            // of the timeline as well.\n            this.waveSurfer.timeline.wrapper.scrollLeft = this.waveSurfer.drawer.wrapper.scrollLeft;\n          });\n\n          // display the cursor also on the timeline\n          this.waveSurfer.timeline.wrapper.addEventListener('mouseenter', () => {\n            this.waveSurfer.cursor.showCursor();\n          });\n          this.waveSurfer.timeline.wrapper.addEventListener('mouseleave', () => {\n            this.waveSurfer.cursor.hideCursor();\n          });\n          this.waveSurfer.timeline.wrapper.addEventListener('mousemove', (e: any) => {\n            const bbox = this.waveSurfer.container.getBoundingClientRect();\n            const x = e.clientX - bbox.left;\n            this.waveSurfer.cursor.updateCursorPosition(x, 0);\n          });\n\n          // hide the cursor on the wave initially. in combination with the param hideOnBlur = false,\n          // it will never be displayed on the wave now. we handle it on the timeline only.\n          this.waveSurfer.cursor.hideCursor();\n\n          // seek on timeline-click\n          this.waveSurfer.timeline.wrapper.addEventListener('mousedown', (e: any) => {\n            this.timelineClicking = true;\n            this.seeekWithTimeline(e);\n          });\n\n          this.waveSurfer.timeline.wrapper.addEventListener('mousemove', (e: any) => {\n            if (this.timelineClicking) {\n              this.seeekWithTimeline(e);\n            }\n          });\n\n          this.waveSurfer.timeline.wrapper.addEventListener('mouseup', (e: any) => {\n            this.timelineClicking = false;\n          });\n\n          this.updateCurrentTime();\n\n          this.detectChanges.next();\n          this.waveSurferReady.next();\n        }, 0);\n      });\n\n      this.waveSurfer.on('error', (error: any) => {\n        // could not load the composition --> delete it\n        // (this may occur, when the composition has been deleted but the project is not saved afterwards)\n        this.deleteSelectedComposition();\n      });\n\n      this.waveSurfer.on('seek', () => {\n        this.updateCurrentTime();\n      });\n\n      this.waveSurfer.on('play', () => {\n        this.startTimeUpdater();\n      });\n\n      this.waveSurfer.on('pause', () => {\n        this.stopTimeUpdater();\n      });\n\n      this.waveSurfer.on('region-created', (region) => {\n        // region created by selection or programmatically\n        if (this.sceneService.selectedScenes && this.sceneService.selectedScenes.length === 1) {\n          if (!region.data.handled) {\n            this.addRegion(region);\n          }\n        } else {\n          if (!region.data.handled) {\n            region.remove();\n          }\n        }\n      });\n\n      this.waveSurfer.on('region-updated', (region: any) => {\n        this.detectChanges.next();\n        this.presetService.previewLive();\n      });\n    }, 0);\n  }\n\n  private hexToRgb(hex: string) {\n    const result = /^#?([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})$/i.exec(hex);\n    return result\n      ? {\n          r: parseInt(result[1], 16),\n          g: parseInt(result[2], 16),\n          b: parseInt(result[3], 16),\n        }\n      : null;\n  }\n\n  private updateRegionSelection() {\n    if (!this.waveSurfer) {\n      return;\n    }\n\n    for (const key of Object.keys(this.waveSurfer.regions.list)) {\n      const region: any = this.waveSurfer.regions.list[key];\n\n      // if no scene is set, the region is not valid (e.g. has been created, while\n      // no scene has been selected and remove did not work properly)\n      if (region.scene) {\n        let intensity = this.intensity;\n\n        region.drag = false;\n        region.resize = false;\n        region.attributes.selectable = false;\n\n        if (this.sceneService.sceneIsSelected(region.scene)) {\n          intensity = this.intensitySelectedScene;\n          region.drag = true;\n          region.resize = true;\n          region.attributes.selectable = true;\n        }\n\n        region.attributes.selected = false;\n\n        if (this.selectedPlaybackRegion && this.selectedPlaybackRegion === region.scenePlaybackRegion) {\n          intensity = this.intensityHighlighted;\n          region.attributes.selected = true;\n        }\n\n        region.color =\n          'rgba(' +\n          this.hexToRgb(region.scene.color).r +\n          ', ' +\n          this.hexToRgb(region.scene.color).g +\n          ', ' +\n          this.hexToRgb(region.scene.color).b +\n          ', ' +\n          intensity +\n          ')';\n        region.updateRender();\n      }\n    }\n  }\n\n  updateSelectedRegion() {\n    if (!this.waveSurfer) {\n      return;\n    }\n\n    if (!this.selectedPlaybackRegion) {\n      return;\n    }\n\n    for (const key of Object.keys(this.waveSurfer.regions.list)) {\n      const region: any = this.waveSurfer.regions.list[key];\n\n      if (this.selectedPlaybackRegion === region.scenePlaybackRegion) {\n        region.start = this.selectedPlaybackRegion.startMillis / 1000;\n        region.end = this.selectedPlaybackRegion.endMillis / 1000;\n        region.updateRender();\n        break;\n      }\n    }\n  }\n\n  private setSelectedRegion(scenePlaybackRegion?: ScenePlaybackRegion) {\n    if (this.selectedPlaybackRegion && this.selectedPlaybackRegion === scenePlaybackRegion) {\n      // No update required\n      return;\n    }\n\n    if (scenePlaybackRegion) {\n      this.selectedPlaybackRegion = scenePlaybackRegion;\n    }\n\n    this.updateRegionSelection();\n  }\n\n  private getRegionSnapToGridValue(value: number): number {\n    // the regions should snap to a grid\n    const offset = this.getSnapToGridOffset() || 0;\n    const interval = this.getSnapToGridInterval() || 0;\n    return Math.round((value - offset) / interval) * interval + offset;\n  }\n\n  private connectRegion(waveSurferRegion: any, scene: Scene, scenePlaybackRegion: ScenePlaybackRegion, preset?: Preset) {\n    waveSurferRegion.scenePlaybackRegion = scenePlaybackRegion;\n    waveSurferRegion.scene = scene;\n    waveSurferRegion.preset = preset;\n\n    waveSurferRegion.on('click', (event) => {\n      if (this.sceneService.sceneIsSelected(scene)) {\n        this.setSelectedRegion(scenePlaybackRegion);\n      }\n    });\n\n    waveSurferRegion.on('update', () => {\n      this.setSelectedRegion(scenePlaybackRegion);\n      if (this.selectedComposition.snapToGrid) {\n        // update the regions boundaries. they may not snap to grid, if it has been\n        // disabled during creation of the region but activated afterwards.\n        waveSurferRegion.start = this.getRegionSnapToGridValue(waveSurferRegion.start);\n        waveSurferRegion.end = this.getRegionSnapToGridValue(waveSurferRegion.end);\n      }\n      scenePlaybackRegion.startMillis = waveSurferRegion.start * 1000;\n      scenePlaybackRegion.endMillis = waveSurferRegion.end * 1000;\n    });\n  }\n\n  private drawRegion(scenePlaybackRegion: ScenePlaybackRegion, scene: Scene) {\n    // draw the regions of the currently selected scene\n    if (!this.isWaveSurferReady()) {\n      return;\n    }\n\n    // add the playback region\n    const waveSurferRegion = this.waveSurfer.addRegion({\n      start: scenePlaybackRegion.startMillis / 1000,\n      end: scenePlaybackRegion.endMillis / 1000,\n      color: '#fff',\n      data: { handled: true },\n    });\n    this.connectRegion(waveSurferRegion, scene, scenePlaybackRegion);\n\n    // TODO show the all presets\n    // for (let presetUuid of scene.presetUuids) {\n    //   const preset = this.presetService.getPresetByUuid(presetUuid);\n\n    //   let waveSurferRegion = this.timelineService.waveSurfer.addRegion({\n    //     start: (scenePlaybackRegion.startMillis + (preset.startMillis ? preset.startMillis : 0)) / 1000,\n    //     end: (scenePlaybackRegion.startMillis\n    //       + (preset.endMillis ? preset.endMillis : scenePlaybackRegion.endMillis - scenePlaybackRegion.startMillis)) / 1000,\n    //     color: '#fff',\n    //     data: { handled: true },\n    //     // TODO\n    //     attributes: {\n    //       preset: true,\n    //       name: 'Preset 1'\n    //     }\n    //   });\n    //   this.connectRegion(waveSurferRegion, scene, scenePlaybackRegion, preset);\n    // }\n\n    this.updateRegionSelection();\n  }\n\n  removeRegion() {\n    if (!this.selectedPlaybackRegion) {\n      return;\n    }\n\n    if (this.sceneService.selectedScenes.length !== 1) {\n      return;\n    }\n\n    for (let i = 0; i < this.selectedComposition.scenePlaybackRegions.length; i++) {\n      if (this.selectedComposition.scenePlaybackRegions[i] === this.selectedPlaybackRegion) {\n        // remove the region from wavesurfer\n        for (const key of Object.keys(this.waveSurfer.regions.list)) {\n          const region: any = this.waveSurfer.regions.list[key];\n\n          if (region.scenePlaybackRegion === this.selectedPlaybackRegion) {\n            region.remove();\n          }\n        }\n\n        this.selectedPlaybackRegion = undefined;\n        this.selectedComposition.scenePlaybackRegions.splice(i, 1);\n\n        return;\n      }\n    }\n\n    this.presetService.previewLive();\n  }\n\n  getPresetsInTime(timeMillis: number): PresetRegionScene[] {\n    // Return all presets which should be active during the specified time\n    const activePresets: PresetRegionScene[] = [];\n\n    for (let sceneIndex = this.projectService.project.scenes.length - 1; sceneIndex >= 0; sceneIndex--) {\n      const scene = this.projectService.project.scenes[sceneIndex];\n\n      for (const region of this.selectedComposition.scenePlaybackRegions) {\n        if (region.sceneUuid === scene.uuid) {\n          for (let presetIndex = this.projectService.project.presets.length - 1; presetIndex >= 0; presetIndex--) {\n            for (const presetUuid of scene.presetUuids) {\n              if (presetUuid === this.projectService.project.presets[presetIndex].uuid) {\n                const preset = this.presetService.getPresetByUuid(presetUuid);\n\n                if (preset) {\n                  let presetStartMillis = preset.startMillis === undefined ? region.startMillis : region.startMillis + preset.startMillis;\n                  let presetEndMillis = preset.endMillis === undefined ? region.endMillis : region.startMillis + preset.endMillis;\n\n                  // extend the running time, if fading is done outside the boundaries\n                  presetStartMillis -= preset.fadeInPre ? preset.fadeInMillis : 0;\n                  presetEndMillis += preset.fadeOutPost ? preset.fadeOutMillis : 0;\n\n                  if (presetStartMillis <= timeMillis && presetEndMillis >= timeMillis) {\n                    activePresets.push(new PresetRegionScene(preset, region, scene));\n                  }\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n\n    return activePresets;\n  }\n\n  drawAllRegions() {\n    if (!this.selectedComposition) {\n      return;\n    }\n\n    // draw the regions in the same order as their corresponding scenes, but draw\n    // the selected ones last, to make sure they're always clickable.\n    for (let sceneIndex = this.projectService.project.scenes.length - 1; sceneIndex >= 0; sceneIndex--) {\n      const scene = this.projectService.project.scenes[sceneIndex];\n      if (!this.sceneService.sceneIsSelected(scene)) {\n        for (const scenePlaybackRegion of this.selectedComposition.scenePlaybackRegions) {\n          if (scenePlaybackRegion.sceneUuid === scene.uuid) {\n            this.drawRegion(scenePlaybackRegion, scene);\n          }\n        }\n      }\n    }\n\n    // draw all selected scenes afterwards\n    for (let sceneIndex = this.projectService.project.scenes.length - 1; sceneIndex >= 0; sceneIndex--) {\n      const scene = this.projectService.project.scenes[sceneIndex];\n\n      if (this.sceneService.sceneIsSelected(scene)) {\n        for (const scenePlaybackRegion of this.selectedComposition.scenePlaybackRegions) {\n          if (scenePlaybackRegion.sceneUuid === scene.uuid) {\n            this.drawRegion(scenePlaybackRegion, scene);\n          }\n        }\n      }\n    }\n  }\n\n  updateGrid() {\n    if (this.waveSurferReady) {\n      this.waveSurfer.timeline.params.offset = this.getSnapToGridOffset();\n\n      this.waveSurfer.regions.params.snapToGridInterval = this.getSnapToGridInterval();\n      this.waveSurfer.regions.params.snapToGridOffset = this.getSnapToGridOffset();\n    }\n    this.updateCurrentTime();\n  }\n\n  getExternalCompositionNames(): Observable<string[]> {\n    // get available compositions from an external pool (e.g. Rocket Show)\n    return this.http.get('composition/list').pipe(\n      map((response: object[]) => {\n        const compositionNames: string[] = [];\n\n        for (const responseComposition of response) {\n          compositionNames.push((responseComposition as any).name);\n        }\n\n        return compositionNames;\n      })\n    );\n  }\n\n  selectCompositionIndex(index: number) {\n    this.selectedComposition = this.projectService.project.compositions[index];\n    this.selectedCompositionIndex = index;\n    this.projectService.project.selectedCompositionUuid = this.selectedComposition.uuid;\n    this.createWaveSurfer();\n\n    // required to trigger timeline.component.resize()\n    this.waveSurferReady.next();\n\n    this.applyZoom(0);\n  }\n}\n"]}