diff --git a/docs/release-notes-editor.txt b/docs/release-notes-editor.txt
index 68f45cee8df985b481b43439d1f5ffe2e8103a27..e54c428d183ab8f41a9e360b6ae18728b063bd9c 100644
--- a/docs/release-notes-editor.txt
+++ b/docs/release-notes-editor.txt
@@ -1,5 +1,11 @@
 Editor
 ======
+1.35.0
+- Implement hotspot image element
+  Clickable and non-clickable (read-only) areas can be placed on an image.
+  The shapes of the areas can be ellipses and rectangles. Their position,
+  size, rotation, color and frame thickness can be set. The elements can be marked as required.
+
 1.34.0
 - Implement GeoGebra applet element
   This needs a base64 representation of a unit.
diff --git a/docs/release-notes-player.txt b/docs/release-notes-player.txt
index 739dea7068895316440c18fe1c12638712c98dd8..473415b0369aa01f2bea9648a4b7d5c58eee841f 100644
--- a/docs/release-notes-player.txt
+++ b/docs/release-notes-player.txt
@@ -1,5 +1,9 @@
 Player
 ======
+1.20.0
+- Support for hotspot image element
+  Clickable areas of the image are colored on click.
+
 1.27.0
 - Add new input assistance presets ('Space' and 'Comma').
   The preset 'Space' can be used to separate words.
diff --git a/projects/common/components/input-elements/hotspot-image.component.ts b/projects/common/components/input-elements/hotspot-image.component.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4f09383d2533f2a6779a7abb6dcea3681750fabe
--- /dev/null
+++ b/projects/common/components/input-elements/hotspot-image.component.ts
@@ -0,0 +1,56 @@
+import { Component, Input } from '@angular/core';
+import { HotspotImageElement } from 'common/models/elements/input-elements/hotspot-image';
+import { FormElementComponent } from '../../directives/form-element-component.directive';
+
+@Component({
+  selector: 'aspect-hotspot-image',
+  template: `
+    <div *ngIf="elementModel.src"
+         [style.width.%]="100"
+         [style.height.%]="100"
+         class="image-container">
+      <img [src]="elementModel.src | safeResourceUrl"
+           [alt]="'imageNotFound' | translate"
+           tabindex="0"
+           (focusout)="elementFormControl.markAsTouched()">
+      <div *ngFor="let item of elementModel.value; let index = index">
+        <div class="hotspot"
+             [class.active-hotspot]="!item.readOnly"
+             [class.circle]="item.shape === 'ellipse'"
+             [class.border]="item.borderWidth > 0"
+             [style.border-width.px]="item.borderWidth"
+             [style.border-color]="item.borderColor"
+             [style.background-color]="(parentForm && elementFormControl.value[index].value) ||
+                                       (!parentForm && item.value) ?
+                                       item.backgroundColor :
+                                       'transparent'"
+             [style.top.px]="item.top"
+             [style.left.px]="item.left"
+             [style.width.px]="item.width"
+             [style.height.px]="item.height"
+             [style.transform]="'rotate(' + item.rotation + 'deg)'"
+             (click)="!item.readOnly && parentForm ? onHotspotClicked(index) : null">
+        </div>
+      </div>
+      <mat-error *ngIf="elementFormControl.errors && elementFormControl.touched">
+        {{elementFormControl.errors | errorTransform: elementModel}}
+      </mat-error>
+    </div>
+  `,
+  styles: [
+    '.circle {border-radius: 50%;}',
+    '.border {border-color: #000000; border-style: solid}',
+    '.hotspot {position: absolute; box-sizing: border-box;}',
+    '.active-hotspot {cursor: pointer;}',
+    '.image-container {position: relative;}'
+  ]
+})
+export class HotspotImageComponent extends FormElementComponent {
+  @Input() elementModel!: HotspotImageElement;
+
+  onHotspotClicked(index: number): void {
+    const actualValue = this.elementFormControl.value;
+    actualValue[index].value = !actualValue[index].value;
+    this.elementFormControl.setValue(actualValue);
+  }
+}
diff --git a/projects/common/models/elements/element.ts b/projects/common/models/elements/element.ts
index e7b072b657b2349f1b8f9ef8baf78bf642059415..ee0b7536e38def1f018cbfd42de01299abc80f98 100644
--- a/projects/common/models/elements/element.ts
+++ b/projects/common/models/elements/element.ts
@@ -6,11 +6,11 @@ import { ElementFactory } from 'common/util/element.factory';
 import { LikertRowElement } from 'common/models/elements/compound-elements/likert/likert-row';
 
 export type UIElementType = 'text' | 'button' | 'text-field' | 'text-field-simple' | 'text-area' | 'checkbox'
-| 'dropdown' | 'radio' | 'image' | 'audio' | 'video' | 'likert' | 'likert-row' | 'radio-group-images'
+| 'dropdown' | 'radio' | 'image' | 'audio' | 'video' | 'likert' | 'likert-row' | 'radio-group-images' | 'hotspot-image'
 | 'drop-list' | 'drop-list-simple' | 'cloze' | 'spell-correct' | 'slider' | 'frame' | 'toggle-button' | 'geometry';
 
 export type UIElementValue = string | number | boolean | undefined | UIElementType | InputElementValue |
-TextLabel | TextLabel[] | ClozeDocument | LikertRowElement[] |
+TextLabel | TextLabel[] | ClozeDocument | LikertRowElement[] | Hotspot[] |
 PositionProperties | PlayerProperties | BasicStyles;
 
 export type InputAssistancePreset = null | 'french' | 'numbers' | 'numbersAndOperators' | 'numbersAndBasicOperators'
@@ -61,7 +61,7 @@ export abstract class UIElement {
   abstract getElementComponent(): Type<ElementComponent>;
 }
 
