@rocketshow/designer 1.31.0 → 1.33.0

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

@@ -0,0 +1,140 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { ConfigService } from './config.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./config.service";
+export class IntroService {
+    constructor(configService) {
+        this.configService = configService;
+        this.showIntro = false;
+        this.activeStep = 'start';
+        this.positionTopPercentage = 50;
+        this.positionLeftPercentage = 50;
+        this.stylePosition = 'top: calc(50% - 150px); left: calc(50% - 200px);';
+        this.stepChanged = new Subject();
+    }
+    refresh() {
+        // called, as soon as the config has been updated
+        if (this.configService.intro) {
+            if (localStorage.getItem('showIntro')) {
+                this.showIntro = localStorage.getItem('showIntro') === 'true';
+            }
+            else {
+                this.showIntro = true;
+            }
+        }
+    }
+    setShowIntro(value) {
+        this.showIntro = value;
+        if (value) {
+            localStorage.setItem('showIntro', 'true');
+        }
+        else {
+            localStorage.setItem('showIntro', 'false');
+        }
+        this.stepChanged.next();
+    }
+    reset() {
+        this.activeStep = 'start';
+        this.setShowIntro(true);
+        this.stepChanged.next();
+    }
+    showStep(step) {
+        if (!this.showIntro) {
+            return false;
+        }
+        if (this.activeStep !== step) {
+            return false;
+        }
+        return true;
+    }
+    next() {
+        switch (this.activeStep) {
+            case 'start':
+                this.activeStep = 'preview';
+                this.positionTopPercentage = 60;
+                this.positionLeftPercentage = 40;
+                break;
+            case 'preview':
+                this.activeStep = 'fixtures';
+                this.positionTopPercentage = 40;
+                this.positionLeftPercentage = 30;
+                break;
+            case 'fixtures':
+                this.activeStep = 'presets';
+                this.positionTopPercentage = 30;
+                this.positionLeftPercentage = 50;
+                break;
+            case 'presets':
+                this.activeStep = 'capabilities';
+                this.positionTopPercentage = 50;
+                this.positionLeftPercentage = 60;
+                break;
+            case 'capabilities':
+                this.activeStep = 'scenes';
+                this.positionTopPercentage = 50;
+                this.positionLeftPercentage = 40;
+                break;
+            case 'scenes':
+                this.activeStep = 'timeline';
+                this.positionTopPercentage = 40;
+                this.positionLeftPercentage = 50;
+                break;
+            case 'timeline':
+                this.activeStep = 'finish';
+                this.positionTopPercentage = 50;
+                this.positionLeftPercentage = 50;
+                break;
+        }
+        this.stepChanged.next();
+    }
+    back() {
+        switch (this.activeStep) {
+            case 'preview':
+                this.activeStep = 'start';
+                this.positionTopPercentage = 50;
+                this.positionLeftPercentage = 50;
+                break;
+            case 'fixtures':
+                this.activeStep = 'preview';
+                this.positionTopPercentage = 60;
+                this.positionLeftPercentage = 40;
+                break;
+            case 'presets':
+                this.activeStep = 'fixtures';
+                this.positionTopPercentage = 30;
+                this.positionLeftPercentage = 50;
+                break;
+            case 'capabilities':
+                this.activeStep = 'presets';
+                this.positionTopPercentage = 40;
+                this.positionLeftPercentage = 30;
+                break;
+            case 'scenes':
+                this.activeStep = 'capabilities';
+                this.positionTopPercentage = 50;
+                this.positionLeftPercentage = 60;
+                break;
+            case 'timeline':
+                this.activeStep = 'scenes';
+                this.positionTopPercentage = 50;
+                this.positionLeftPercentage = 40;
+                break;
+            case 'finish':
+                this.activeStep = 'timeline';
+                this.positionTopPercentage = 40;
+                this.positionLeftPercentage = 50;
+                break;
+        }
+        this.stepChanged.next();
+    }
+    static { this.ɵfac = function IntroService_Factory(t) { return new (t || IntroService)(i0.ɵɵinject(i1.ConfigService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: IntroService, factory: IntroService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IntroService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], () => [{ type: i1.ConfigService }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"intro.service.js","sourceRoot":"","sources":["../../../../../projects/designer/src/lib/services/intro.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Subject } from 'rxjs';\nimport { ConfigService } from './config.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class IntroService {\n  showIntro = false;\n  activeStep = 'start';\n  positionTopPercentage = 50;\n  positionLeftPercentage = 50;\n  stylePosition = 'top: calc(50% - 150px); left: calc(50% - 200px);';\n  stepChanged: Subject<void> = new Subject<void>();\n\n  constructor(private configService: ConfigService) {}\n\n  refresh() {\n    // called, as soon as the config has been updated\n    if (this.configService.intro) {\n      if (localStorage.getItem('showIntro')) {\n        this.showIntro = localStorage.getItem('showIntro') === 'true';\n      } else {\n        this.showIntro = true;\n      }\n    }\n  }\n\n  setShowIntro(value: boolean) {\n    this.showIntro = value;\n    if (value) {\n      localStorage.setItem('showIntro', 'true');\n    } else {\n      localStorage.setItem('showIntro', 'false');\n    }\n    this.stepChanged.next();\n  }\n\n  reset() {\n    this.activeStep = 'start';\n    this.setShowIntro(true);\n    this.stepChanged.next();\n  }\n\n  showStep(step: string): boolean {\n    if (!this.showIntro) {\n      return false;\n    }\n\n    if (this.activeStep !== step) {\n      return false;\n    }\n\n    return true;\n  }\n\n  next() {\n    switch (this.activeStep) {\n      case 'start':\n        this.activeStep = 'preview';\n        this.positionTopPercentage = 60;\n        this.positionLeftPercentage = 40;\n        break;\n      case 'preview':\n        this.activeStep = 'fixtures';\n        this.positionTopPercentage = 40;\n        this.positionLeftPercentage = 30;\n        break;\n      case 'fixtures':\n        this.activeStep = 'presets';\n        this.positionTopPercentage = 30;\n        this.positionLeftPercentage = 50;\n        break;\n      case 'presets':\n        this.activeStep = 'capabilities';\n        this.positionTopPercentage = 50;\n        this.positionLeftPercentage = 60;\n        break;\n      case 'capabilities':\n        this.activeStep = 'scenes';\n        this.positionTopPercentage = 50;\n        this.positionLeftPercentage = 40;\n        break;\n      case 'scenes':\n        this.activeStep = 'timeline';\n        this.positionTopPercentage = 40;\n        this.positionLeftPercentage = 50;\n        break;\n      case 'timeline':\n        this.activeStep = 'finish';\n        this.positionTopPercentage = 50;\n        this.positionLeftPercentage = 50;\n        break;\n    }\n\n    this.stepChanged.next();\n  }\n\n  back() {\n    switch (this.activeStep) {\n      case 'preview':\n        this.activeStep = 'start';\n        this.positionTopPercentage = 50;\n        this.positionLeftPercentage = 50;\n        break;\n      case 'fixtures':\n        this.activeStep = 'preview';\n        this.positionTopPercentage = 60;\n        this.positionLeftPercentage = 40;\n        break;\n      case 'presets':\n        this.activeStep = 'fixtures';\n        this.positionTopPercentage = 30;\n        this.positionLeftPercentage = 50;\n        break;\n      case 'capabilities':\n        this.activeStep = 'presets';\n        this.positionTopPercentage = 40;\n        this.positionLeftPercentage = 30;\n        break;\n      case 'scenes':\n        this.activeStep = 'capabilities';\n        this.positionTopPercentage = 50;\n        this.positionLeftPercentage = 60;\n        break;\n      case 'timeline':\n        this.activeStep = 'scenes';\n        this.positionTopPercentage = 50;\n        this.positionLeftPercentage = 40;\n        break;\n      case 'finish':\n        this.activeStep = 'timeline';\n        this.positionTopPercentage = 40;\n        this.positionLeftPercentage = 50;\n        break;\n    }\n\n    this.stepChanged.next();\n  }\n}\n"]}

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

@@ -0,0 +1,400 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { FixtureCapabilityColor, FixtureCapabilityType } from '../models/fixture-capability';
+import { FixtureCapabilityValue } from '../models/fixture-capability-value';
+import { FixtureChannelValue } from '../models/fixture-channel-value';
+import { Preset } from '../models/preset';
+import { AnimationService } from './animation.service';
+import { ConfigService } from './config.service';
+import { EffectService } from './effect.service';
+import { FixtureService } from './fixture.service';
+import { ProjectService } from './project.service';
+import { UuidService } from './uuid.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./effect.service";
+import * as i2 from "./uuid.service";
+import * as i3 from "./project.service";
+import * as i4 from "./fixture.service";
+import * as i5 from "./config.service";
+import * as i6 from "@angular/common/http";
+import * as i7 from "./animation.service";
+export class PresetService {
+    constructor(effectService, uuidService, projectService, fixtureService, configService, http, animationService) {
+        this.effectService = effectService;
+        this.uuidService = uuidService;
+        this.projectService = projectService;
+        this.fixtureService = fixtureService;
+        this.configService = configService;
+        this.http = http;
+        this.animationService = animationService;
+        // fires, when the current preview element has changed (scene/preset)
+        this.previewSelectionChanged = new Subject();
+        // fires, when the fixture selection has changed
+        this.fixtureSelectionChanged = new Subject();
+        // fires, when the fixture selection has changed for settings
+        this.fixtureSelectionSettingsChanged = new Subject();
+        // fires, when the selected color has changed. This is required,
+        // because detectChanges is not enough to trigger different components.
+        this.fixtureColorChanged = new Subject();
+        this.liveChangePending = false;
+    }
+    getPresetByUuid(uuid) {
+        for (const preset of this.projectService.project.presets) {
+            if (preset.uuid === uuid) {
+                return preset;
+            }
+        }
+    }
+    fixtureIsSelected(fixture, preset) {
+        // is the passed fixture selected in the passed/currently selected preset?
+        if (!preset) {
+            if (this.selectedPreset) {
+                preset = this.selectedPreset;
+            }
+            else {
+                return false;
+            }
+        }
+        for (const selectedFixtureUuid of preset.fixtureUuids) {
+            if (selectedFixtureUuid === fixture.uuid) {
+                return true;
+            }
+        }
+        return false;
+    }
+    switchFixtureSelection(fixture) {
+        if (!this.selectedPreset) {
+            return;
+        }
+        // select all fixtures at the specified start channel or unselect them,
+        // if already selected
+        if (this.fixtureIsSelected(fixture)) {
+            for (let i = this.selectedPreset.fixtureUuids.length - 1; i >= 0; i--) {
+                const projectFixture = this.fixtureService.getFixtureByUuid(this.selectedPreset.fixtureUuids[i]);
+                if (projectFixture.dmxFirstChannel === fixture.dmxFirstChannel) {
+                    this.selectedPreset.fixtureUuids.splice(i, 1);
+                }
+            }
+        }
+        else {
+            for (const projectFixture of this.projectService.project.fixtures) {
+                if (projectFixture.dmxFirstChannel === fixture.dmxFirstChannel) {
+                    this.selectedPreset.fixtureUuids.push(projectFixture.uuid);
+                }
+            }
+        }
+    }
+    selectAllFixtures() {
+        if (!this.selectedPreset) {
+            return;
+        }
+        for (const fixture of this.projectService.project.fixtures) {
+            if (!this.fixtureIsSelected(fixture)) {
+                this.selectedPreset.fixtureUuids.push(fixture.uuid);
+            }
+        }
+    }
+    selectNoFixtures() {
+        if (!this.selectedPreset) {
+            return;
+        }
+        this.selectedPreset.fixtureUuids = [];
+    }
+    removeDeletedFixtures() {
+        // after changing the configuration in the fixture pool, we might need to
+        // delete some fixtures
+        for (const preset of this.projectService.project.presets) {
+            for (let i = preset.fixtureUuids.length - 1; i >= 0; i--) {
+                const presetFixture = this.fixtureService.getFixtureByUuid(preset.fixtureUuids[i]);
+                if (!presetFixture) {
+                    preset.fixtureUuids.splice(i, 1);
+                }
+            }
+        }
+    }
+    updateFixtureSelection() {
+        // after changing the configuration in the fixture pool, we might need to
+        // select some more fixtures on the same channel as already selected ones
+        for (const preset of this.projectService.project.presets) {
+            for (let i = preset.fixtureUuids.length - 1; i >= 0; i--) {
+                const presetFixture = this.fixtureService.getFixtureByUuid(preset.fixtureUuids[i]);
+                for (const projectFixture of this.projectService.project.fixtures) {
+                    if (projectFixture.dmxFirstChannel === presetFixture.dmxFirstChannel && !this.fixtureIsSelected(projectFixture, preset)) {
+                        preset.fixtureUuids.push(projectFixture.uuid);
+                    }
+                }
+            }
+        }
+    }
+    deleteCapabilityValue(preset, capabilityType, color, wheel, profileUuid) {
+        for (let i = 0; i < preset.fixtureCapabilityValues.length; i++) {
+            if (this.fixtureService.capabilitiesMatch(preset.fixtureCapabilityValues[i].type, capabilityType, preset.fixtureCapabilityValues[i].color, color, preset.fixtureCapabilityValues[i].wheel, wheel, preset.fixtureCapabilityValues[i].profileUuid, profileUuid)) {
+                preset.fixtureCapabilityValues.splice(i, 1);
+                return;
+            }
+        }
+    }
+    setCapabilityValue(preset, capabilityType, valuePercentage, slotNumber, color, wheel, profileUuid) {
+        // Delete existant properties with this type and set the new value
+        this.deleteCapabilityValue(preset, capabilityType, color, wheel, profileUuid);
+        const fixtureCapabilityValue = new FixtureCapabilityValue();
+        fixtureCapabilityValue.type = capabilityType;
+        fixtureCapabilityValue.color = color;
+        fixtureCapabilityValue.wheel = wheel;
+        fixtureCapabilityValue.valuePercentage = valuePercentage;
+        fixtureCapabilityValue.slotNumber = slotNumber;
+        fixtureCapabilityValue.profileUuid = profileUuid;
+        preset.fixtureCapabilityValues.push(fixtureCapabilityValue);
+    }
+    getCapabilityValue(preset, capabilityType, color, wheel, profileUuid) {
+        for (const capabilityValue of preset.fixtureCapabilityValues) {
+            if (this.fixtureService.capabilitiesMatch(capabilityValue.type, capabilityType, capabilityValue.color, color, capabilityValue.wheel, wheel, capabilityValue.profileUuid, profileUuid)) {
+                return capabilityValue;
+            }
+        }
+        return undefined;
+    }
+    deleteChannelValue(channelName, profileUuid) {
+        for (let i = 0; i < this.selectedPreset.fixtureChannelValues.length; i++) {
+            if (this.selectedPreset.fixtureChannelValues[i].channelName === channelName &&
+                this.selectedPreset.fixtureChannelValues[i].profileUuid === profileUuid) {
+                this.selectedPreset.fixtureChannelValues.splice(i, 1);
+                return;
+            }
+        }
+    }
+    setChannelValue(channelName, profileUuid, value) {
+        // Delete existant properties with this type and set the new value
+        this.deleteChannelValue(channelName, profileUuid);
+        const fixtureChannelValue = new FixtureChannelValue();
+        fixtureChannelValue.channelName = channelName;
+        fixtureChannelValue.profileUuid = profileUuid;
+        fixtureChannelValue.value = value;
+        this.selectedPreset.fixtureChannelValues.push(fixtureChannelValue);
+    }
+    getChannelValue(channelName, profileUuid) {
+        for (const channelValue of this.selectedPreset.fixtureChannelValues) {
+            if (channelValue.channelName === channelName && channelValue.profileUuid === profileUuid) {
+                return channelValue.value;
+            }
+        }
+    }
+    getApproximatedColorWheelCapability(preset, cachedChannel) {
+        // return an approximated wheel slot channel capability, if a color or a slot on a different
+        // wheel has been selected
+        let colorRed;
+        let colorGreen;
+        let colorBlue;
+        let lowestDiff = Number.MAX_VALUE;
+        let lowestDiffCapability;
+        let capabilityValue;
+        capabilityValue = this.getCapabilityValue(preset, FixtureCapabilityType.ColorIntensity, FixtureCapabilityColor.Red);
+        if (capabilityValue) {
+            colorRed = 255 * capabilityValue.valuePercentage;
+        }
+        capabilityValue = this.getCapabilityValue(preset, FixtureCapabilityType.ColorIntensity, FixtureCapabilityColor.Green);
+        if (capabilityValue) {
+            colorGreen = 255 * capabilityValue.valuePercentage;
+        }
+        capabilityValue = this.getCapabilityValue(preset, FixtureCapabilityType.ColorIntensity, FixtureCapabilityColor.Blue);
+        if (capabilityValue) {
+            colorBlue = 255 * capabilityValue.valuePercentage;
+        }
+        if (!colorRed && !colorGreen && !colorBlue) {
+            // no color found -> search the first color wheel
+            // TODO
+        }
+        if (colorRed !== undefined && colorGreen !== undefined && colorBlue !== undefined) {
+            for (const capability of cachedChannel.capabilities) {
+                if (capability.capability.slotNumber) {
+                    const mixedColor = this.fixtureService.getMixedWheelSlotColor(capability.wheel, capability.capability.slotNumber);
+                    if (mixedColor) {
+                        const diff = Math.abs(mixedColor.red - colorRed) + Math.abs(mixedColor.green - colorGreen) + Math.abs(mixedColor.blue - colorBlue);
+                        if (diff < lowestDiff) {
+                            lowestDiff = diff;
+                            lowestDiffCapability = capability;
+                        }
+                    }
+                }
+            }
+        }
+        return lowestDiffCapability;
+    }
+    hasCapabilityType(type) {
+        // there is at least one channel with at least one intensity capability
+        for (const fixtureUuid of this.selectedPreset.fixtureUuids) {
+            const fixture = this.fixtureService.getCachedFixtureByUuid(fixtureUuid);
+            for (const channel of fixture.channels) {
+                if (channel.channel) {
+                    for (const capability of channel.capabilities) {
+                        if (capability.capability.type === type) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    hasCapabilityDimmer() {
+        return this.hasCapabilityType(FixtureCapabilityType.Intensity);
+    }
+    hasCapabilityColor() {
+        // TODO optionally color temperature and color white (see stairville/mh-100)
+        // one of the profiles has a color intensity
+        if (this.hasCapabilityType(FixtureCapabilityType.ColorIntensity)) {
+            return true;
+        }
+        return false;
+    }
+    hasCapabilityColorOrColorWheel() {
+        // TODO optionally color temperature and color white (see stairville/mh-100)
+        // one of the profiles has a color intensity
+        if (this.hasCapabilityColor()) {
+            return true;
+        }
+        // a color wheel is involved
+        for (const fixtureUuid of this.selectedPreset.fixtureUuids) {
+            const fixture = this.fixtureService.getCachedFixtureByUuid(fixtureUuid);
+            for (const channel of fixture.channels) {
+                if (channel.colorWheel) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    hasCapabilityPanTilt() {
+        let hasPan = false;
+        let hasTilt = false;
+        // there is at least one pan and one tilt channel
+        if (this.hasCapabilityType(FixtureCapabilityType.Pan)) {
+            hasPan = true;
+        }
+        if (this.hasCapabilityType(FixtureCapabilityType.Tilt)) {
+            hasTilt = true;
+        }
+        if (hasPan && hasTilt) {
+            return true;
+        }
+        return false;
+    }
+    selectPreset(index) {
+        this.effectService.selectedEffect = undefined;
+        this.selectedPreset = this.projectService.project.presets[index];
+        this.projectService.project.selectedPresetUuid = this.projectService.project.presets[index].uuid;
+        this.autoOpenFirstEffect();
+        this.previewSelectionChanged.next();
+        this.previewLive();
+    }
+    autoOpenFirstEffect() {
+        // open the first effect, if the preset only has one
+        if (this.selectedPreset && this.selectedPreset.effects.length === 1) {
+            this.effectService.selectedEffect = this.selectedPreset.effects[0];
+        }
+    }
+    addPreset(name) {
+        const preset = new Preset();
+        preset.uuid = this.uuidService.getUuid();
+        preset.name = name || 'New Preset';
+        // Insert the new preset before the highest currently selected preset
+        let highestSelectedPresetIndex = 0;
+        for (let i = 0; i < this.projectService.project.presets.length; i++) {
+            if (this.selectedPreset === this.projectService.project.presets[i]) {
+                highestSelectedPresetIndex = i;
+                break;
+            }
+        }
+        this.projectService.project.presets.splice(highestSelectedPresetIndex, 0, preset);
+        this.selectPreset(highestSelectedPresetIndex);
+    }
+    getSelectedProfiles() {
+        const profiles = [];
+        if (!this.selectedPreset) {
+            return profiles;
+        }
+        for (const fixtureUuid of this.selectedPreset.fixtureUuids) {
+            const fixture = this.fixtureService.getFixtureByUuid(fixtureUuid);
+            const profile = this.fixtureService.getProfileByUuid(fixture.profileUuid);
+            if (profiles.indexOf(profile) < 0) {
+                profiles.push(profile);
+            }
+        }
+        return profiles;
+    }
+    getSelectedProfileChannels(selectedProfiles) {
+        const availableChannels = new Map();
+        const calculatedProfileModes = new Map();
+        for (const profile of selectedProfiles) {
+            const modes = [];
+            for (const fixtureUuid of this.selectedPreset.fixtureUuids) {
+                const fixture = this.fixtureService.getCachedFixtureByUuid(fixtureUuid);
+                if (modes.indexOf(fixture.mode) < 0) {
+                    modes.push(fixture.mode);
+                }
+            }
+            calculatedProfileModes.set(profile, modes);
+        }
+        // calculate all required channels from the modes
+        calculatedProfileModes.forEach((modes, profile) => {
+            const profileChannels = [];
+            for (const mode of modes) {
+                const channels = this.fixtureService.getCachedChannels(profile, mode);
+                for (const channel of channels) {
+                    // only add the channel, if no channel with the same name has already been added
+                    // (e.g. a fine channel)
+                    if (channel.channel && !profileChannels.find((c) => c.name === channel.name)) {
+                        profileChannels.push(channel);
+                    }
+                }
+            }
+            availableChannels.set(profile, profileChannels);
+        });
+        return availableChannels;
+    }
+    previewLive(compositionName = '', positionMillis) {
+        if (!this.configService.livePreview) {
+            return;
+        }
+        // collect all changes and delay them to not flood the backend
+        // (except play events. they need to be delivered always)
+        if (this.livePreviewTimer && !compositionName) {
+            this.liveChangePending = true;
+            return;
+        }
+        let position = positionMillis;
+        if (position === undefined) {
+            position = Math.round(this.animationService.timeMillis);
+        }
+        this.http
+            .post('preview?positionMillis=' + position + '&compositionName=' + compositionName, JSON.stringify(this.projectService.project))
+            .subscribe();
+        this.liveChangePending = false;
+        if (!compositionName) {
+            this.livePreviewTimer = setTimeout(() => {
+                this.livePreviewTimer = undefined;
+                if (this.liveChangePending) {
+                    this.http
+                        .post('preview?positionMillis=' + position + '&compositionName=' + compositionName, JSON.stringify(this.projectService.project))
+                        .subscribe();
+                }
+            }, 50);
+        }
+    }
+    stopPreviewPlay() {
+        if (!this.configService.livePreview) {
+            return;
+        }
+        this.http.post('stop-preview-play', null).subscribe();
+    }
+    static { this.ɵfac = function PresetService_Factory(t) { return new (t || PresetService)(i0.ɵɵinject(i1.EffectService), i0.ɵɵinject(i2.UuidService), i0.ɵɵinject(i3.ProjectService), i0.ɵɵinject(i4.FixtureService), i0.ɵɵinject(i5.ConfigService), i0.ɵɵinject(i6.HttpClient), i0.ɵɵinject(i7.AnimationService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PresetService, factory: PresetService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PresetService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], () => [{ type: i1.EffectService }, { type: i2.UuidService }, { type: i3.ProjectService }, { type: i4.FixtureService }, { type: i5.ConfigService }, { type: i6.HttpClient }, { type: i7.AnimationService }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preset.service.js","sourceRoot":"","sources":["../../../../../projects/designer/src/lib/services/preset.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { Subject } from 'rxjs';\nimport { CachedFixtureCapability } from '../models/cached-fixture-capability';\nimport { CachedFixtureChannel } from '../models/cached-fixture-channel';\nimport { Fixture } from '../models/fixture';\nimport { FixtureCapabilityColor, FixtureCapabilityType } from '../models/fixture-capability';\nimport { FixtureCapabilityValue } from '../models/fixture-capability-value';\nimport { FixtureChannelValue } from '../models/fixture-channel-value';\nimport { FixtureMode } from '../models/fixture-mode';\nimport { FixtureProfile } from '../models/fixture-profile';\nimport { Preset } from '../models/preset';\nimport { AnimationService } from './animation.service';\nimport { ConfigService } from './config.service';\nimport { EffectService } from './effect.service';\nimport { FixtureService } from './fixture.service';\nimport { ProjectService } from './project.service';\nimport { UuidService } from './uuid.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class PresetService {\n  selectedPreset: Preset;\n\n  // fires, when the current preview element has changed (scene/preset)\n  previewSelectionChanged: Subject<void> = new Subject<void>();\n\n  // fires, when the fixture selection has changed\n  fixtureSelectionChanged: Subject<void> = new Subject<void>();\n\n  // fires, when the fixture selection has changed for settings\n  fixtureSelectionSettingsChanged: Subject<void> = new Subject<void>();\n\n  // fires, when the selected color has changed. This is required,\n  // because detectChanges is not enough to trigger different components.\n  fixtureColorChanged: Subject<void> = new Subject<void>();\n\n  livePreviewTimer: any;\n  liveChangePending = false;\n\n  constructor(\n    private effectService: EffectService,\n    private uuidService: UuidService,\n    private projectService: ProjectService,\n    private fixtureService: FixtureService,\n    private configService: ConfigService,\n    private http: HttpClient,\n    private animationService: AnimationService\n  ) {}\n\n  getPresetByUuid(uuid: string): Preset {\n    for (const preset of this.projectService.project.presets) {\n      if (preset.uuid === uuid) {\n        return preset;\n      }\n    }\n  }\n\n  fixtureIsSelected(fixture: Fixture, preset?: Preset): boolean {\n    // is the passed fixture selected in the passed/currently selected preset?\n    if (!preset) {\n      if (this.selectedPreset) {\n        preset = this.selectedPreset;\n      } else {\n        return false;\n      }\n    }\n\n    for (const selectedFixtureUuid of preset.fixtureUuids) {\n      if (selectedFixtureUuid === fixture.uuid) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  switchFixtureSelection(fixture: Fixture) {\n    if (!this.selectedPreset) {\n      return;\n    }\n\n    // select all fixtures at the specified start channel or unselect them,\n    // if already selected\n    if (this.fixtureIsSelected(fixture)) {\n      for (let i = this.selectedPreset.fixtureUuids.length - 1; i >= 0; i--) {\n        const projectFixture = this.fixtureService.getFixtureByUuid(this.selectedPreset.fixtureUuids[i]);\n        if (projectFixture.dmxFirstChannel === fixture.dmxFirstChannel) {\n          this.selectedPreset.fixtureUuids.splice(i, 1);\n        }\n      }\n    } else {\n      for (const projectFixture of this.projectService.project.fixtures) {\n        if (projectFixture.dmxFirstChannel === fixture.dmxFirstChannel) {\n          this.selectedPreset.fixtureUuids.push(projectFixture.uuid);\n        }\n      }\n    }\n  }\n\n  selectAllFixtures() {\n    if (!this.selectedPreset) {\n      return;\n    }\n\n    for (const fixture of this.projectService.project.fixtures) {\n      if (!this.fixtureIsSelected(fixture)) {\n        this.selectedPreset.fixtureUuids.push(fixture.uuid);\n      }\n    }\n  }\n\n  selectNoFixtures() {\n    if (!this.selectedPreset) {\n      return;\n    }\n\n    this.selectedPreset.fixtureUuids = [];\n  }\n\n  public removeDeletedFixtures() {\n    // after changing the configuration in the fixture pool, we might need to\n    // delete some fixtures\n    for (const preset of this.projectService.project.presets) {\n      for (let i = preset.fixtureUuids.length - 1; i >= 0; i--) {\n        const presetFixture = this.fixtureService.getFixtureByUuid(preset.fixtureUuids[i]);\n        if (!presetFixture) {\n          preset.fixtureUuids.splice(i, 1);\n        }\n      }\n    }\n  }\n\n  public updateFixtureSelection() {\n    // after changing the configuration in the fixture pool, we might need to\n    // select some more fixtures on the same channel as already selected ones\n    for (const preset of this.projectService.project.presets) {\n      for (let i = preset.fixtureUuids.length - 1; i >= 0; i--) {\n        const presetFixture = this.fixtureService.getFixtureByUuid(preset.fixtureUuids[i]);\n        for (const projectFixture of this.projectService.project.fixtures) {\n          if (projectFixture.dmxFirstChannel === presetFixture.dmxFirstChannel && !this.fixtureIsSelected(projectFixture, preset)) {\n            preset.fixtureUuids.push(projectFixture.uuid);\n          }\n        }\n      }\n    }\n  }\n\n  deleteCapabilityValue(\n    preset: Preset,\n    capabilityType: FixtureCapabilityType,\n    color?: FixtureCapabilityColor,\n    wheel?: string,\n    profileUuid?: string\n  ) {\n    for (let i = 0; i < preset.fixtureCapabilityValues.length; i++) {\n      if (\n        this.fixtureService.capabilitiesMatch(\n          preset.fixtureCapabilityValues[i].type,\n          capabilityType,\n          preset.fixtureCapabilityValues[i].color,\n          color,\n          preset.fixtureCapabilityValues[i].wheel,\n          wheel,\n          preset.fixtureCapabilityValues[i].profileUuid,\n          profileUuid\n        )\n      ) {\n        preset.fixtureCapabilityValues.splice(i, 1);\n        return;\n      }\n    }\n  }\n\n  setCapabilityValue(\n    preset: Preset,\n    capabilityType: FixtureCapabilityType,\n    valuePercentage: number,\n    slotNumber?: number,\n    color?: FixtureCapabilityColor,\n    wheel?: string,\n    profileUuid?: string\n  ) {\n    // Delete existant properties with this type and set the new value\n    this.deleteCapabilityValue(preset, capabilityType, color, wheel, profileUuid);\n\n    const fixtureCapabilityValue = new FixtureCapabilityValue();\n    fixtureCapabilityValue.type = capabilityType;\n    fixtureCapabilityValue.color = color;\n    fixtureCapabilityValue.wheel = wheel;\n    fixtureCapabilityValue.valuePercentage = valuePercentage;\n    fixtureCapabilityValue.slotNumber = slotNumber;\n    fixtureCapabilityValue.profileUuid = profileUuid;\n\n    preset.fixtureCapabilityValues.push(fixtureCapabilityValue);\n  }\n\n  getCapabilityValue(\n    preset: Preset,\n    capabilityType: FixtureCapabilityType,\n    color?: FixtureCapabilityColor,\n    wheel?: string,\n    profileUuid?: string\n  ): FixtureCapabilityValue {\n    for (const capabilityValue of preset.fixtureCapabilityValues) {\n      if (\n        this.fixtureService.capabilitiesMatch(\n          capabilityValue.type,\n          capabilityType,\n          capabilityValue.color,\n          color,\n          capabilityValue.wheel,\n          wheel,\n          capabilityValue.profileUuid,\n          profileUuid\n        )\n      ) {\n        return capabilityValue;\n      }\n    }\n    return undefined;\n  }\n\n  deleteChannelValue(channelName: string, profileUuid: string) {\n    for (let i = 0; i < this.selectedPreset.fixtureChannelValues.length; i++) {\n      if (\n        this.selectedPreset.fixtureChannelValues[i].channelName === channelName &&\n        this.selectedPreset.fixtureChannelValues[i].profileUuid === profileUuid\n      ) {\n        this.selectedPreset.fixtureChannelValues.splice(i, 1);\n        return;\n      }\n    }\n  }\n\n  setChannelValue(channelName: string, profileUuid: string, value: number) {\n    // Delete existant properties with this type and set the new value\n    this.deleteChannelValue(channelName, profileUuid);\n\n    const fixtureChannelValue = new FixtureChannelValue();\n    fixtureChannelValue.channelName = channelName;\n    fixtureChannelValue.profileUuid = profileUuid;\n    fixtureChannelValue.value = value;\n\n    this.selectedPreset.fixtureChannelValues.push(fixtureChannelValue);\n  }\n\n  getChannelValue(channelName: string, profileUuid: string): number {\n    for (const channelValue of this.selectedPreset.fixtureChannelValues) {\n      if (channelValue.channelName === channelName && channelValue.profileUuid === profileUuid) {\n        return channelValue.value;\n      }\n    }\n  }\n\n  getApproximatedColorWheelCapability(preset: Preset, cachedChannel: CachedFixtureChannel): CachedFixtureCapability {\n    // return an approximated wheel slot channel capability, if a color or a slot on a different\n    // wheel has been selected\n    let colorRed: number;\n    let colorGreen: number;\n    let colorBlue: number;\n    let lowestDiff = Number.MAX_VALUE;\n    let lowestDiffCapability: CachedFixtureCapability;\n    let capabilityValue: FixtureCapabilityValue;\n\n    capabilityValue = this.getCapabilityValue(preset, FixtureCapabilityType.ColorIntensity, FixtureCapabilityColor.Red);\n    if (capabilityValue) {\n      colorRed = 255 * capabilityValue.valuePercentage;\n    }\n    capabilityValue = this.getCapabilityValue(preset, FixtureCapabilityType.ColorIntensity, FixtureCapabilityColor.Green);\n    if (capabilityValue) {\n      colorGreen = 255 * capabilityValue.valuePercentage;\n    }\n    capabilityValue = this.getCapabilityValue(preset, FixtureCapabilityType.ColorIntensity, FixtureCapabilityColor.Blue);\n    if (capabilityValue) {\n      colorBlue = 255 * capabilityValue.valuePercentage;\n    }\n\n    if (!colorRed && !colorGreen && !colorBlue) {\n      // no color found -> search the first color wheel\n      // TODO\n    }\n\n    if (colorRed !== undefined && colorGreen !== undefined && colorBlue !== undefined) {\n      for (const capability of cachedChannel.capabilities) {\n        if (capability.capability.slotNumber) {\n          const mixedColor = this.fixtureService.getMixedWheelSlotColor(capability.wheel, capability.capability.slotNumber);\n          if (mixedColor) {\n            const diff =\n              Math.abs(mixedColor.red - colorRed) + Math.abs(mixedColor.green - colorGreen) + Math.abs(mixedColor.blue - colorBlue);\n\n            if (diff < lowestDiff) {\n              lowestDiff = diff;\n              lowestDiffCapability = capability;\n            }\n          }\n        }\n      }\n    }\n\n    return lowestDiffCapability;\n  }\n\n  private hasCapabilityType(type: FixtureCapabilityType): boolean {\n    // there is at least one channel with at least one intensity capability\n    for (const fixtureUuid of this.selectedPreset.fixtureUuids) {\n      const fixture = this.fixtureService.getCachedFixtureByUuid(fixtureUuid);\n      for (const channel of fixture.channels) {\n        if (channel.channel) {\n          for (const capability of channel.capabilities) {\n            if (capability.capability.type === type) {\n              return true;\n            }\n          }\n        }\n      }\n    }\n    return false;\n  }\n\n  hasCapabilityDimmer(): boolean {\n    return this.hasCapabilityType(FixtureCapabilityType.Intensity);\n  }\n\n  hasCapabilityColor(): boolean {\n    // TODO optionally color temperature and color white (see stairville/mh-100)\n\n    // one of the profiles has a color intensity\n    if (this.hasCapabilityType(FixtureCapabilityType.ColorIntensity)) {\n      return true;\n    }\n\n    return false;\n  }\n\n  hasCapabilityColorOrColorWheel(): boolean {\n    // TODO optionally color temperature and color white (see stairville/mh-100)\n\n    // one of the profiles has a color intensity\n    if (this.hasCapabilityColor()) {\n      return true;\n    }\n\n    // a color wheel is involved\n    for (const fixtureUuid of this.selectedPreset.fixtureUuids) {\n      const fixture = this.fixtureService.getCachedFixtureByUuid(fixtureUuid);\n      for (const channel of fixture.channels) {\n        if (channel.colorWheel) {\n          return true;\n        }\n      }\n    }\n\n    return false;\n  }\n\n  hasCapabilityPanTilt(): boolean {\n    let hasPan = false;\n    let hasTilt = false;\n\n    // there is at least one pan and one tilt channel\n    if (this.hasCapabilityType(FixtureCapabilityType.Pan)) {\n      hasPan = true;\n    }\n\n    if (this.hasCapabilityType(FixtureCapabilityType.Tilt)) {\n      hasTilt = true;\n    }\n\n    if (hasPan && hasTilt) {\n      return true;\n    }\n\n    return false;\n  }\n\n  selectPreset(index: number) {\n    this.effectService.selectedEffect = undefined;\n    this.selectedPreset = this.projectService.project.presets[index];\n    this.projectService.project.selectedPresetUuid = this.projectService.project.presets[index].uuid;\n    this.autoOpenFirstEffect();\n    this.previewSelectionChanged.next();\n    this.previewLive();\n  }\n\n  autoOpenFirstEffect() {\n    // open the first effect, if the preset only has one\n    if (this.selectedPreset && this.selectedPreset.effects.length === 1) {\n      this.effectService.selectedEffect = this.selectedPreset.effects[0];\n    }\n  }\n\n  addPreset(name?: string): void {\n    const preset: Preset = new Preset();\n    preset.uuid = this.uuidService.getUuid();\n    preset.name = name || 'New Preset';\n\n    // Insert the new preset before the highest currently selected preset\n    let highestSelectedPresetIndex = 0;\n\n    for (let i = 0; i < this.projectService.project.presets.length; i++) {\n      if (this.selectedPreset === this.projectService.project.presets[i]) {\n        highestSelectedPresetIndex = i;\n        break;\n      }\n    }\n\n    this.projectService.project.presets.splice(highestSelectedPresetIndex, 0, preset);\n    this.selectPreset(highestSelectedPresetIndex);\n  }\n\n  getSelectedProfiles() {\n    const profiles: FixtureProfile[] = [];\n\n    if (!this.selectedPreset) {\n      return profiles;\n    }\n\n    for (const fixtureUuid of this.selectedPreset.fixtureUuids) {\n      const fixture = this.fixtureService.getFixtureByUuid(fixtureUuid);\n      const profile = this.fixtureService.getProfileByUuid(fixture.profileUuid);\n\n      if (profiles.indexOf(profile) < 0) {\n        profiles.push(profile);\n      }\n    }\n\n    return profiles;\n  }\n\n  getSelectedProfileChannels(selectedProfiles: FixtureProfile[]) {\n    const availableChannels: Map<FixtureProfile, CachedFixtureChannel[]> = new Map<FixtureProfile, CachedFixtureChannel[]>();\n\n    const calculatedProfileModes = new Map<FixtureProfile, FixtureMode[]>();\n    for (const profile of selectedProfiles) {\n      const modes: FixtureMode[] = [];\n      for (const fixtureUuid of this.selectedPreset.fixtureUuids) {\n        const fixture = this.fixtureService.getCachedFixtureByUuid(fixtureUuid);\n        if (modes.indexOf(fixture.mode) < 0) {\n          modes.push(fixture.mode);\n        }\n      }\n      calculatedProfileModes.set(profile, modes);\n    }\n\n    // calculate all required channels from the modes\n    calculatedProfileModes.forEach((modes: FixtureMode[], profile: FixtureProfile) => {\n      const profileChannels: CachedFixtureChannel[] = [];\n      for (const mode of modes) {\n        const channels = this.fixtureService.getCachedChannels(profile, mode);\n        for (const channel of channels) {\n          // only add the channel, if no channel with the same name has already been added\n          // (e.g. a fine channel)\n          if (channel.channel && !profileChannels.find((c) => c.name === channel.name)) {\n            profileChannels.push(channel);\n          }\n        }\n      }\n      availableChannels.set(profile, profileChannels);\n    });\n\n    return availableChannels;\n  }\n\n  previewLive(compositionName: string = '', positionMillis?: number) {\n    if (!this.configService.livePreview) {\n      return;\n    }\n\n    // collect all changes and delay them to not flood the backend\n    // (except play events. they need to be delivered always)\n    if (this.livePreviewTimer && !compositionName) {\n      this.liveChangePending = true;\n      return;\n    }\n\n    let position = positionMillis;\n\n    if (position === undefined) {\n      position = Math.round(this.animationService.timeMillis);\n    }\n\n    this.http\n      .post('preview?positionMillis=' + position + '&compositionName=' + compositionName, JSON.stringify(this.projectService.project))\n      .subscribe();\n\n    this.liveChangePending = false;\n\n    if (!compositionName) {\n      this.livePreviewTimer = setTimeout(() => {\n        this.livePreviewTimer = undefined;\n        if (this.liveChangePending) {\n          this.http\n            .post('preview?positionMillis=' + position + '&compositionName=' + compositionName, JSON.stringify(this.projectService.project))\n            .subscribe();\n        }\n      }, 50);\n    }\n  }\n\n  stopPreviewPlay() {\n    if (!this.configService.livePreview) {\n      return;\n    }\n\n    this.http.post('stop-preview-play', null).subscribe();\n  }\n}\n"]}