@rocketshow/designer 1.32.0 → 1.33.0

package/esm2022/lib/fixture/fixture-capability/fixture-capability-color/fixture-capability-color.component.mjs

@@ -0,0 +1,147 @@
+import { ChangeDetectorRef, Component } from '@angular/core';
+import { FixtureCapabilityColor, FixtureCapabilityType } from '../../../models/fixture-capability';
+import { FixtureService } from '../../../services/fixture.service';
+import { PresetService } from '../../../services/preset.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/preset.service";
+import * as i2 from "../../../services/fixture.service";
+import * as i3 from "@angular/forms";
+import * as i4 from "@ngx-translate/core";
+export class FixtureCapabilityColorComponent {
+    constructor(presetService, fixtureService, changeDetectorRef) {
+        this.presetService = presetService;
+        this.fixtureService = fixtureService;
+        this.changeDetectorRef = changeDetectorRef;
+        this.color = '#ffffff';
+        this.active = false;
+        this.colorPickerMounted = false;
+        // avoid internal updating events
+        this.updatingColor = false;
+        this.updateSubscription = this.presetService.previewSelectionChanged.subscribe(() => {
+            this.update();
+            this.changeDetectorRef.detectChanges();
+        });
+        this.update();
+    }
+    update() {
+        let red;
+        let green;
+        let blue;
+        let capabilityValue;
+        capabilityValue = this.presetService.getCapabilityValue(this.presetService.selectedPreset, FixtureCapabilityType.ColorIntensity, FixtureCapabilityColor.Red);
+        if (capabilityValue) {
+            red = 255 * capabilityValue.valuePercentage;
+        }
+        capabilityValue = this.presetService.getCapabilityValue(this.presetService.selectedPreset, FixtureCapabilityType.ColorIntensity, FixtureCapabilityColor.Green);
+        if (capabilityValue) {
+            green = 255 * capabilityValue.valuePercentage;
+        }
+        capabilityValue = this.presetService.getCapabilityValue(this.presetService.selectedPreset, FixtureCapabilityType.ColorIntensity, FixtureCapabilityColor.Blue);
+        if (capabilityValue) {
+            blue = 255 * capabilityValue.valuePercentage;
+        }
+        if (red !== undefined && green !== undefined && blue !== undefined) {
+            this.active = true;
+        }
+        else {
+            this.active = false;
+            red = 255;
+            green = 255;
+            blue = 255;
+        }
+        this.color = this.fixtureService.rgbToHex(red, green, blue);
+        this.setPickerColor(red, green, blue);
+    }
+    setPickerColor(red, green, blue) {
+        this.updatingColor = true;
+        if (this.colorPicker) {
+            this.colorPicker.color.rgb = { r: red, g: green, b: blue };
+        }
+        this.updatingColor = false;
+    }
+    ngOnDestroy() {
+        this.updateSubscription.unsubscribe();
+    }
+    ngOnInit() {
+        this.colorPicker = new iro.ColorPicker('#color-picker-container', {
+            width: 180,
+            color: this.color,
+            borderWidth: 1,
+            borderColor: '#ffffff',
+            sliderMargin: 20,
+        });
+        this.colorPicker.on('color:change', this.changeColor.bind(this));
+        // mounted may be called, before this callback has been added. use input:start therefore
+        this.colorPicker.on('input:start', this.mount.bind(this));
+    }
+    mount() {
+        this.colorPickerMounted = true;
+    }
+    updateFixtureColor(color) {
+        if (this.presetService.selectedPreset) {
+            if (color) {
+                this.presetService.setCapabilityValue(this.presetService.selectedPreset, FixtureCapabilityType.ColorIntensity, color.rgb.r / 255, undefined, FixtureCapabilityColor.Red);
+                this.presetService.setCapabilityValue(this.presetService.selectedPreset, FixtureCapabilityType.ColorIntensity, color.rgb.g / 255, undefined, FixtureCapabilityColor.Green);
+                this.presetService.setCapabilityValue(this.presetService.selectedPreset, FixtureCapabilityType.ColorIntensity, color.rgb.b / 255, undefined, FixtureCapabilityColor.Blue);
+            }
+            else {
+                this.presetService.deleteCapabilityValue(this.presetService.selectedPreset, FixtureCapabilityType.ColorIntensity, FixtureCapabilityColor.Red);
+                this.presetService.deleteCapabilityValue(this.presetService.selectedPreset, FixtureCapabilityType.ColorIntensity, FixtureCapabilityColor.Green);
+                this.presetService.deleteCapabilityValue(this.presetService.selectedPreset, FixtureCapabilityType.ColorIntensity, FixtureCapabilityColor.Blue);
+            }
+            this.changeDetectorRef.detectChanges();
+            this.presetService.fixtureColorChanged.next();
+            this.presetService.previewLive();
+        }
+    }
+    changeActive(active) {
+        this.active = active;
+        if (active) {
+            this.updateFixtureColor(this.colorPicker.color);
+        }
+        else {
+            this.updateFixtureColor(undefined);
+            this.setPickerColor(255, 255, 255);
+            this.color = '#ffffff';
+        }
+        this.presetService.previewLive();
+    }
+    changeColor(color) {
+        if (!this.colorPickerMounted || this.updatingColor) {
+            return;
+        }
+        this.active = true;
+        this.color = color.hexString;
+        this.updateFixtureColor(color);
+    }
+    static { this.ɵfac = function FixtureCapabilityColorComponent_Factory(t) { return new (t || FixtureCapabilityColorComponent)(i0.ɵɵdirectiveInject(i1.PresetService), i0.ɵɵdirectiveInject(i2.FixtureService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: FixtureCapabilityColorComponent, selectors: [["lib-app-fixture-capability-color"]], decls: 12, vars: 7, consts: [[1, "card", "border-secondary", "h-100"], [1, "card-header"], [1, "my-auto", 2, "float", "left"], [1, "form-check"], ["type", "checkbox", "id", "capabilityColorActive", 1, "form-check-input", 3, "ngModelChange", "ngModel"], ["for", "capabilityColorActive", 1, "form-check-label"], [1, "pull-right"], ["type", "text", 2, "width", "58px", "text-align", "center", "font-size", "12px", "font-family", "monospace", 3, "ngModelChange", "ngModel"], [1, "card-body", "h-100"], ["id", "color-picker-container"]], template: function FixtureCapabilityColorComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div", 0)(1, "div", 1)(2, "div", 2)(3, "div", 3)(4, "input", 4);
+            i0.ɵɵlistener("ngModelChange", function FixtureCapabilityColorComponent_Template_input_ngModelChange_4_listener($event) { return ctx.changeActive($event); });
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(5, "label", 5);
+            i0.ɵɵtext(6);
+            i0.ɵɵpipe(7, "translate");
+            i0.ɵɵelementEnd()()();
+            i0.ɵɵelementStart(8, "div", 6)(9, "input", 7);
+            i0.ɵɵtwoWayListener("ngModelChange", function FixtureCapabilityColorComponent_Template_input_ngModelChange_9_listener($event) { i0.ɵɵtwoWayBindingSet(ctx.color, $event) || (ctx.color = $event); return $event; });
+            i0.ɵɵelementEnd()()();
+            i0.ɵɵelementStart(10, "div", 8);
+            i0.ɵɵelement(11, "div", 9);
+            i0.ɵɵelementEnd()();
+        } if (rf & 2) {
+            i0.ɵɵclassProp("capability-deactivated", !ctx.active);
+            i0.ɵɵadvance(4);
+            i0.ɵɵproperty("ngModel", ctx.active);
+            i0.ɵɵadvance(2);
+            i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(7, 5, "designer.fixture.capability-color"));
+            i0.ɵɵadvance(3);
+            i0.ɵɵtwoWayProperty("ngModel", ctx.color);
+        } }, dependencies: [i3.DefaultValueAccessor, i3.CheckboxControlValueAccessor, i3.NgControlStatus, i3.NgModel, i4.TranslatePipe] }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FixtureCapabilityColorComponent, [{
+        type: Component,
+        args: [{ selector: 'lib-app-fixture-capability-color', template: "<div class=\"card border-secondary h-100\" [class.capability-deactivated]=\"!active\">\n  <div class=\"card-header\">\n    <div class=\"my-auto\" style=\"float: left\">\n      <div class=\"form-check\">\n        <input\n          type=\"checkbox\"\n          class=\"form-check-input\"\n          id=\"capabilityColorActive\"\n          [ngModel]=\"active\"\n          (ngModelChange)=\"changeActive($event)\"\n        />\n        <label class=\"form-check-label\" for=\"capabilityColorActive\">{{ 'designer.fixture.capability-color' | translate }}</label>\n      </div>\n    </div>\n    <div class=\"pull-right\">\n      <input type=\"text\" [(ngModel)]=\"color\" style=\"width: 58px; text-align: center; font-size: 12px; font-family: monospace\" />\n    </div>\n  </div>\n\n  <div class=\"card-body h-100\">\n    <div id=\"color-picker-container\"></div>\n  </div>\n</div>\n" }]
+    }], () => [{ type: i1.PresetService }, { type: i2.FixtureService }, { type: i0.ChangeDetectorRef }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(FixtureCapabilityColorComponent, { className: "FixtureCapabilityColorComponent" }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fixture-capability-color.component.js","sourceRoot":"","sources":["../../../../../../../projects/designer/src/lib/fixture/fixture-capability/fixture-capability-color/fixture-capability-color.component.ts","../../../../../../../projects/designer/src/lib/fixture/fixture-capability/fixture-capability-color/fixture-capability-color.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, OnDestroy, OnInit } from '@angular/core';\nimport { Subscription } from 'rxjs';\nimport { FixtureCapabilityColor, FixtureCapabilityType } from '../../../models/fixture-capability';\nimport { FixtureCapabilityValue } from '../../../models/fixture-capability-value';\nimport { FixtureService } from '../../../services/fixture.service';\nimport { PresetService } from '../../../services/preset.service';\n\ndeclare var iro: any;\n\n@Component({\n  selector: 'lib-app-fixture-capability-color',\n  templateUrl: './fixture-capability-color.component.html',\n  styleUrls: ['./fixture-capability-color.component.css'],\n})\nexport class FixtureCapabilityColorComponent implements OnInit, OnDestroy {\n  color = '#ffffff';\n  colorPicker: any;\n  active = false;\n  private colorPickerMounted = false;\n\n  // avoid internal updating events\n  private updatingColor = false;\n\n  private updateSubscription: Subscription;\n\n  constructor(private presetService: PresetService, private fixtureService: FixtureService, private changeDetectorRef: ChangeDetectorRef) {\n    this.updateSubscription = this.presetService.previewSelectionChanged.subscribe(() => {\n      this.update();\n      this.changeDetectorRef.detectChanges();\n    });\n    this.update();\n  }\n\n  private update() {\n    let red: number;\n    let green: number;\n    let blue: number;\n    let capabilityValue: FixtureCapabilityValue;\n    capabilityValue = this.presetService.getCapabilityValue(\n      this.presetService.selectedPreset,\n      FixtureCapabilityType.ColorIntensity,\n      FixtureCapabilityColor.Red\n    );\n    if (capabilityValue) {\n      red = 255 * capabilityValue.valuePercentage;\n    }\n    capabilityValue = this.presetService.getCapabilityValue(\n      this.presetService.selectedPreset,\n      FixtureCapabilityType.ColorIntensity,\n      FixtureCapabilityColor.Green\n    );\n    if (capabilityValue) {\n      green = 255 * capabilityValue.valuePercentage;\n    }\n    capabilityValue = this.presetService.getCapabilityValue(\n      this.presetService.selectedPreset,\n      FixtureCapabilityType.ColorIntensity,\n      FixtureCapabilityColor.Blue\n    );\n    if (capabilityValue) {\n      blue = 255 * capabilityValue.valuePercentage;\n    }\n    if (red !== undefined && green !== undefined && blue !== undefined) {\n      this.active = true;\n    } else {\n      this.active = false;\n      red = 255;\n      green = 255;\n      blue = 255;\n    }\n    this.color = this.fixtureService.rgbToHex(red, green, blue);\n    this.setPickerColor(red, green, blue);\n  }\n\n  private setPickerColor(red: number, green: number, blue: number) {\n    this.updatingColor = true;\n    if (this.colorPicker) {\n      this.colorPicker.color.rgb = { r: red, g: green, b: blue };\n    }\n    this.updatingColor = false;\n  }\n\n  ngOnDestroy() {\n    this.updateSubscription.unsubscribe();\n  }\n\n  ngOnInit() {\n    this.colorPicker = new iro.ColorPicker('#color-picker-container', {\n      width: 180,\n      color: this.color,\n      borderWidth: 1,\n      borderColor: '#ffffff',\n      sliderMargin: 20,\n    });\n\n    this.colorPicker.on('color:change', this.changeColor.bind(this));\n\n    // mounted may be called, before this callback has been added. use input:start therefore\n    this.colorPicker.on('input:start', this.mount.bind(this));\n  }\n\n  mount() {\n    this.colorPickerMounted = true;\n  }\n\n  private updateFixtureColor(color: any) {\n    if (this.presetService.selectedPreset) {\n      if (color) {\n        this.presetService.setCapabilityValue(\n          this.presetService.selectedPreset,\n          FixtureCapabilityType.ColorIntensity,\n          color.rgb.r / 255,\n          undefined,\n          FixtureCapabilityColor.Red\n        );\n        this.presetService.setCapabilityValue(\n          this.presetService.selectedPreset,\n          FixtureCapabilityType.ColorIntensity,\n          color.rgb.g / 255,\n          undefined,\n          FixtureCapabilityColor.Green\n        );\n        this.presetService.setCapabilityValue(\n          this.presetService.selectedPreset,\n          FixtureCapabilityType.ColorIntensity,\n          color.rgb.b / 255,\n          undefined,\n          FixtureCapabilityColor.Blue\n        );\n      } else {\n        this.presetService.deleteCapabilityValue(\n          this.presetService.selectedPreset,\n          FixtureCapabilityType.ColorIntensity,\n          FixtureCapabilityColor.Red\n        );\n        this.presetService.deleteCapabilityValue(\n          this.presetService.selectedPreset,\n          FixtureCapabilityType.ColorIntensity,\n          FixtureCapabilityColor.Green\n        );\n        this.presetService.deleteCapabilityValue(\n          this.presetService.selectedPreset,\n          FixtureCapabilityType.ColorIntensity,\n          FixtureCapabilityColor.Blue\n        );\n      }\n      this.changeDetectorRef.detectChanges();\n      this.presetService.fixtureColorChanged.next();\n      this.presetService.previewLive();\n    }\n  }\n\n  changeActive(active: boolean) {\n    this.active = active;\n\n    if (active) {\n      this.updateFixtureColor(this.colorPicker.color);\n    } else {\n      this.updateFixtureColor(undefined);\n      this.setPickerColor(255, 255, 255);\n      this.color = '#ffffff';\n    }\n    this.presetService.previewLive();\n  }\n\n  changeColor(color: any) {\n    if (!this.colorPickerMounted || this.updatingColor) {\n      return;\n    }\n\n    this.active = true;\n    this.color = color.hexString;\n    this.updateFixtureColor(color);\n  }\n}\n","<div class=\"card border-secondary h-100\" [class.capability-deactivated]=\"!active\">\n  <div class=\"card-header\">\n    <div class=\"my-auto\" style=\"float: left\">\n      <div class=\"form-check\">\n        <input\n          type=\"checkbox\"\n          class=\"form-check-input\"\n          id=\"capabilityColorActive\"\n          [ngModel]=\"active\"\n          (ngModelChange)=\"changeActive($event)\"\n        />\n        <label class=\"form-check-label\" for=\"capabilityColorActive\">{{ 'designer.fixture.capability-color' | translate }}</label>\n      </div>\n    </div>\n    <div class=\"pull-right\">\n      <input type=\"text\" [(ngModel)]=\"color\" style=\"width: 58px; text-align: center; font-size: 12px; font-family: monospace\" />\n    </div>\n  </div>\n\n  <div class=\"card-body h-100\">\n    <div id=\"color-picker-container\"></div>\n  </div>\n</div>\n"]}

package/esm2022/lib/fixture/fixture-capability/fixture-capability-color-wheel/fixture-capability-color-wheel.component.mjs

@@ -0,0 +1,213 @@
+import { ChangeDetectorRef, Component, Input } from '@angular/core';
+import { CachedFixtureChannel } from '../../../models/cached-fixture-channel';
+import { FixtureCapabilityType } from '../../../models/fixture-capability';
+import { FixtureProfile } from '../../../models/fixture-profile';
+import { FixtureService } from '../../../services/fixture.service';
+import { PresetService } from '../../../services/preset.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/preset.service";
+import * as i2 from "../../../services/fixture.service";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/forms";
+import * as i5 from "@ngx-translate/core";
+function FixtureCapabilityColorWheelComponent_div_9_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div");
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate2("", ctx_r0._fixtureProfile.name, " - ", ctx_r0._channel.name, "");
+} }
+function FixtureCapabilityColorWheelComponent_div_10_div_1_div_1_Template(rf, ctx) { if (rf & 1) {
+    const _r4 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 13);
+    i0.ɵɵlistener("click", function FixtureCapabilityColorWheelComponent_div_10_div_1_div_1_Template_div_click_0_listener() { i0.ɵɵrestoreView(_r4); const slot_r3 = i0.ɵɵnextContext().$implicit; const ctx_r0 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r0.selectSlotNumber(slot_r3.capability.slotNumber)); });
+    i0.ɵɵelementEnd();
+} }
+function FixtureCapabilityColorWheelComponent_div_10_div_1_Template(rf, ctx) { if (rf & 1) {
+    const _r2 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 11);
+    i0.ɵɵlistener("click", function FixtureCapabilityColorWheelComponent_div_10_div_1_Template_div_click_0_listener() { const slot_r3 = i0.ɵɵrestoreView(_r2).$implicit; const ctx_r0 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r0.selectSlotNumber(slot_r3.capability.slotNumber)); });
+    i0.ɵɵtemplate(1, FixtureCapabilityColorWheelComponent_div_10_div_1_div_1_Template, 1, 0, "div", 12);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const slot_r3 = ctx.$implicit;
+    const ctx_r0 = i0.ɵɵnextContext(2);
+    i0.ɵɵclassProp("color-selected", ctx_r0.slotCapabilityIsSelected(slot_r3.capability.slotNumber));
+    i0.ɵɵproperty("ngStyle", ctx_r0.getCapabilityColorStyle(slot_r3));
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngIf", ctx_r0.slotCapabilityIsSelected(slot_r3.capability.slotNumber));
+} }
+function FixtureCapabilityColorWheelComponent_div_10_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 9);
+    i0.ɵɵtemplate(1, FixtureCapabilityColorWheelComponent_div_10_div_1_Template, 2, 4, "div", 10);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("ngForOf", ctx_r0.slotCapabilities);
+} }
+export class FixtureCapabilityColorWheelComponent {
+    set profile(value) {
+        this._fixtureProfile = value;
+        this.update();
+    }
+    set channel(value) {
+        this._channel = value;
+        this.update();
+    }
+    constructor(presetService, changeDetectorRef, fixtureService) {
+        this.presetService = presetService;
+        this.changeDetectorRef = changeDetectorRef;
+        this.fixtureService = fixtureService;
+        this.showContainer = false;
+    }
+    ngOnInit() {
+        this.colorChangeSubscription = this.presetService.fixtureColorChanged.subscribe(() => {
+            this.changeDetectorRef.detectChanges();
+        });
+    }
+    ngOnDestroy() {
+        this.colorChangeSubscription.unsubscribe();
+    }
+    update() {
+        if (this._fixtureProfile && this._channel) {
+            this.wheelName = undefined;
+            this.slotCapabilities = [];
+            // get the wheel name
+            for (const capability of this._channel.capabilities) {
+                if (capability.wheel) {
+                    this.wheelName = capability.wheelName;
+                    break;
+                }
+            }
+            if (!this.wheelName) {
+                this.wheelName = this._channel.name;
+            }
+            this.wheel = this.fixtureService.getWheelByName(this._fixtureProfile, this.wheelName);
+            // calculate all available slots
+            for (const capability of this._channel.capabilities) {
+                if (capability.capability.type === FixtureCapabilityType.WheelSlot) {
+                    this.slotCapabilities.push(capability);
+                }
+            }
+        }
+        this.changeDetectorRef.detectChanges();
+    }
+    getCapabilityColorStyle(capability) {
+        let property = 'background-color';
+        let value = 'black';
+        let colors = [];
+        if (capability.wheelSlots) {
+            for (const slot of capability.wheelSlots) {
+                // calculate the color based on the color wheel slot
+                if (slot.colors.length > 0) {
+                    colors = colors.concat(slot.colors);
+                }
+            }
+        }
+        if (colors.length > 1) {
+            // mixed colors -> gradient
+            let colorString;
+            for (const color of colors) {
+                if (colorString) {
+                    colorString += ', ';
+                }
+                else {
+                    colorString = '';
+                }
+                colorString += color;
+            }
+            property = 'background-image';
+            value = 'linear-gradient(to bottom right, ' + colorString + ')';
+        }
+        else if (colors.length === 1) {
+            value = colors[0];
+        }
+        else {
+            value = '#fff';
+        }
+        const style = {};
+        style[property] = value;
+        return style;
+    }
+    getCurrentSlotNumber() {
+        const capabilityValue = this.presetService.getCapabilityValue(this.presetService.selectedPreset, FixtureCapabilityType.WheelSlot, undefined, this.wheelName, this._fixtureProfile.uuid);
+        if (capabilityValue) {
+            return capabilityValue.slotNumber;
+        }
+        return undefined;
+    }
+    slotCapabilityIsSelected(slotNumber) {
+        const selectedSlotNumber = this.getCurrentSlotNumber();
+        if (selectedSlotNumber >= 0) {
+            // a slot is selected
+            return selectedSlotNumber === slotNumber;
+        }
+        else {
+            // no slot is selected and the capability is inactive
+            // -> show the approx. color, if a color or a similar slot from a different wheel has been selected
+            const approximatedCapability = this.presetService.getApproximatedColorWheelCapability(this.presetService.selectedPreset, this._channel);
+            if (approximatedCapability) {
+                return slotNumber === approximatedCapability.capability.slotNumber;
+            }
+            else {
+                return false;
+            }
+        }
+    }
+    changeActive(active) {
+        if (active) {
+            this.presetService.setCapabilityValue(this.presetService.selectedPreset, FixtureCapabilityType.WheelSlot, undefined, 1, undefined, this.wheelName, this._fixtureProfile.uuid);
+        }
+        else {
+            this.presetService.deleteCapabilityValue(this.presetService.selectedPreset, FixtureCapabilityType.WheelSlot, undefined, this.wheelName, this._fixtureProfile.uuid);
+        }
+        this.presetService.previewLive();
+    }
+    selectSlotNumber(slotNumber) {
+        this.presetService.setCapabilityValue(this.presetService.selectedPreset, FixtureCapabilityType.WheelSlot, undefined, slotNumber, undefined, this.wheelName, this._fixtureProfile.uuid);
+        this.presetService.previewLive();
+    }
+    static { this.ɵfac = function FixtureCapabilityColorWheelComponent_Factory(t) { return new (t || FixtureCapabilityColorWheelComponent)(i0.ɵɵdirectiveInject(i1.PresetService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i2.FixtureService)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: FixtureCapabilityColorWheelComponent, selectors: [["lib-app-fixture-capability-color-wheel"]], inputs: { profile: "profile", channel: "channel", wheelIndex: "wheelIndex", showContainer: "showContainer" }, decls: 11, vars: 12, consts: [[1, "card", "border-secondary", "h-100", 2, "min-height", "200px"], [1, "card-header"], [1, "my-auto"], [1, "form-check"], ["type", "checkbox", 1, "form-check-input", 3, "ngModelChange", "id", "ngModel"], [1, "form-check-label", 3, "for"], [1, "card-body", "h-100"], [4, "ngIf"], ["class", "d-flex", "style", "max-width: 240px; flex-wrap: wrap", 4, "ngIf"], [1, "d-flex", 2, "max-width", "240px", "flex-wrap", "wrap"], ["class", "m-1 color", 3, "color-selected", "ngStyle", "click", 4, "ngFor", "ngForOf"], [1, "m-1", "color", 3, "click", "ngStyle"], ["class", "color-selected-inner", 3, "click", 4, "ngIf"], [1, "color-selected-inner", 3, "click"]], template: function FixtureCapabilityColorWheelComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div", 0)(1, "div", 1)(2, "div", 2)(3, "div", 3)(4, "input", 4);
+            i0.ɵɵlistener("ngModelChange", function FixtureCapabilityColorWheelComponent_Template_input_ngModelChange_4_listener($event) { return ctx.changeActive($event); });
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(5, "label", 5);
+            i0.ɵɵtext(6);
+            i0.ɵɵpipe(7, "translate");
+            i0.ɵɵelementEnd()()()();
+            i0.ɵɵelementStart(8, "div", 6);
+            i0.ɵɵtemplate(9, FixtureCapabilityColorWheelComponent_div_9_Template, 2, 2, "div", 7)(10, FixtureCapabilityColorWheelComponent_div_10_Template, 2, 1, "div", 8);
+            i0.ɵɵelementEnd()();
+        } if (rf & 2) {
+            i0.ɵɵclassProp("capability-deactivated", ctx.getCurrentSlotNumber() == undefined);
+            i0.ɵɵadvance(4);
+            i0.ɵɵpropertyInterpolate1("id", "capabilityColorWheel", ctx.wheelIndex, "Active");
+            i0.ɵɵproperty("ngModel", ctx.getCurrentSlotNumber() != undefined);
+            i0.ɵɵadvance();
+            i0.ɵɵpropertyInterpolate1("for", "capabilityColorWheel", ctx.wheelIndex, "Active");
+            i0.ɵɵadvance();
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(7, 10, "designer.fixture.capability-color"), " ");
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("ngIf", ctx.showContainer);
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("ngIf", ctx.wheel);
+        } }, dependencies: [i3.NgForOf, i3.NgIf, i3.NgStyle, i4.CheckboxControlValueAccessor, i4.NgControlStatus, i4.NgModel, i5.TranslatePipe], styles: [".color[_ngcontent-%COMP%]{box-sizing:border-box;width:50px;height:50px;border:solid 1px #ced4da;cursor:pointer}.color-selected[_ngcontent-%COMP%]{border-width:3px;border-color:#fff}.color-selected-inner[_ngcontent-%COMP%]{border:solid 1px black;height:100%;width:100%}"] }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FixtureCapabilityColorWheelComponent, [{
+        type: Component,
+        args: [{ selector: 'lib-app-fixture-capability-color-wheel', template: "<div class=\"card border-secondary h-100\" [class.capability-deactivated]=\"getCurrentSlotNumber() == undefined\" style=\"min-height: 200px\">\n  <div class=\"card-header\">\n    <div class=\"my-auto\">\n      <div class=\"form-check\">\n        <input\n          type=\"checkbox\"\n          class=\"form-check-input\"\n          id=\"capabilityColorWheel{{ wheelIndex }}Active\"\n          [ngModel]=\"getCurrentSlotNumber() != undefined\"\n          (ngModelChange)=\"changeActive($event)\"\n        />\n        <label class=\"form-check-label\" for=\"capabilityColorWheel{{ wheelIndex }}Active\">\n          {{ 'designer.fixture.capability-color' | translate }}\n        </label>\n      </div>\n    </div>\n  </div>\n\n  <div class=\"card-body h-100\">\n    <div *ngIf=\"showContainer\">{{ _fixtureProfile.name }} - {{ _channel.name }}</div>\n\n    <div *ngIf=\"wheel\" class=\"d-flex\" style=\"max-width: 240px; flex-wrap: wrap\">\n      <div\n        *ngFor=\"let slot of slotCapabilities; let i = index\"\n        (click)=\"selectSlotNumber(slot.capability.slotNumber)\"\n        class=\"m-1 color\"\n        [class.color-selected]=\"slotCapabilityIsSelected(slot.capability.slotNumber)\"\n        [ngStyle]=\"getCapabilityColorStyle(slot)\"\n      >\n        <div\n          *ngIf=\"slotCapabilityIsSelected(slot.capability.slotNumber)\"\n          (click)=\"selectSlotNumber(slot.capability.slotNumber)\"\n          class=\"color-selected-inner\"\n        ></div>\n      </div>\n    </div>\n  </div>\n</div>\n", styles: [".color{box-sizing:border-box;width:50px;height:50px;border:solid 1px #ced4da;cursor:pointer}.color-selected{border-width:3px;border-color:#fff}.color-selected-inner{border:solid 1px black;height:100%;width:100%}\n"] }]
+    }], () => [{ type: i1.PresetService }, { type: i0.ChangeDetectorRef }, { type: i2.FixtureService }], { profile: [{
+            type: Input
+        }], channel: [{
+            type: Input
+        }], wheelIndex: [{
+            type: Input
+        }], showContainer: [{
+            type: Input
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(FixtureCapabilityColorWheelComponent, { className: "FixtureCapabilityColorWheelComponent" }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fixture-capability-color-wheel.component.js","sourceRoot":"","sources":["../../../../../../../projects/designer/src/lib/fixture/fixture-capability/fixture-capability-color-wheel/fixture-capability-color-wheel.component.ts","../../../../../../../projects/designer/src/lib/fixture/fixture-capability/fixture-capability-color-wheel/fixture-capability-color-wheel.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, Input, OnDestroy, OnInit } from '@angular/core';\nimport { Subscription } from 'rxjs';\nimport { CachedFixtureCapability } from '../../../models/cached-fixture-capability';\nimport { CachedFixtureChannel } from '../../../models/cached-fixture-channel';\nimport { FixtureCapabilityType } from '../../../models/fixture-capability';\nimport { FixtureProfile } from '../../../models/fixture-profile';\nimport { FixtureWheel } from '../../../models/fixture-wheel';\nimport { FixtureService } from '../../../services/fixture.service';\nimport { PresetService } from '../../../services/preset.service';\n\n@Component({\n  selector: 'lib-app-fixture-capability-color-wheel',\n  templateUrl: './fixture-capability-color-wheel.component.html',\n  styleUrls: ['./fixture-capability-color-wheel.component.css'],\n})\nexport class FixtureCapabilityColorWheelComponent implements OnInit, OnDestroy {\n  _fixtureProfile: FixtureProfile;\n  _channel: CachedFixtureChannel;\n  wheelName: string;\n  wheel: FixtureWheel;\n  slotCapabilities: CachedFixtureCapability[];\n\n  private colorChangeSubscription: Subscription;\n\n  @Input()\n  set profile(value: FixtureProfile) {\n    this._fixtureProfile = value;\n    this.update();\n  }\n\n  @Input()\n  set channel(value: CachedFixtureChannel) {\n    this._channel = value;\n    this.update();\n  }\n\n  @Input()\n  wheelIndex: number;\n\n  @Input()\n  showContainer = false;\n\n  constructor(public presetService: PresetService, private changeDetectorRef: ChangeDetectorRef, private fixtureService: FixtureService) {}\n\n  ngOnInit() {\n    this.colorChangeSubscription = this.presetService.fixtureColorChanged.subscribe(() => {\n      this.changeDetectorRef.detectChanges();\n    });\n  }\n\n  ngOnDestroy() {\n    this.colorChangeSubscription.unsubscribe();\n  }\n\n  private update() {\n    if (this._fixtureProfile && this._channel) {\n      this.wheelName = undefined;\n      this.slotCapabilities = [];\n\n      // get the wheel name\n      for (const capability of this._channel.capabilities) {\n        if (capability.wheel) {\n          this.wheelName = capability.wheelName;\n          break;\n        }\n      }\n      if (!this.wheelName) {\n        this.wheelName = this._channel.name;\n      }\n\n      this.wheel = this.fixtureService.getWheelByName(this._fixtureProfile, this.wheelName);\n\n      // calculate all available slots\n      for (const capability of this._channel.capabilities) {\n        if (capability.capability.type === FixtureCapabilityType.WheelSlot) {\n          this.slotCapabilities.push(capability);\n        }\n      }\n    }\n\n    this.changeDetectorRef.detectChanges();\n  }\n\n  getCapabilityColorStyle(capability: CachedFixtureCapability): any {\n    let property = 'background-color';\n    let value = 'black';\n    let colors: string[] = [];\n\n    if (capability.wheelSlots) {\n      for (const slot of capability.wheelSlots) {\n        // calculate the color based on the color wheel slot\n        if (slot.colors.length > 0) {\n          colors = colors.concat(slot.colors);\n        }\n      }\n    }\n\n    if (colors.length > 1) {\n      // mixed colors -> gradient\n      let colorString: string;\n      for (const color of colors) {\n        if (colorString) {\n          colorString += ', ';\n        } else {\n          colorString = '';\n        }\n        colorString += color;\n      }\n      property = 'background-image';\n      value = 'linear-gradient(to bottom right, ' + colorString + ')';\n    } else if (colors.length === 1) {\n      value = colors[0];\n    } else {\n      value = '#fff';\n    }\n\n    const style = {};\n    style[property] = value;\n    return style;\n  }\n\n  getCurrentSlotNumber(): number {\n    const capabilityValue = this.presetService.getCapabilityValue(\n      this.presetService.selectedPreset,\n      FixtureCapabilityType.WheelSlot,\n      undefined,\n      this.wheelName,\n      this._fixtureProfile.uuid\n    );\n\n    if (capabilityValue) {\n      return capabilityValue.slotNumber;\n    }\n    return undefined;\n  }\n\n  slotCapabilityIsSelected(slotNumber: number): boolean {\n    const selectedSlotNumber = this.getCurrentSlotNumber();\n\n    if (selectedSlotNumber >= 0) {\n      // a slot is selected\n      return selectedSlotNumber === slotNumber;\n    } else {\n      // no slot is selected and the capability is inactive\n      // -> show the approx. color, if a color or a similar slot from a different wheel has been selected\n      const approximatedCapability = this.presetService.getApproximatedColorWheelCapability(\n        this.presetService.selectedPreset,\n        this._channel\n      );\n\n      if (approximatedCapability) {\n        return slotNumber === approximatedCapability.capability.slotNumber;\n      } else {\n        return false;\n      }\n    }\n  }\n\n  changeActive(active: boolean) {\n    if (active) {\n      this.presetService.setCapabilityValue(\n        this.presetService.selectedPreset,\n        FixtureCapabilityType.WheelSlot,\n        undefined,\n        1,\n        undefined,\n        this.wheelName,\n        this._fixtureProfile.uuid\n      );\n    } else {\n      this.presetService.deleteCapabilityValue(\n        this.presetService.selectedPreset,\n        FixtureCapabilityType.WheelSlot,\n        undefined,\n        this.wheelName,\n        this._fixtureProfile.uuid\n      );\n    }\n\n    this.presetService.previewLive();\n  }\n\n  selectSlotNumber(slotNumber: number) {\n    this.presetService.setCapabilityValue(\n      this.presetService.selectedPreset,\n      FixtureCapabilityType.WheelSlot,\n      undefined,\n      slotNumber,\n      undefined,\n      this.wheelName,\n      this._fixtureProfile.uuid\n    );\n    this.presetService.previewLive();\n  }\n}\n","<div class=\"card border-secondary h-100\" [class.capability-deactivated]=\"getCurrentSlotNumber() == undefined\" style=\"min-height: 200px\">\n  <div class=\"card-header\">\n    <div class=\"my-auto\">\n      <div class=\"form-check\">\n        <input\n          type=\"checkbox\"\n          class=\"form-check-input\"\n          id=\"capabilityColorWheel{{ wheelIndex }}Active\"\n          [ngModel]=\"getCurrentSlotNumber() != undefined\"\n          (ngModelChange)=\"changeActive($event)\"\n        />\n        <label class=\"form-check-label\" for=\"capabilityColorWheel{{ wheelIndex }}Active\">\n          {{ 'designer.fixture.capability-color' | translate }}\n        </label>\n      </div>\n    </div>\n  </div>\n\n  <div class=\"card-body h-100\">\n    <div *ngIf=\"showContainer\">{{ _fixtureProfile.name }} - {{ _channel.name }}</div>\n\n    <div *ngIf=\"wheel\" class=\"d-flex\" style=\"max-width: 240px; flex-wrap: wrap\">\n      <div\n        *ngFor=\"let slot of slotCapabilities; let i = index\"\n        (click)=\"selectSlotNumber(slot.capability.slotNumber)\"\n        class=\"m-1 color\"\n        [class.color-selected]=\"slotCapabilityIsSelected(slot.capability.slotNumber)\"\n        [ngStyle]=\"getCapabilityColorStyle(slot)\"\n      >\n        <div\n          *ngIf=\"slotCapabilityIsSelected(slot.capability.slotNumber)\"\n          (click)=\"selectSlotNumber(slot.capability.slotNumber)\"\n          class=\"color-selected-inner\"\n        ></div>\n      </div>\n    </div>\n  </div>\n</div>\n"]}

package/esm2022/lib/fixture/fixture-capability/fixture-capability-dimmer/fixture-capability-dimmer.component.mjs

@@ -0,0 +1,78 @@
+import { ChangeDetectorRef, Component } from '@angular/core';
+import { FixtureCapabilityType } from '../../../models/fixture-capability';
+import { PresetService } from '../../../services/preset.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/preset.service";
+import * as i2 from "@angular/forms";
+import * as i3 from "ngx-bootstrap-slider";
+export class FixtureCapabilityDimmerComponent {
+    constructor(presetService, changeDetectorRef) {
+        this.presetService = presetService;
+        this.changeDetectorRef = changeDetectorRef;
+    }
+    ngOnInit() { }
+    getValue() {
+        const capabilityValue = this.presetService.getCapabilityValue(this.presetService.selectedPreset, FixtureCapabilityType.Intensity);
+        if (capabilityValue) {
+            return capabilityValue.valuePercentage;
+        }
+        return undefined;
+    }
+    getValueText() {
+        const value = this.getValue();
+        if (value >= 0) {
+            return Math.round(value * 100 * 100) / 100;
+        }
+        return undefined;
+    }
+    setValue(value) {
+        if (isNaN(value)) {
+            return;
+        }
+        if (value < 0 || value > 1) {
+            return;
+        }
+        this.presetService.setCapabilityValue(this.presetService.selectedPreset, FixtureCapabilityType.Intensity, value);
+        this.changeDetectorRef.detectChanges();
+        this.presetService.previewLive();
+    }
+    changeActive(active) {
+        if (active) {
+            this.setValue(1);
+        }
+        else {
+            this.presetService.deleteCapabilityValue(this.presetService.selectedPreset, FixtureCapabilityType.Intensity);
+            this.changeDetectorRef.detectChanges();
+        }
+        this.presetService.previewLive();
+    }
+    static { this.ɵfac = function FixtureCapabilityDimmerComponent_Factory(t) { return new (t || FixtureCapabilityDimmerComponent)(i0.ɵɵdirectiveInject(i1.PresetService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: FixtureCapabilityDimmerComponent, selectors: [["lib-app-fixture-capability-dimmer"]], decls: 12, vars: 11, consts: [[1, "card", "border-secondary", "h-100", 2, "min-height", "200px"], [1, "card-header"], [1, "my-auto"], [1, "form-check"], ["type", "checkbox", "id", "capabilityDimmerActive", 1, "form-check-input", 3, "ngModelChange", "ngModel"], ["for", "capabilityDimmerActive", 1, "form-check-label"], [1, "icon-dimmer"], [1, "card-body", "h-100", "d-flex", 2, "flex-direction", "column"], [1, "mb-4", "w-100", "d-flex"], ["type", "text", 1, "mx-auto", 2, "width", "42px", "height", "20px", "text-align", "center", "font-size", "12px", "font-family", "monospace", 3, "ngModelChange", "ngModel"], [1, "h-100", "w-100", "d-flex"], [1, "mx-auto", 2, "height", "100%", 3, "change", "value", "orientation", "reversed", "tooltip", "min", "max", "step"]], template: function FixtureCapabilityDimmerComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div", 0)(1, "div", 1)(2, "div", 2)(3, "div", 3)(4, "input", 4);
+            i0.ɵɵlistener("ngModelChange", function FixtureCapabilityDimmerComponent_Template_input_ngModelChange_4_listener($event) { return ctx.changeActive($event); });
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(5, "label", 5);
+            i0.ɵɵelement(6, "i", 6);
+            i0.ɵɵelementEnd()()()();
+            i0.ɵɵelementStart(7, "div", 7)(8, "div", 8)(9, "input", 9);
+            i0.ɵɵlistener("ngModelChange", function FixtureCapabilityDimmerComponent_Template_input_ngModelChange_9_listener($event) { return ctx.setValue($event / 100); });
+            i0.ɵɵelementEnd()();
+            i0.ɵɵelementStart(10, "div", 10)(11, "mv-slider", 11);
+            i0.ɵɵlistener("change", function FixtureCapabilityDimmerComponent_Template_mv_slider_change_11_listener($event) { return ctx.setValue($event.newValue); });
+            i0.ɵɵelementEnd()()()();
+        } if (rf & 2) {
+            i0.ɵɵclassProp("capability-deactivated", ctx.getValue() == undefined);
+            i0.ɵɵadvance(4);
+            i0.ɵɵproperty("ngModel", ctx.getValue() != undefined);
+            i0.ɵɵadvance(5);
+            i0.ɵɵproperty("ngModel", ctx.getValueText() >= 0 ? ctx.getValueText() : 0);
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("value", ctx.getValue() >= 0 ? ctx.getValue() : 0)("orientation", "vertical")("reversed", true)("tooltip", "hide")("min", 0)("max", 1)("step", 0.001);
+        } }, dependencies: [i2.DefaultValueAccessor, i2.CheckboxControlValueAccessor, i2.NgControlStatus, i2.NgModel, i3.SliderComponent] }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FixtureCapabilityDimmerComponent, [{
+        type: Component,
+        args: [{ selector: 'lib-app-fixture-capability-dimmer', template: "<div class=\"card border-secondary h-100\" [class.capability-deactivated]=\"getValue() == undefined\" style=\"min-height: 200px\">\n  <div class=\"card-header\">\n    <div class=\"my-auto\">\n      <div class=\"form-check\">\n        <input\n          type=\"checkbox\"\n          class=\"form-check-input\"\n          id=\"capabilityDimmerActive\"\n          [ngModel]=\"getValue() != undefined\"\n          (ngModelChange)=\"changeActive($event)\"\n        />\n        <label class=\"form-check-label\" for=\"capabilityDimmerActive\">\n          <i class=\"icon-dimmer\"></i>\n        </label>\n      </div>\n    </div>\n  </div>\n\n  <div class=\"card-body h-100 d-flex\" style=\"flex-direction: column\">\n    <div class=\"mb-4 w-100 d-flex\">\n      <input\n        class=\"mx-auto\"\n        type=\"text\"\n        [ngModel]=\"getValueText() >= 0 ? getValueText() : 0\"\n        (ngModelChange)=\"setValue($event / 100)\"\n        style=\"width: 42px; height: 20px; text-align: center; font-size: 12px; font-family: monospace\"\n      />\n    </div>\n\n    <div class=\"h-100 w-100 d-flex\">\n      <mv-slider\n        class=\"mx-auto\"\n        [value]=\"getValue() >= 0 ? getValue() : 0\"\n        (change)=\"setValue($event.newValue)\"\n        [orientation]=\"'vertical'\"\n        [reversed]=\"true\"\n        style=\"height: 100%\"\n        [tooltip]=\"'hide'\"\n        [min]=\"0\"\n        [max]=\"1\"\n        [step]=\"0.001\"\n      ></mv-slider>\n    </div>\n  </div>\n</div>\n" }]
+    }], () => [{ type: i1.PresetService }, { type: i0.ChangeDetectorRef }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(FixtureCapabilityDimmerComponent, { className: "FixtureCapabilityDimmerComponent" }); })();
+//# sourceMappingURL=data:application/json;base64,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