-export type InputElementValue = string[] | string | number | boolean | TextLabel[] | null;
+export type InputElementValue = string[] | string | number | boolean | TextLabel[] | null | Hotspot[] | boolean[];
 
 export abstract class InputElement extends UIElement {
   label: string = 'Beschriftung';
@@ -200,6 +200,20 @@ export interface PlayerProperties {
   playbackTime: number;
 }
 
+export interface Hotspot {
+  top: number;
+  left: number;
+  width: number;
+  height: number;
+  shape: 'ellipse' | 'rect';
+  borderWidth: number;
+  borderColor: string;
+  backgroundColor: string;
+  rotation: number;
+  value: boolean;
+  readOnly: boolean
+}
+
 export interface ValueChangeElement {
   id: string;
   value: InputElementValue;
diff --git a/projects/common/models/elements/input-elements/hotspot-image.ts b/projects/common/models/elements/input-elements/hotspot-image.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dc4d79671fb67dae6c20a666305e754a1324b8c2
--- /dev/null
+++ b/projects/common/models/elements/input-elements/hotspot-image.ts
@@ -0,0 +1,53 @@
+import { Type } from '@angular/core';
+import { ElementFactory } from 'common/util/element.factory';
+import {
+  InputElement, PositionedUIElement, PositionProperties, AnswerScheme, Hotspot, AnswerSchemeValue
+} from 'common/models/elements/element';
+import { ElementComponent } from 'common/directives/element-component.directive';
+import { HotspotImageComponent } from 'common/components/input-elements/hotspot-image.component';
+
+export class HotspotImageElement extends InputElement implements PositionedUIElement {
+  value: Hotspot[];
+  src: string | null = null;
+  position: PositionProperties;
+
+  constructor(element: Partial<HotspotImageElement>) {
+    super({ height: 100, ...element });
+    this.value = element.value !== undefined ? [...element.value] : [];
+    if (element.src) this.src = element.src;
+    this.position = ElementFactory.initPositionProps(element.position);
+  }
+
+  hasAnswerScheme(): boolean {
+    return Boolean(this.getAnswerScheme);
+  }
+
+  getAnswerScheme(): AnswerScheme {
+    return {
+      id: this.id,
+      type: 'boolean',
+      format: '',
+      multiple: true,
+      nullable: false,
+      values: this.getAnswerSchemeValues(),
+      valuesComplete: true
+    };
+  }
+
+  private getAnswerSchemeValues(): AnswerSchemeValue[] {
+    return this.value
+      .map((hotspot, index) => ({
+        value: (index + 1).toString(),
+        label: `top: ${hotspot.top},
+        left: ${hotspot.left},
+        height: ${hotspot.height},
+        width: ${hotspot.width},
+        shape: ${hotspot.shape},
+        value: ${hotspot.value}`
+      }));
+  }
+
+  getElementComponent(): Type<ElementComponent> {
+    return HotspotImageComponent;
+  }
+}
diff --git a/projects/common/models/section.ts b/projects/common/models/section.ts
index 96ef87fc0b86d0f21190e451fde2bca7aeade9c6..38a12066ca0a746126b7dcdff6c1378f3d7073f6 100644
--- a/projects/common/models/section.ts
+++ b/projects/common/models/section.ts
@@ -27,6 +27,7 @@ import { SpellCorrectElement } from 'common/models/elements/input-elements/spell
 import { FrameElement } from 'common/models/elements/frame/frame';
 import { ToggleButtonElement } from 'common/models/elements/compound-elements/cloze/cloze-child-elements/toggle-button';
 import { GeometryElement } from 'common/models/elements/geometry/geometry';
+import { HotspotImageElement } from 'common/models/elements/input-elements/hotspot-image';
 
 export class Section {
   [index: string]: unknown;
@@ -49,6 +50,7 @@ export class Section {
     checkbox: CheckboxElement,
     dropdown: DropdownElement,
     radio: RadioButtonGroupElement,
+    'hotspot-image': HotspotImageElement,
     image: ImageElement,
     audio: AudioElement,
     video: VideoElement,
diff --git a/projects/common/shared.module.ts b/projects/common/shared.module.ts
index 102cb183d48b3da6f3c640f4b40b1bd13838eb22..161d618b177bdcfb5c384b3820bb9778d04a1c9a 100644
--- a/projects/common/shared.module.ts
+++ b/projects/common/shared.module.ts
@@ -21,6 +21,7 @@ import { MatDialogModule } from '@angular/material/dialog';
 import { MatSliderModule } from '@angular/material/slider';
 import { DomSanitizer } from '@angular/platform-browser';
 import { HttpClientModule } from '@angular/common/http';
+import { HotspotImageComponent } from 'common/components/input-elements/hotspot-image.component';
 import { TextComponent } from './components/text/text.component';
 import { ButtonComponent } from './components/button/button.component';
 import { TextFieldComponent } from './components/input-elements/text-field.component';
@@ -113,6 +114,7 @@ import { GeometryComponent } from './components/geometry/geometry.component';
     RadioGroupImagesComponent,
     DropListComponent,
     ClozeComponent,
+    HotspotImageComponent,
     DropListSimpleComponent,
     SliderComponent,
     SpellCorrectComponent,
@@ -158,6 +160,7 @@ import { GeometryComponent } from './components/geometry/geometry.component';
     RadioGroupImagesComponent,
     DropListComponent,
     ClozeComponent,
+    HotspotImageComponent,
     LikertComponent,
     ButtonComponent,
     FrameComponent,
diff --git a/projects/editor/src/app/app.module.ts b/projects/editor/src/app/app.module.ts
index a42abb5f032bd0ffef2251aecc16e7cd61adf413..a2e2e07121540eb8931aae0adee6a511dd830064 100644
--- a/projects/editor/src/app/app.module.ts
+++ b/projects/editor/src/app/app.module.ts
@@ -21,6 +21,13 @@ import { MatListModule } from '@angular/material/list';
 
 import { APIService, SharedModule } from 'common/shared.module';
 import { SectionInsertDialogComponent } from 'editor/src/app/components/dialogs/section-insert-dialog.component';
+import { HotspotListPanelComponent } from 'editor/src/app/components/properties-panel/hotspot-list-panel.component';
+import { VeronaAPIService } from 'editor/src/app/services/verona-api.service';
+import { MatRadioModule } from '@angular/material/radio';
+import {
+  HotspotFieldSetComponent
+} from 'editor/src/app/components/properties-panel/model-properties-tab/input-groups/hotspot-field-set.component';
+import { HotspotEditDialogComponent } from 'editor/src/app/components/dialogs/hotspot-edit-dialog.component';
 import { AppComponent } from './app.component';
 import { ToolbarComponent } from './components/toolbar/toolbar.component';
 import { UiElementToolboxComponent } from
@@ -88,7 +95,6 @@ import { LikertRowLabelPipe } from './components/properties-panel/likert-row-lab
 import { LabelEditDialogComponent } from './components/dialogs/label-edit-dialog.component';
 import { BorderPropertiesComponent } from './components/properties-panel/model-properties-tab/input-groups/border-properties.component';
 import { GeogebraAppDefinitionDialogComponent } from './components/dialogs/geogebra-app-definition-dialog.component';
-import { VeronaAPIService } from 'editor/src/app/services/verona-api.service';
 
 @NgModule({
   declarations: [
@@ -115,6 +121,7 @@ import { VeronaAPIService } from 'editor/src/app/services/verona-api.service';
     PlayerEditDialogComponent,
     LikertRowEditDialogComponent,
     RichTextEditDialogComponent,
+    HotspotEditDialogComponent,
     ElementModelPropertiesComponent,
     DropListOptionEditDialogComponent,
     PositionFieldSetComponent,
@@ -135,6 +142,8 @@ import { VeronaAPIService } from 'editor/src/app/services/verona-api.service';
     InputElementPropertiesComponent,
     PresetValuePropertiesComponent,
     OptionListPanelComponent,
+    HotspotFieldSetComponent,
+    HotspotListPanelComponent,
     LikertRowLabelPipe,
     LabelEditDialogComponent,
     BorderPropertiesComponent,
@@ -162,7 +171,8 @@ import { VeronaAPIService } from 'editor/src/app/services/verona-api.service';
         useClass: EditorTranslateLoader
       }
     }),
-    MatListModule
+    MatListModule,
+    MatRadioModule
   ],
   providers: [
     { provide: APIService, useExisting: VeronaAPIService }
diff --git a/projects/editor/src/app/components/dialogs/hotspot-edit-dialog.component.ts b/projects/editor/src/app/components/dialogs/hotspot-edit-dialog.component.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8acee1882bc50d925f44dffcc1326f524dca2427
--- /dev/null
+++ b/projects/editor/src/app/components/dialogs/hotspot-edit-dialog.component.ts
@@ -0,0 +1,95 @@
+import { Component, Inject } from '@angular/core';
+import { MAT_DIALOG_DATA } from '@angular/material/dialog';
+import { Hotspot } from 'common/models/elements/element';
+
+@Component({
+  selector: 'aspect-hotspot-edit-dialog',
+  template: `
+    <mat-dialog-content fxLayout="column" fxLayoutGap="10px">
+      <div fxLayout="row" fxLayoutGap="10px">
+        <mat-form-field appearance="fill" fxFlex="50">
+          <mat-label>{{ 'hotspot.top' | translate }}</mat-label>
+          <input matInput type="number" min="0"
+                 [(ngModel)]="newHotspot.top">
+        </mat-form-field>
+        <mat-form-field appearance="fill" fxFlex="50">
+          <mat-label>{{ 'hotspot.left' | translate }}</mat-label>
+          <input matInput type="number" min="0"
+                 [(ngModel)]="newHotspot.left">
+        </mat-form-field>
+      </div>
+      <div fxLayout="row" fxLayoutGap="10px">
+        <mat-form-field appearance="fill" fxFlex="50">
+          <mat-label>{{ 'hotspot.width' | translate }}</mat-label>
+          <input matInput type="number" min="0"
+                 [(ngModel)]="newHotspot.width">
+        </mat-form-field>
+        <mat-form-field appearance="fill" fxFlex="50">
+          <mat-label>{{ 'hotspot.height' | translate }}</mat-label>
+          <input matInput type="number" min="0"
+                 [(ngModel)]="newHotspot.height">
+        </mat-form-field>
+      </div>
+      <div fxLayout="row" fxLayoutGap="10px" fxLayoutAlign="space-between center">
+        <mat-radio-group [(ngModel)]="newHotspot.shape" fxFlex="50" fxLayout='column' fxLayoutGap="5px">
+          <label>{{'hotspot.shape' | translate}}</label>
+          <mat-radio-button value='ellipse'>{{'hotspot.ellipse' | translate}}</mat-radio-button>
+          <mat-radio-button value='rect'>{{'hotspot.rect' | translate}}</mat-radio-button>
+        </mat-radio-group>
+        <mat-form-field appearance="fill" fxFlex="50">
+          <mat-label>{{ 'hotspot.borderWidth' | translate }}</mat-label>
+          <input matInput type="number" min="0"
+                 [(ngModel)]="newHotspot.borderWidth">
+        </mat-form-field>
+      </div>
+
+
+      <div fxLayout="row" fxLayoutGap="10px">
+        <mat-form-field appearance="fill" class="mdInput textsingleline">
+          <mat-label>{{'hotspot.backgroundColor' | translate }}</mat-label>
+          <input matInput type="text" [(ngModel)]="newHotspot.backgroundColor">
+          <button mat-icon-button matSuffix (click)="backgroundColorInput.click()">
+            <mat-icon>edit</mat-icon>
+          </button>
+        </mat-form-field>
+        <input matInput type="color" hidden #backgroundColorInput [(ngModel)]="newHotspot.backgroundColor">
+
+        <mat-form-field appearance="fill" class="mdInput textsingleline">
+          <mat-label>{{'hotspot.borderColor' | translate }}</mat-label>
+          <input matInput type="text" [(ngModel)]="newHotspot.borderColor">
+          <button mat-icon-button matSuffix (click)="borderColorInput.click()">
+            <mat-icon>edit</mat-icon>
+          </button>
+        </mat-form-field>
+        <input matInput type="color" hidden #borderColorInput [(ngModel)]="newHotspot.borderColor">
+      </div>
+
+      <div fxLayout="row" fxLayoutGap="10px">
+        <mat-form-field appearance="fill" fxFlex="50">
+          <mat-label>{{ 'hotspot.rotation' | translate }}</mat-label>
+          <input matInput type="number" min="0"
+                 [(ngModel)]="newHotspot.rotation">
+        </mat-form-field>
+        <div fxFlex="50">
+          <mat-checkbox [checked]="newHotspot.value"
+                        (change)="newHotspot.value = $event.checked">
+            {{ 'hotspot.value' | translate }}
+          </mat-checkbox>
+          <mat-checkbox [checked]="newHotspot.readOnly"
+                        (change)="newHotspot.readOnly = $event.checked">
+            {{ 'hotspot.readOnly' | translate }}
+          </mat-checkbox>
+        </div>
+      </div>
+    </mat-dialog-content>
+    <mat-dialog-actions>
+      <button mat-button [mat-dialog-close]="newHotspot">{{'save' | translate }}</button>
+      <button mat-button mat-dialog-close>{{'cancel' | translate }}</button>
+    </mat-dialog-actions>
+  `
+})
+export class HotspotEditDialogComponent {
+  constructor(@Inject(MAT_DIALOG_DATA) public data: { hotspot: Hotspot }) { }
+
+  newHotspot = { ...this.data.hotspot };
+}
diff --git a/projects/editor/src/app/components/new-ui-element-panel/ui-element-toolbox.component.html b/projects/editor/src/app/components/new-ui-element-panel/ui-element-toolbox.component.html
index 60f37bc8b39dec1702917ec9077f6afc79a97c3c..02d738d389b8e59fd70ed354112a2d949d59e71e 100644
--- a/projects/editor/src/app/components/new-ui-element-panel/ui-element-toolbox.component.html
+++ b/projects/editor/src/app/components/new-ui-element-panel/ui-element-toolbox.component.html
@@ -93,6 +93,11 @@
       <mat-icon>linear_scale</mat-icon>
       {{'toolbox.slider' | translate }}
     </button>
+    <button mat-stroked-button (click)="addUIElement('hotspot-image')"
+            draggable="true" (dragstart)="$event.dataTransfer?.setData('elementType','hotspot-image')">
+      <mat-icon>ads_click</mat-icon>
+      {{'toolbox.hotspot-image' | translate }}
+    </button>
   </mat-expansion-panel>
   <mat-expansion-panel>
     <mat-expansion-panel-header>
diff --git a/projects/editor/src/app/components/properties-panel/element-properties-panel.component.ts b/projects/editor/src/app/components/properties-panel/element-properties-panel.component.ts
index 323a3c0ac2c2f22e26633f5a8812b5d430163856..eb06f2b6ebd754f4788238c050e6ed2572f7b22e 100644
--- a/projects/editor/src/app/components/properties-panel/element-properties-panel.component.ts
+++ b/projects/editor/src/app/components/properties-panel/element-properties-panel.component.ts
@@ -6,7 +6,7 @@ import { Subject } from 'rxjs';
 import { takeUntil } from 'rxjs/operators';
 import { TranslateService } from '@ngx-translate/core';
 import { MessageService } from 'common/services/message.service';
-import { TextLabel, UIElement } from 'common/models/elements/element';
+import { Hotspot, TextLabel, UIElement } from 'common/models/elements/element';
 import { LikertRowElement } from 'common/models/elements/compound-elements/likert/likert-row';
 import { UnitService } from '../../services/unit.service';
 import { SelectionService } from '../../services/selection.service';
@@ -85,7 +85,7 @@ export class ElementPropertiesPanelComponent implements OnInit, OnDestroy {
   }
 
   updateModel(property: string,
-              value: string | number | boolean | string[] |
+              value: string | number | boolean | string[] | boolean[] | Hotspot[] |
               TextLabel | TextLabel[] | LikertRowElement[] | null,
               isInputValid: boolean | null = true): void {
     if (isInputValid) {
diff --git a/projects/editor/src/app/components/properties-panel/hotspot-list-panel.component.ts b/projects/editor/src/app/components/properties-panel/hotspot-list-panel.component.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3f7988c0cd2f98f5f0643bdea93e12e1590cabcc
--- /dev/null
+++ b/projects/editor/src/app/components/properties-panel/hotspot-list-panel.component.ts
@@ -0,0 +1,55 @@
+import {
+  Component, EventEmitter, Input, Output
+} from '@angular/core';
+import { CdkDragDrop } from '@angular/cdk/drag-drop/drag-events';
+import { Hotspot } from 'common/models/elements/element';
+
+@Component({
+  selector: 'aspect-hotspot-list-panel',
+  template: `
+    <fieldset fxLayout="column">
+      <legend>{{title | translate }}</legend>
+      <button mat-mini-fab matSuffix color="primary" [style.bottom.px]="3" fxFlexAlign="end"
+              (click)="addListItem();">
+        <mat-icon>add</mat-icon>
+      </button>
+
+      <div class="drop-list" cdkDropList [cdkDropListData]="itemList"
+           (cdkDropListDropped)="moveListValue($event)">
+        <div *ngFor="let item of itemList; let i = index" cdkDrag
+             class="option-draggable" fxLayout="row">
+          <div fxFlex fxFlexAlign="center">{{'hotspot.'+item.shape | translate}}({{i + 1}})</div>
+          <button mat-icon-button color="primary"
+                  (click)="editItem.emit(i)">
+            <mat-icon>build</mat-icon>
+          </button>
+          <button mat-icon-button color="primary"
+                  (click)="removeListItem(i)">
+            <mat-icon>clear</mat-icon>
+          </button>
+        </div>
+      </div>
+    </fieldset>
+  `
+})
+export class HotspotListPanelComponent {
+  @Input() title!: string;
+  @Input() textFieldLabel!: string;
+  @Input() itemList!: Hotspot[];
+  @Output() addItem = new EventEmitter<void>();
+  @Output() removeItem = new EventEmitter<number>();
+  @Output() editItem = new EventEmitter<number>();
+  @Output() changedItemOrder = new EventEmitter<{ previousIndex: number, currentIndex: number }>();
+
+  addListItem(): void {
+    this.addItem.emit();
+  }
+
+  removeListItem(itemIndex: number): void {
+    this.removeItem.emit(itemIndex);
+  }
+
+  moveListValue(event: CdkDragDrop<Hotspot[]>): void {
+    this.changedItemOrder.emit({ previousIndex: event.previousIndex, currentIndex: event.currentIndex });
+  }
+}
diff --git a/projects/editor/src/app/components/properties-panel/model-properties-tab/element-model-properties.component.html b/projects/editor/src/app/components/properties-panel/model-properties-tab/element-model-properties.component.html
index 47d9db4b66ea83d88608dafeff028a1c045f8ed2..1c3ca293ce2a0d014a11860393b711410e5e6d51 100644
--- a/projects/editor/src/app/components/properties-panel/model-properties-tab/element-model-properties.component.html
+++ b/projects/editor/src/app/components/properties-panel/model-properties-tab/element-model-properties.component.html
@@ -31,6 +31,11 @@
                             (updateModel)="updateModel.emit($event)">
   </aspect-options-field-set>
 
+  <aspect-hotspot-field-set *ngIf="combinedProperties.type === 'hotspot-image'"
+                            [combinedProperties]="combinedProperties"
+                            (updateModel)="updateModel.emit($event)">
+  </aspect-hotspot-field-set>
+
   <aspect-border-properties [combinedProperties]="combinedProperties"
                             (updateModel)="updateModel.emit($event)"></aspect-border-properties>
 
diff --git a/projects/editor/src/app/components/properties-panel/model-properties-tab/element-model-properties.component.ts b/projects/editor/src/app/components/properties-panel/model-properties-tab/element-model-properties.component.ts
index b27890edeb611bc49369488b0df06317a8599dc7..3006f14ec8decaf14163944e2d09a27a26de71b3 100644
--- a/projects/editor/src/app/components/properties-panel/model-properties-tab/element-model-properties.component.ts
+++ b/projects/editor/src/app/components/properties-panel/model-properties-tab/element-model-properties.component.ts
@@ -6,15 +6,15 @@ import { DomSanitizer } from '@angular/platform-browser';
 import { CdkDragDrop } from '@angular/cdk/drag-drop/drag-events';
 import { moveItemInArray } from '@angular/cdk/drag-drop';
 import {
-  InputElementValue, TextLabel, TextImageLabel, UIElement
+  InputElementValue, TextLabel, TextImageLabel, UIElement, Hotspot
 } from 'common/models/elements/element';
 import { LikertRowElement } from 'common/models/elements/compound-elements/likert/likert-row';
 import { FileService } from 'common/services/file.service';
 import { CombinedProperties } from 'editor/src/app/components/properties-panel/element-properties-panel.component';
+import { firstValueFrom } from 'rxjs';
 import { UnitService } from '../../../services/unit.service';
 import { SelectionService } from '../../../services/selection.service';
 import { DialogService } from '../../../services/dialog.service';
-import { firstValueFrom } from 'rxjs';
 
 @Component({
   selector: 'aspect-element-model-properties-component',
@@ -26,7 +26,7 @@ export class ElementModelPropertiesComponent {
   @Input() selectedElements: UIElement[] = [];
   @Output() updateModel = new EventEmitter<{
     property: string;
-    value: InputElementValue | TextImageLabel[] | LikertRowElement[] | TextLabel[],
+    value: InputElementValue | TextImageLabel[] | LikertRowElement[] | TextLabel[] | Hotspot[]
     isInputValid?: boolean | null
   }>();
 
diff --git a/projects/editor/src/app/components/properties-panel/model-properties-tab/input-groups/hotspot-field-set.component.ts b/projects/editor/src/app/components/properties-panel/model-properties-tab/input-groups/hotspot-field-set.component.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c3e6898687afc9d0a3310ec0364c68dd0530c6c1
--- /dev/null
+++ b/projects/editor/src/app/components/properties-panel/model-properties-tab/input-groups/hotspot-field-set.component.ts
@@ -0,0 +1,70 @@
+import {
+  Component, EventEmitter, Input, Output
+} from '@angular/core';
+import { Hotspot } from 'common/models/elements/element';
+import { CombinedProperties } from 'editor/src/app/components/properties-panel/element-properties-panel.component';
+import { DialogService } from 'editor/src/app/services/dialog.service';
+import { moveItemInArray } from '@angular/cdk/drag-drop';
+
+@Component({
+  selector: 'aspect-hotspot-field-set',
+  template: `
+    <aspect-hotspot-list-panel *ngIf="combinedProperties.value !== undefined"
+                               [itemList]="$any(combinedProperties.value)"
+                               [title]="'propertiesPanel.hotspots' | translate"
+                               [textFieldLabel]="'propertiesPanel.newHotspot' | translate"
+                               (changedItemOrder)="moveHotspot($event)"
+                               (addItem)="addHotspot()"
+                               (removeItem)="removeHotspot($event)"
+                               (editItem)="editHotspot($event)">
+    </aspect-hotspot-list-panel>
+  `
+})
+export class HotspotFieldSetComponent {
+  @Input() combinedProperties!: CombinedProperties;
+  @Output() updateModel = new EventEmitter<{ property: string; value: Hotspot[] }>();
+
+  constructor(private dialogService: DialogService) { }
+
+  addHotspot(): void {
+    const newHotspot: Hotspot = {
+      top: 10,
+      left: 10,
+      width: 20,
+      height: 20,
+      shape: 'rect',
+      borderWidth: 1,
+      borderColor: '#000000',
+      backgroundColor: '#000000',
+      rotation: 0,
+      value: false,
+      readOnly: false
+    };
+    (this.combinedProperties.value as Hotspot[]).push(newHotspot);
+    this.updateModel.emit({ property: 'value', value: this.combinedProperties.value as Hotspot[] });
+  }
+
+  removeHotspot(index: number): void {
+    const valueList = this.combinedProperties.value as Hotspot[];
+    valueList.splice(index, 1);
+    this.updateModel.emit({ property: 'value', value: valueList });
+  }
+
+  moveHotspot(indices: { previousIndex: number, currentIndex: number }): void {
+    moveItemInArray(this.combinedProperties.value as Hotspot[],
+      indices.previousIndex,
+      indices.currentIndex);
+    this.updateModel.emit({ property: 'value', value: this.combinedProperties.value as Hotspot[] });
+  }
+
+  async editHotspot(index: number): Promise<void> {
+    const selectedOption = (this.combinedProperties.value as Hotspot[])[index];
+    await this.dialogService.showHotspotEditDialog(selectedOption)
+      .subscribe((result: Hotspot) => {
+        if (result) {
+          (this.combinedProperties.value as Hotspot[])[index] = result;
+          this.updateModel.emit({ property: 'value', value: (this.combinedProperties.value as Hotspot[]) });
+        }
+      });
+  }
+}
diff --git a/projects/editor/src/app/services/dialog.service.ts b/projects/editor/src/app/services/dialog.service.ts
index d7091d01c63e2d857bc9820642aa124866a4fe5f..e43faa42ae769c349a775becf9644ad305c42e08 100644
--- a/projects/editor/src/app/services/dialog.service.ts
+++ b/projects/editor/src/app/services/dialog.service.ts
@@ -4,13 +4,17 @@ import { MatDialog } from '@angular/material/dialog';
 import {
   DragNDropValueObject,
   PlayerProperties,
-  TextImageLabel, Label
+  TextImageLabel, Label, Hotspot
 } from 'common/models/elements/element';
 import { ClozeDocument } from 'common/models/elements/compound-elements/cloze/cloze';
 import { LikertRowElement } from 'common/models/elements/compound-elements/likert/likert-row';
 import { Section } from 'common/models/section';
 import { SectionInsertDialogComponent } from 'editor/src/app/components/dialogs/section-insert-dialog.component';
 import { LabelEditDialogComponent } from 'editor/src/app/components/dialogs/label-edit-dialog.component';
+import {
+  GeogebraAppDefinitionDialogComponent
+} from 'editor/src/app/components/dialogs/geogebra-app-definition-dialog.component';
+import { HotspotEditDialogComponent } from 'editor/src/app/components/dialogs/hotspot-edit-dialog.component';
 import { ConfirmationDialogComponent } from '../components/dialogs/confirmation-dialog.component';
 import { TextEditDialogComponent } from '../components/dialogs/text-edit-dialog.component';
 import { TextEditMultilineDialogComponent } from '../components/dialogs/text-edit-multiline-dialog.component';
@@ -18,9 +22,6 @@ import { RichTextEditDialogComponent } from '../components/dialogs/rich-text-edi
 import { PlayerEditDialogComponent } from '../components/dialogs/player-edit-dialog.component';
 import { LikertRowEditDialogComponent } from '../components/dialogs/likert-row-edit-dialog.component';
 import { DropListOptionEditDialogComponent } from '../components/dialogs/drop-list-option-edit-dialog.component';
-import {
-  GeogebraAppDefinitionDialogComponent
-} from 'editor/src/app/components/dialogs/geogebra-app-definition-dialog.component';
 
 @Injectable({
   providedIn: 'root'
@@ -103,6 +104,13 @@ export class DialogService {
     return dialogRef.afterClosed();
   }
 
+  showHotspotEditDialog(hotspot: Hotspot): Observable<Hotspot> {
+    const dialogRef = this.dialog.open(HotspotEditDialogComponent, {
+      data: { hotspot }
+    });
+    return dialogRef.afterClosed();
+  }
+
   showSectionInsertDialog(section: Section): Observable<Section> {
     const dialogRef = this.dialog.open(SectionInsertDialogComponent, {
       data: { section }
diff --git a/projects/editor/src/app/services/id.service.ts b/projects/editor/src/app/services/id.service.ts
index c6be2eef012839a5025179c8660ed94b9db5351e..d96646ed78652765a1ebfc4b1ac6a8dda31f3f05 100644
--- a/projects/editor/src/app/services/id.service.ts
+++ b/projects/editor/src/app/services/id.service.ts
@@ -18,6 +18,7 @@ export class IDService {
     checkbox: 0,
     dropdown: 0,
     radio: 0,
+    'hotspot-image': 0,
     image: 0,
     audio: 0,
     video: 0,
diff --git a/projects/editor/src/app/services/unit.service.ts b/projects/editor/src/app/services/unit.service.ts
index e87713ae2a1de5f74f44efe89491c23133f07359..10ccfb36ef56183e00aa911f0ed56435845d00bf 100644
--- a/projects/editor/src/app/services/unit.service.ts
+++ b/projects/editor/src/app/services/unit.service.ts
@@ -11,7 +11,7 @@ import {
   CompoundElement,
   DragNDropValueObject, InputElement,
   InputElementValue, TextLabel, PlayerElement, PlayerProperties, PositionedUIElement,
-  UIElement, UIElementType, UIElementValue
+  UIElement, UIElementType, UIElementValue, Hotspot
 } from 'common/models/elements/element';
 import { ClozeDocument, ClozeElement } from 'common/models/elements/compound-elements/cloze/cloze';
 import { LikertRowElement } from 'common/models/elements/compound-elements/likert/likert-row';
@@ -109,9 +109,10 @@ export class UnitService {
       newElement.appDefinition = await firstValueFrom(this.dialogService.showGeogebraAppDefinitionDialog());
       if (!newElement.appDefinition) return; // dialog canceled
     }
-    if (['audio', 'video', 'image'].includes(elementType)) {
+    if (['audio', 'video', 'image', 'hotspot-image'].includes(elementType)) {
       let mediaSrc = '';
       switch (elementType) {
+        case 'hotspot-image':
         case 'image':
           mediaSrc = await FileService.loadImage();
           break;
@@ -225,7 +226,7 @@ export class UnitService {
 
   updateElementsProperty(elements: UIElement[],
                          property: string,
-                         value: InputElementValue | LikertRowElement[] |
+                         value: InputElementValue | LikertRowElement[] | Hotspot[] |
                          TextLabel | TextLabel[] | ClozeDocument | null): void {
     console.log('updateElementProperty', elements, property, value);
     elements.forEach(element => {
diff --git a/projects/editor/src/assets/i18n/de.json b/projects/editor/src/assets/i18n/de.json
index a1c997be93f0a1ee6aaa3972d77ddea27b1e8fa8..56ae888e3d6a8333cc175f9b125472aa6a5511cf 100644
--- a/projects/editor/src/assets/i18n/de.json
+++ b/projects/editor/src/assets/i18n/de.json
@@ -177,7 +177,24 @@
     "showFullscreenButton": "Vollbild-Knopf anzeigen",
     "enableShiftDragZoom": "Bewegen und Zoom erlauben",
     "customToolBar": "Anpassung Werkzeugleiste",
-    "customToolbarHelp": "Hier kann definiert werden, welche Elemente auf der Werkzeigleiste angezeigt werden sollen. Für Details bitte die Dokumentation konsultieren."
+    "customToolbarHelp": "Hier kann definiert werden, welche Elemente auf der Werkzeigleiste angezeigt werden sollen. Für Details bitte die Dokumentation konsultieren.",
+    "hotspots": "Aktive Bereiche",
+    "newHotspot": "Neuer Bereich"
+  },
+  "hotspot": {
+    "top": "Abstand von oben",
+    "left": "Abstand von links",
+    "width": "Bereichsbreite",
+    "height": "Bereichshöhe",
+    "borderWidth": "Rahmenbreite",
+    "borderColor": "Rahmenfarbe",
+    "shape": "Bereichsform",
+    "rect": "Rechteck",
+    "ellipse": "Ellipse",
+    "rotation": "Drehung",
+    "backgroundColor": "Füllfarbe (bei Aktivierung)",
+    "value": "Aktivierter Bereich",
+    "readOnly": "Schreibgeschützt"
   },
   "player": {
     "autoStart": "Autostart (nicht für Tablets)",
@@ -225,7 +242,8 @@
     "slider": "Schieberegler",
     "spell-correct": "Wort korrigieren",
     "toggle-button": "Optionsfeld",
-    "geometry": "Geometrie"
+    "geometry": "Geometrie",
+    "hotspot-image": "Bildbereiche"
   },
   "section-menu": {
     "height": "Höhe",
diff --git a/projects/player/src/app/components/elements/element-group-selection/element-group-selection.component.ts b/projects/player/src/app/components/elements/element-group-selection/element-group-selection.component.ts
index 687252a70892730c4583987431cde758e7bc90d7..e1b3034f699f0f9a98865e8416d1797e4aca7a13 100644
--- a/projects/player/src/app/components/elements/element-group-selection/element-group-selection.component.ts
+++ b/projects/player/src/app/components/elements/element-group-selection/element-group-selection.component.ts
@@ -1,6 +1,6 @@
 import { Component, Input, OnInit } from '@angular/core';
-import { ElementGroup, ElementGroupName } from '../../../models/element-group';
 import { UIElement, UIElementType } from 'common/models/elements/element';
+import { ElementGroup, ElementGroupName } from '../../../models/element-group';
 
 @Component({
   selector: 'aspect-element-group-selection',
@@ -16,7 +16,7 @@ export class ElementGroupSelectionComponent implements OnInit {
     { name: 'mediaPlayerGroup', types: ['audio', 'video'] },
     {
       name: 'inputGroup',
-      types: ['checkbox', 'slider', 'drop-list', 'radio', 'radio-group-images', 'dropdown']
+      types: ['checkbox', 'slider', 'drop-list', 'radio', 'radio-group-images', 'dropdown', 'hotspot-image']
     },
     { name: 'compoundGroup', types: ['cloze', 'likert'] },
     { name: 'textGroup', types: ['text'] },
diff --git a/projects/player/src/app/components/elements/input-group-element/input-group-element.component.html b/projects/player/src/app/components/elements/input-group-element/input-group-element.component.html
index b4ad838ba9b10e449e9a10be7a9f2b95d98fb361..f7be78e173f1677ea3e7436b282ad0d7a877a61a 100644
--- a/projects/player/src/app/components/elements/input-group-element/input-group-element.component.html
+++ b/projects/player/src/app/components/elements/input-group-element/input-group-element.component.html
@@ -30,6 +30,12 @@
       [parentForm]="form"
       [elementModel]="elementModel | cast: RadioButtonGroupComplexElement">
   </aspect-radio-group-images>
+  <aspect-hotspot-image
+    *ngIf="elementModel.type === 'hotspot-image'"
+    #elementComponent
+    [parentForm]="form"
+    [elementModel]="elementModel | cast: HotspotImageElement">
+  </aspect-hotspot-image>
   <aspect-dropdown
       *ngIf="elementModel.type === 'dropdown'"
       #elementComponent
diff --git a/projects/player/src/app/components/elements/input-group-element/input-group-element.component.ts b/projects/player/src/app/components/elements/input-group-element/input-group-element.component.ts
index c41bd5b0f4cb4d532f7fb1ae7cb4df5cdc6730c3..4a2942b4b3518bf4c9cecca1b5c394fccc056541 100644
--- a/projects/player/src/app/components/elements/input-group-element/input-group-element.component.ts
+++ b/projects/player/src/app/components/elements/input-group-element/input-group-element.component.ts
@@ -12,6 +12,7 @@ import { RadioButtonGroupElement } from 'common/models/elements/input-elements/r
 import { RadioButtonGroupComplexElement } from 'common/models/elements/input-elements/radio-button-group-complex';
 import { DropdownElement } from 'common/models/elements/input-elements/dropdown';
 import { InputElement } from 'common/models/elements/element';
+import { HotspotImageElement } from 'common/models/elements/input-elements/hotspot-image';
 import { ValidationService } from '../../../services/validation.service';
 import { ElementFormGroupDirective } from '../../../directives/element-form-group.directive';
 import { ElementModelElementCodeMappingService } from '../../../services/element-model-element-code-mapping.service';
@@ -30,6 +31,7 @@ export class InputGroupElementComponent extends ElementFormGroupDirective implem
   RadioButtonGroupElement!: RadioButtonGroupElement;
   RadioButtonGroupComplexElement!: RadioButtonGroupComplexElement;
   DropdownElement!: DropdownElement;
+  HotspotImageElement!: HotspotImageElement;
 
   constructor(
     public unitStateService: UnitStateService,
diff --git a/projects/player/src/app/components/page-scroll-button/page-scroll-button.component.html b/projects/player/src/app/components/page-scroll-button/page-scroll-button.component.html
index ba9a935a287c536326fdb06da560d4f08b23210b..88def98ddac31c2f4b340aca63bf8678c6470d4f 100644
--- a/projects/player/src/app/components/page-scroll-button/page-scroll-button.component.html
+++ b/projects/player/src/app/components/page-scroll-button/page-scroll-button.component.html
@@ -1,5 +1,5 @@
 <ng-content></ng-content>
-<div fxLayout="column" fxLayoutAlign="center end"
+<div fxLayout="column" fxLayoutAlign="center center"
      class="scroll-button-container">
   <button *ngIf="isVisible.value"
           mat-fab
diff --git a/projects/player/src/app/directives/element-form-group.directive.ts b/projects/player/src/app/directives/element-form-group.directive.ts
index 79f238c7a172dcf8136c5e296ccd1ac14350e871..87158bf9b976b6a5568322a2cd4e6c0e09d3666c 100644
--- a/projects/player/src/app/directives/element-form-group.directive.ts
+++ b/projects/player/src/app/directives/element-form-group.directive.ts
@@ -11,6 +11,7 @@ import { VeronaSubscriptionService } from 'player/modules/verona/services/verona
 import { LogService } from 'player/modules/logging/services/log.service';
 import { InputElement, InputElementValue } from 'common/models/elements/element';
 import { SliderElement } from 'common/models/elements/input-elements/slider';
+import { hotspotImageRequiredValidator } from 'player/src/app/validators/hotspot-image-required.validator';
 import { ValidationService } from '../services/validation.service';
 import { ElementGroupDirective } from './element-group.directive';
 import { ElementModelElementCodeMappingService } from '../services/element-model-element-code-mapping.service';
@@ -68,6 +69,9 @@ export abstract class ElementFormGroupDirective extends ElementGroupDirective im
     const validators: ValidatorFn[] = [];
     if (elementModel.required) {
       switch (elementModel.type) {
+        case 'hotspot-image':
+          validators.push(hotspotImageRequiredValidator());
+          break;
         case 'checkbox':
           validators.push(Validators.requiredTrue);
           break;
diff --git a/projects/player/src/app/services/element-model-element-code-mapping.service.spec.ts b/projects/player/src/app/services/element-model-element-code-mapping.service.spec.ts
index b22e66659f2f8d1170302871c2c977688d946abb..4b4d5e95ef802919f00f1d726d56506bf6542130 100644
--- a/projects/player/src/app/services/element-model-element-code-mapping.service.spec.ts
+++ b/projects/player/src/app/services/element-model-element-code-mapping.service.spec.ts
@@ -12,6 +12,7 @@ import * as radioGroupImages_130 from 'test-data/element-models/radio-group-imag
 import * as toggleButton_130 from 'test-data/element-models/toggle-button_130.json';
 import * as textArea_130 from 'test-data/element-models/text-area_130.json';
 import * as spellCorrect_130 from 'test-data/element-models/spell-correct_130.json';
+import * as hotspotImage_135 from 'test-data/element-models/hotspot-image_135.json';
 import * as dragNDropValues_01_130 from 'test-data/values/dragNDropValues_01_130.json';
 import * as dragNDropValues_02_130 from 'test-data/values/dragNDropValues_02_130.json';
 import { DropListElement } from 'common/models/elements/input-elements/drop-list';
@@ -31,7 +32,8 @@ import { RadioButtonGroupElement } from 'common/models/elements/input-elements/r
 import { RadioButtonGroupComplexElement } from 'common/models/elements/input-elements/radio-button-group-complex';
 import { LikertRowElement } from 'common/models/elements/compound-elements/likert/likert-row';
 import { ToggleButtonElement } from 'common/models/elements/compound-elements/cloze/cloze-child-elements/toggle-button';
-import { DragNDropValueObject } from 'common/models/elements/element';
+import { DragNDropValueObject, Hotspot } from 'common/models/elements/element';
+import { HotspotImageElement } from 'common/models/elements/input-elements/hotspot-image';
 import { ElementModelElementCodeMappingService } from './element-model-element-code-mapping.service';
 
 describe('ElementModelElementCodeMappingService', () => {
@@ -99,6 +101,46 @@ describe('ElementModelElementCodeMappingService', () => {
       .toBe(null);
   });
 
+  it('should map the value of a hotspot image elementModel to its elementCode value', () => {
+    const hotspots: Hotspot[] = [
+      {
+        top: 10,
+        left: 10,
+        width: 20,
+        height: 20,
+        shape: 'rect',
+        borderWidth: 1,
+        borderColor: '#000000',
+        backgroundColor: '#000000',
+        rotation: 0,
+        readOnly: false,
+        value: true
+      },
+      {
+        top: 10,
+        left: 10,
+        width: 20,
+        height: 20,
+        shape: 'rect',
+        borderWidth: 1,
+        borderColor: '#000000',
+        backgroundColor: '#000000',
+        rotation: 0,
+        readOnly: false,
+        value: false
+      }
+    ];
+    expect(service.mapToElementCodeValue(hotspots, 'hotspot-image'))
+      .toEqual([true, false]);
+  });
+
+  it('should map the value of a hotspot image elementModel to its elementCode value', () => {
+    const hotspots: Hotspot[] = [];
+
+    expect(service.mapToElementCodeValue(hotspots, 'hotspot-image'))
+      .toEqual([]);
+  });
+
   it('should map the value of a radio-group-images elementModel to its elementCode value', () => {
     for (let i = 0; i < 10; i++) {
       expect(service.mapToElementCodeValue(i, 'radio-group-images'))
@@ -496,4 +538,44 @@ describe('ElementModelElementCodeMappingService', () => {
     expect(service.mapToElementModelValue(undefined, elementModel))
       .toEqual(null);
   });
+
+  it('should map an elementCode value to hotspot-image elementModel value', () => {
+    const elementModel: HotspotImageElement = JSON.parse(JSON.stringify(hotspotImage_135));
+    expect(service.mapToElementModelValue([true], elementModel))
+      .toEqual([
+        {
+          top: 10,
+          left: 10,
+          width: 20,
+          height: 20,
+          shape: 'rect',
+          borderWidth: 1,
+          borderColor: '#000000',
+          backgroundColor: '#000000',
+          rotation: 0,
+          readOnly: false,
+          value: true
+        }
+      ]);
+  });
+
+  it('should map an elementCode value to hotspot-image elementModel value', () => {
+    const elementModel: HotspotImageElement = JSON.parse(JSON.stringify(hotspotImage_135));
+    expect(service.mapToElementModelValue([false], elementModel))
+      .toEqual([
+        {
+          top: 10,
+          left: 10,
+          width: 20,
+          height: 20,
+          shape: 'rect',
+          borderWidth: 1,
+          borderColor: '#000000',
+          backgroundColor: '#000000',
+          rotation: 0,
+          readOnly: false,
+          value: false
+        }
+      ]);
+  });
 });
diff --git a/projects/player/src/app/services/element-model-element-code-mapping.service.ts b/projects/player/src/app/services/element-model-element-code-mapping.service.ts
index d06fa96a1a9cb16263278a949413dd599e054f01..8a49d63cf55dafcf13754a153d810d458018fb5f 100644
--- a/projects/player/src/app/services/element-model-element-code-mapping.service.ts
+++ b/projects/player/src/app/services/element-model-element-code-mapping.service.ts
@@ -1,7 +1,7 @@
 import { Injectable } from '@angular/core';
-import { TextMarkingService } from './text-marking.service';
 import {
   DragNDropValueObject,
+  Hotspot,
   InputElement,
   InputElementValue,
   UIElement,
@@ -12,6 +12,8 @@ import { AudioElement } from 'common/models/elements/media-elements/audio';
 import { VideoElement } from 'common/models/elements/media-elements/video';
 import { ImageElement } from 'common/models/elements/media-elements/image';
 import { GeometryElement } from 'common/models/elements/geometry/geometry';
+import { HotspotImageElement } from 'common/models/elements/input-elements/hotspot-image';
+import { TextMarkingService } from './text-marking.service';
 
 @Injectable({
   providedIn: 'root'
@@ -28,6 +30,11 @@ export class ElementModelElementCodeMappingService {
         return (elementCodeValue !== undefined) ?
           (elementCodeValue as string[]).map(id => this.getDragNDropValueObjectById(id)) as DragNDropValueObject[] :
           (elementModel as InputElement).value;
+      case 'hotspot-image':
+        return (elementCodeValue !== undefined) ?
+          (elementCodeValue as boolean[])
+            .map((v, i) => ({ ...(elementModel as HotspotImageElement).value[i], value: v })) :
+          (elementModel as HotspotImageElement).value;
       case 'text':
         return (elementCodeValue !== undefined) ?
           TextMarkingService
@@ -64,6 +71,8 @@ export class ElementModelElementCodeMappingService {
       case 'drop-list':
       case 'drop-list-simple':
         return (elementModelValue as DragNDropValueObject[]).map(object => object.id);
+      case 'hotspot-image':
+        return (elementModelValue as Hotspot[]).map(hotspot => hotspot.value);
       case 'text':
         return TextMarkingService.getMarkedTextIndices(elementModelValue as string);
       case 'radio':
diff --git a/projects/player/src/app/validators/hotspot-image-required.validator.ts b/projects/player/src/app/validators/hotspot-image-required.validator.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3eead0cc70b4142b0ebd5c6a0d9a6d0583c9f269
--- /dev/null
+++ b/projects/player/src/app/validators/hotspot-image-required.validator.ts
@@ -0,0 +1,8 @@
+import { AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';
+import { Hotspot } from 'common/models/elements/element';
+
+export function hotspotImageRequiredValidator(): ValidatorFn {
+  return (control: AbstractControl): ValidationErrors | null => (
+    (control.value as Hotspot[]).some(hotspot => hotspot.value) ? null : { required: true }
+  );
+}
diff --git a/test-data/element-models/hotspot-image_135.json b/test-data/element-models/hotspot-image_135.json
new file mode 100644
index 0000000000000000000000000000000000000000..4995ffdde83dc1e60a96d6a040a6a370ae42a321
--- /dev/null
+++ b/test-data/element-models/hotspot-image_135.json
@@ -0,0 +1,42 @@
+{
+  "width": 180,
+  "height": 100,
+  "type": "hotspot-image",
+  "id": "hotspot-image_1",
+  "label": "Beschriftung",
+  "value": [
+    {
+      "top": 10,
+      "left": 10,
+      "width": 20,
+      "height": 20,
+      "shape": "rect",
+      "borderWidth": 1,
+      "borderColor": "#000000",
+      "backgroundColor": "#000000",
+      "rotation": 0,
+      "readOnly": false,
+      "value": true
+    }
+  ],
+  "required": false,
+  "requiredWarnMessage": "Eingabe erforderlich",
+  "readOnly": false,
+  "src": "data:image/gif;base64,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",
+  "position": {
+    "fixedSize": false,
+    "dynamicPositioning": true,
+    "xPosition": 0,
+    "yPosition": 0,
+    "useMinHeight": false,
+    "gridColumn": null,
+    "gridColumnRange": 1,
+    "gridRow": null,
+    "gridRowRange": 1,
+    "marginLeft": 0,
+    "marginRight": 0,
+    "marginTop": 0,
+    "marginBottom": 0,
+    "zIndex": 0
+  }
+}