/**
     * Projcets the given object on the projector. If the object is non-stable, all other non-stable
     * elements will be removed and added to the history.
     *
     * @param projector The projector to add the object to.
     * @param obj The object to project
     */
    public async projectOn(
        projector: Projector,
        obj: Projectable | ProjectorElementBuildDeskriptor | IdentifiableProjectorElement
    ): Promise<void> {
        const element = this.getProjectorElement(obj);

        if (element.stable) {
            // remove the same element, if it is currently projected
            projector.removeElements(element);
            // Add this stable element
            projector.addElement(element);
            await this.projectRequest(projector, projector.elements);
        } else {
            // For non-stable elements remove all other non-stable elements, add them to the history and
            // add the one new element to the projector.
            const removedElements = projector.removeAllNonStableElements();
            let changed = removedElements.length > 0;

            if (element) {
                projector.addElement(element);
                changed = true;
            }
            if (changed) {
                await this.projectRequest(projector, projector.elements, null, removedElements);
            }
        }
    }

    /**
     * Projects one slide (given by the index of the preview) on the given projector. Moves
     * all current projected non-stable elements to the history.
     *
     * @param projector The projector
     * @param previewIndex The index in the `elements_preview` array.
     */
    public async projectPreviewSlide(projector: Projector, previewIndex: number): Promise<void> {
        if (projector.elements_preview.length === 0 || previewIndex >= projector.elements_preview.length) {
            return;
        }

        const removedElements = projector.removeAllNonStableElements();
        projector.addElement(projector.elements_preview.splice(previewIndex, 1)[0]);
        await this.projectRequest(projector, projector.elements, projector.elements_preview, removedElements);
    }

 /**
  * Creates the comment section from the create form.
  */
 public create(): void {
     if (this.createForm.valid && this.projectorToCreate) {
         this.projectorToCreate.patchValues(this.createForm.value as Projector);
         this.projectorToCreate.patchValues({
             reference_projector_id: this.projectors[0].reference_projector_id
         });
         this.repo.create(this.projectorToCreate).then(() => (this.projectorToCreate = null), this.raiseError);
     }
 }

    /**
     * Projects the last slide of the history. This slide will be removed from the history.
     *
     * @param projector The projector
     */
    public async projectPreviousSlide(projector: Projector): Promise<void> {
        if (projector.elements_history.length === 0) {
            return;
        }
        // Get the last element from the history
        const lastElements: ProjectorElements = projector.elements_history[projector.elements_history.length - 1];
        let lastElement: ProjectorElement = null;
        if (lastElements.length > 0) {
            lastElement = lastElements[0];
        }

        // Add all current elements to the preview.
        const removedElements = projector.removeAllNonStableElements();
        removedElements.forEach(e => projector.elements_preview.unshift(e));

        // Add last element
        if (lastElement) {
            projector.addElement(lastElement);
        }
        await this.projectRequest(projector, projector.elements, projector.elements_preview, null, true);
    }

    /**
     * Removes the given object from the projector. Non stable elements will be added to the history.
     *
     * @param projector The projector
     * @param obj the object to unproject
     */
    public async removeFrom(
        projector: Projector,
        obj: Projectable | ProjectorElementBuildDeskriptor | IdentifiableProjectorElement
    ): Promise<void> {
        const element = this.getProjectorElement(obj);

        const removedElements = projector.removeElements(element);
        if (removedElements.length > 0) {
            if (element.stable) {
                await this.projectRequest(projector, projector.elements);
            } else {
                // For non-stable elements: Add removed elements to the history.
                await this.projectRequest(projector, projector.elements, null, removedElements);
            }
        }
    }

 /**
  * Checks, if the object is projected on the given projector.
  *
  * @param obj The object
  * @param projector The projector to test
  * @returns true, if the object is projected on the projector.
  */
 public isProjectedOn(
     obj: Projectable | ProjectorElementBuildDeskriptor | IdentifiableProjectorElement,
     projector: Projector
 ): boolean {
     return projector.isElementShown(this.getProjectorElement(obj));
 }